void set_cursor(Window win, int cursor) { XDefineCursor(wglobal.dpy, win, cursors[cursor]); }
static Lock* lockscreen(Display *dpy, int screen) { char curs[] = {0, 0, 0, 0, 0, 0, 0, 0}; unsigned int len; Lock *lock; XColor color, dummy; XSetWindowAttributes wa; Cursor invisible; if(dpy == NULL || screen < 0) { return NULL; } lock = malloc(sizeof(Lock)); if(lock == NULL) { return NULL; } lock->screen = screen; lock->root = RootWindow(dpy, lock->screen); /* init */ wa.override_redirect = 1; wa.background_pixel = BlackPixel(dpy, lock->screen); lock->win = XCreateWindow(dpy, lock->root, 0, 0, DisplayWidth(dpy, lock->screen), DisplayHeight(dpy, lock->screen), 0, DefaultDepth(dpy, lock->screen), CopyFromParent, DefaultVisual(dpy, lock->screen), CWOverrideRedirect | CWBackPixel, &wa); XAllocNamedColor(dpy, DefaultColormap(dpy, lock->screen), COLOR2, &color, &dummy); lock->colors[1] = color.pixel; XAllocNamedColor(dpy, DefaultColormap(dpy, lock->screen), COLOR1, &color, &dummy); lock->colors[0] = color.pixel; lock->pmap = XCreateBitmapFromData(dpy, lock->win, curs, 8, 8); invisible = XCreatePixmapCursor(dpy, lock->pmap, lock->pmap, &color, &color, 0, 0); XDefineCursor(dpy, lock->win, invisible); XMapRaised(dpy, lock->win); for(len = 1000; len; len--) { if(XGrabPointer(dpy, lock->root, False, ButtonPressMask | ButtonReleaseMask | PointerMotionMask, GrabModeAsync, GrabModeAsync, None, invisible, CurrentTime) == GrabSuccess) { break; } usleep(1000); } if(running && (len > 0)) { for(len = 1000; len; len--) { if(XGrabKeyboard(dpy, lock->root, True, GrabModeAsync, GrabModeAsync, CurrentTime) == GrabSuccess) { break; } usleep(1000); } } running &= (len > 0); if(!running) { unlockscreen(dpy, lock); lock = NULL; } else { XSelectInput(dpy, lock->root, SubstructureNotifyMask); unsigned int value = (unsigned int) (opacity * 0xffffffff); XChangeProperty(dpy, lock->win, XInternAtom(dpy, "_NET_WM_WINDOW_OPACITY", False), XA_CARDINAL, 32, PropModeReplace, (unsigned char *) &value, 1L); XSync(dpy, False); } return lock; }
FILE * Format(ManpageGlobals * man_globals, char * entry) { FILE * file = NULL; #ifdef HAS_MKSTEMP int fd; #endif Widget manpage = man_globals->manpagewidgets.manpage; char cmdbuf[BUFSIZ], tmp[BUFSIZ], filename[BUFSIZ], error_buf[BUFSIZ]; char path[BUFSIZ], sect[BUFSIZ]; XEvent event; Position x,y; /* location to pop up the "would you like to save" widget. */ #ifndef HAS_MKSTEMP if ( !UncompressUnformatted(man_globals, entry, filename) ) { #else if ( !UncompressUnformatted(man_globals, entry, filename, &file) ) { #endif /* We Really could not find it, this should never happen, yea right. */ snprintf(error_buf, sizeof(error_buf), "Could not open manual page, %s", entry); PopupWarning(man_globals, error_buf); XtPopdown( XtParent(man_globals->standby) ); return(NULL); } #ifndef HAS_MKSTEMP if ((file = fopen(filename, "r")) != NULL) { #else if (file != NULL) { #endif char line[BUFSIZ]; if (fgets(line, sizeof(line), file) != NULL) { if (strncmp(line, ".so ", 4) == 0) { line[strlen(line) - 1] = '\0'; fclose(file); unlink(filename); if (line[4] != '/') { char *ptr = NULL; strcpy(tmp, entry); if ((ptr = rindex(tmp, '/')) != NULL) { *ptr = '\0'; if ((ptr = rindex(tmp, '/')) != NULL) ptr[1] = '\0'; } } else *tmp = '\0'; snprintf(filename, sizeof(filename), "%s%s", tmp, line + 4); return (Format(man_globals, filename)); } } fclose(file); } Popup(XtParent(man_globals->standby), XtGrabExclusive); while ( !XCheckTypedWindowEvent(XtDisplay(man_globals->standby), XtWindow(man_globals->standby), Expose, &event) ); XtDispatchEvent( &event ); XFlush(XtDisplay(man_globals->standby)); strcpy(tmp,MANTEMP); /* Get a temp file. */ #ifndef HAS_MKSTEMP (void) mktemp(tmp); #else fd = mkstemp(tmp); file = fdopen(fd, "r"); #endif strcpy(man_globals->tempfile, tmp); ParseEntry(entry, path, sect, NULL); #ifndef HANDLE_ROFFSEQ #ifndef HAS_MKSTEMP snprintf(cmdbuf, sizeof(cmdbuf), "cd %s ; %s %s %s > %s %s", path, TBL, filename, FORMAT, man_globals->tempfile, "2> /dev/null"); #else snprintf(cmdbuf, sizeof(cmdbuf), "cd %s ; %s %s %s >> %s %s", path, TBL, filename, FORMAT, man_globals->tempfile, "2> /dev/null"); #endif #else /* Handle more flexible way of specifying the formatting pipeline */ if (! ConstructCommand(cmdbuf, path, filename, man_globals->tempfile)) { sprintf(error_buf, "Constructed command was too long!"); PopupWarning(man_globals, error_buf); file = NULL; } else #endif /* HANDLE_ROFFSEQ */ if(system(cmdbuf) != 0) { /* execute search. */ snprintf(error_buf, sizeof(error_buf), "Something went wrong trying to run the command: %s", cmdbuf); PopupWarning(man_globals, error_buf); file = NULL; } else { #ifndef HAS_MKSTEMP if ((file = fopen(man_globals->tempfile,"r")) == NULL) { sprintf(error_buf, "Something went wrong in retrieving the %s", "temp file, try cleaning up /tmp"); PopupWarning(man_globals, error_buf); } else { #endif XtPopdown( XtParent(man_globals->standby) ); if ( (man_globals->save == NULL) || (man_globals->manpagewidgets.manpage == NULL) ) unlink(man_globals->tempfile); else { char * ptr, catdir[BUFSIZ]; /* * If the catdir is writeable then ask the user if he/she wants to * write the man page to it. */ strcpy(catdir, man_globals->save_file); if ( (ptr = rindex(catdir, '/')) != NULL) { *ptr = '\0'; if ( access(catdir, W_OK) != 0 ) unlink(man_globals->tempfile); else { x = (Position) Width(man_globals->manpagewidgets.manpage)/2; y = (Position) Height(man_globals->manpagewidgets.manpage)/2; XtTranslateCoords(manpage, x, y, &x, &y); PositionCenter( man_globals->save, (int) x, (int) y, 0, 0, 0, 0); XtPopup( man_globals->save, XtGrabExclusive); } } else unlink(man_globals->tempfile); } #ifndef HAS_MKSTEMP } #endif } /* * If the original was compressed or in another format, delete temporary file. */ if (man_globals->deletetempfile) unlink(filename); return(file); } #ifdef HANDLE_ROFFSEQ /* Function Name: ConstructCommand * Description: Constructs the pipeline of commands necessary to format * a manual page. * Arguments: cmdbuf - the buffer into which to write the command * path - the directory in which the original man page resides * filename - the (uncompressed) manpage source file * tempfile - the name of a temporary file to direct the final * output of the pipeline into * Returns: TRUE if the command fit into the buffer, FALSE if it would * be too long (more than BUFSIZ characters) */ static Boolean ConstructCommand(cmdbuf, path, filename, tempfile) char *cmdbuf, *path, *filename, *tempfile; { /* The original code did the following to produce a command line: * sprintf(cmdbuf,"cd %s ; %s %s %s > %s %s", path, TBL, * filename, FORMAT, man_globals->tempfile, "2> /dev/null"); * We are more flexible and follow more or less the algorithm used * by the Linux man command: * + Obtain a string of letters from the following sources in order * of preference: * + a command line option (not implemented in xman; it's probably not * useful) * + the first line of the manpage source, if it is of the form: * '\" <string> * + the MANROFFSEQ environment variable * + a default string; this is "". * + Interpret the string as a pipeline of filters: * + e = eqn g = grap p = pic t = tbl v = vgrind r = refer * + zsoelim is always run as the first preprocessor in any case. * * Strictly speaking we should save a catpage iff the string comes * from the file or is the default. * * You'll notice that we format a man page into ASCII text output and then * attempt to interpret things like L^HL as bold and so forth. This * is so obviously the Wrong Thing it's untrue. */ char *c = cmdbuf; /* current posn in buffer */ int left = BUFSIZ; /* space left in buffer */ int used; char *fmt; FILE *file; char fmtbuf[128]; int gotfmt = 0; /* set to 1 if we got a directive from source */ char *fname = NULL; #ifdef __UNIXOS2__ int i; #endif fmt = NULL; /* If you have a command line option that gives a setting for fmt, set it here. */ if (!fmt) { /* This is the tricky bit: extract a format string from the source file * Annoyingly, filename might be relative or absolute. We cheat and * use system to get the thing to a known absoute filename. */ if (filename[0] == '/') { fname = filename; } else { fname = malloc(strlen(path) + 1 + strlen(filename) + 1); if (!fname) return FALSE; sprintf(fname, "%s/%s", path, filename); } if ((file = fopen(fname, "r")) && (fgets(fmtbuf, sizeof(fmtbuf), file)) && (!memcmp(fmtbuf, "'\\\" ", 4))) { /* that's squote-backslash-dquote-space */ int len; fmt = fmtbuf + 3; len = strlen(fmt); if (len && (fmt[len-1] == '\n')) { fmt[len-1] = 0; gotfmt++; } } if (fname && fname != filename) free(fname); if (!gotfmt) /* not there or some error */ { fmt = getenv("MANROFFSEQ"); } } if (!fmt) { fmt = DEFAULT_MANROFFSEQ; } /* Start with the first fixed part of the command line */ #ifdef __UNIXOS2__ for (i = 0; i < strlen(path); i++) { if (path[i] == '/') path[i] = '\\'; } used = snprintf(c, left, "cd %s & %s %s ", path, ZSOELIM, filename); #else used = snprintf(c, left, "cd %s; %s %s ", path, ZSOELIM, filename); #endif left -= used; c += used; if (left <= 1) return (FALSE); /* Now add preprocessors of the form '| processor' */ for ( ; *fmt; fmt++) { char *filter; switch (*fmt) { case 'e': filter = EQN; break; case 'g': filter = GRAP; break; case 'p': filter = PIC; break; case 't': filter = TBL; break; case 'v': filter = VGRIND; break; case 'r': filter = REFER; break; default: filter = NULL; break; } if (filter) { used = snprintf(c, left, " | %s ", filter); left -= used; c += used; if (left <= 1) return (FALSE); } } /* Now add the fixed trailing part 'formatprog > tempfile 2> /dev/null' */ #ifdef __UNIXOS2__ used = snprintf(c, left, " | %s > %s 2>NUL", FORMAT, tempfile); #else #ifndef HAS_MKSTEMP used = snprintf(c, left, " | %s > %s 2>/dev/null", FORMAT, tempfile); #else used = snprintf(c, left, " | %s >> %s 2>/dev/null", FORMAT, tempfile); #endif #endif /* __UNIXOS2__ */ left -= used; if (left <= 1) return (FALSE); return (TRUE); } #endif /* HANDLE_ROFFSEQ */ /* Function Name: UncompressUnformatted * Description: Finds an uncompressed unformatted manual page. * Arguments: man_globals - the psuedo global structure. * entry - the manual page entry. * RETURNED filename - location to put the name of the file. * Returns: TRUE if the file was found. */ static Boolean #ifndef HAS_MKSTEMP UncompressUnformatted(ManpageGlobals * man_globals, char * entry, char * filename) #else UncompressUnformatted(ManpageGlobals * man_globals, char * entry, char * filename, FILE **file) #endif { char path[BUFSIZ], page[BUFSIZ], section[BUFSIZ], input[BUFSIZ]; int len_cat = strlen(CAT), len_man = strlen(MAN); #if defined(SMAN) && defined(SFORMAT) int len_sman = strlen(SMAN); #endif ParseEntry(entry, path, section, page); man_globals->bzip2 = FALSE; man_globals->lzma = FALSE; #if defined(__OpenBSD__) || defined(__NetBSD__) /* * look for uncompressed file in machine subdir first */ snprintf(filename, BUFSIZ, "%s/%s%s/%s/%s", path, MAN, section + len_cat, MACHINE, page); if ( access( filename, R_OK ) == 0 ) { man_globals->compress = FALSE; man_globals->gzip = FALSE; man_globals->deletetempfile = FALSE; snprintf(man_globals->save_file, sizeof(man_globals->save_file), "%s/%s%s/%s/%s", path, CAT, section + len_cat, MACHINE, page); return(TRUE); } /* * Then for compressed files in an uncompressed directory. */ snprintf(input, sizeof(input), "%s.%s", filename, COMPRESSION_EXTENSION); #ifndef HAS_MKSTEMP if ( UncompressNamed(man_globals, input, filename) ) { #else if ( UncompressNamed(man_globals, input, filename, file) ) { #endif man_globals->compress = TRUE; man_globals->deletetempfile = TRUE; snprintf(man_globals->save_file, sizeof(man_globals->save_file), "%s/%s%s/%s.%s", path, CAT, section + len_cat, page, COMPRESSION_EXTENSION); return(TRUE); } #ifdef GZIP_EXTENSION else { snprintf(input, sizeof(input), "%s.%s", filename, GZIP_EXTENSION); #ifndef HAS_MKSTEMP if ( UncompressNamed(man_globals, input, filename) ) { #else if ( UncompressNamed(man_globals, input, filename, file) ) { #endif man_globals->compress = TRUE; man_globals->gzip = TRUE; man_globals->deletetempfile = TRUE; snprintf(man_globals->save_file, sizeof(man_globals->save_file), "%s/%s%s/%s.%s", path, CAT, section + len_cat, page, GZIP_EXTENSION); return(TRUE); } } #endif /* GZIP_EXTENSION */ #endif /* __OpenBSD__ || __NetBSD__ */ #ifdef BZIP2_EXTENSION { sprintf(input, "%s.%s", filename, BZIP2_EXTENSION); #ifndef HAS_MKSTEMP if ( UncompressNamed(man_globals, input, filename) ) { #else if ( UncompressNamed(man_globals, input, filename, file) ) { #endif man_globals->compress = TRUE; man_globals->gzip = FALSE; man_globals->bzip2 = TRUE; sprintf(man_globals->save_file, "%s/%s%s/%s.%s", path, CAT, section + len_cat, page, BZIP2_EXTENSION); return(TRUE); } } #endif /* BZIP2_EXTENSION */ #ifdef LZMA_EXTENSION { sprintf(input, "%s.%s", filename, LZMA_EXTENSION); #ifndef HAS_MKSTEMP if ( UncompressNamed(man_globals, input, filename) ) { #else if ( UncompressNamed(man_globals, input, filename, file) ) { #endif man_globals->compress = TRUE; man_globals->gzip = FALSE; man_globals->lzma = TRUE; sprintf(man_globals->save_file, "%s/%s%s/%s.%s", path, CAT, section + len_cat, page, LZMA_EXTENSION); return(TRUE); } } #endif /* LZMA_EXTENSION */ /* * Look for uncompressed file first. */ snprintf(filename, BUFSIZ, "%s/%s%s/%s", path, MAN, section + len_man, page); if ( access( filename, R_OK ) == 0 ) { man_globals->compress = FALSE; man_globals->gzip = FALSE; man_globals->deletetempfile = FALSE; snprintf(man_globals->save_file, sizeof(man_globals->save_file), "%s/%s%s/%s", path, CAT, section + len_cat, page); return(TRUE); } #if defined(SMAN) && defined(SFORMAT) /* * Look for uncompressed sgml file next. */ snprintf(input, BUFSIZ, "%s/%s%s/%s", path, SMAN, section + len_sman, page); #ifndef HAS_MKSTEMP if ( SgmlToRoffNamed(man_globals, input, filename) ) { #else if ( SgmlToRoffNamed(man_globals, input, filename, file) ) { #endif man_globals->compress = FALSE; man_globals->gzip = FALSE; man_globals->deletetempfile = TRUE; snprintf(man_globals->save_file, sizeof(man_globals->save_file), "%s/%s%s/%s", path, CAT, section + len_cat, page); return(TRUE); } #endif /* * Then for compressed files in an uncompressed directory. */ snprintf(input, sizeof(input), "%s.%s", filename, COMPRESSION_EXTENSION); #ifndef HAS_MKSTEMP if ( UncompressNamed(man_globals, input, filename) ) { #else if ( UncompressNamed(man_globals, input, filename, file) ) { #endif man_globals->compress = TRUE; man_globals->deletetempfile = TRUE; snprintf(man_globals->save_file, sizeof(man_globals->save_file), "%s/%s%s/%s.%s", path, CAT, section + len_cat, page, COMPRESSION_EXTENSION); return(TRUE); } #ifdef GZIP_EXTENSION else { snprintf(input, sizeof(input), "%s.%s", filename, GZIP_EXTENSION); #ifndef HAS_MKSTEMP if ( UncompressNamed(man_globals, input, filename) ) { #else if ( UncompressNamed(man_globals, input, filename, file) ) { #endif man_globals->compress = TRUE; man_globals->gzip = TRUE; man_globals->deletetempfile = TRUE; snprintf(man_globals->save_file, sizeof(man_globals->save_file), "%s/%s%s/%s.%s", path, CAT, section + len_cat, page, GZIP_EXTENSION); return(TRUE); } } #endif #ifdef BZIP2_EXTENSION { sprintf(input, "%s.%s", filename, BZIP2_EXTENSION); #ifndef HAS_MKSTEMP if ( UncompressNamed(man_globals, input, filename) ) { #else if ( UncompressNamed(man_globals, input, filename, file) ) { #endif man_globals->compress = TRUE; man_globals->gzip = TRUE; sprintf(man_globals->save_file, "%s/%s%s/%s.%s", path, CAT, section + len_cat, page, BZIP2_EXTENSION); return(TRUE); } } #endif #ifdef LZMA_EXTENSION { sprintf(input, "%s.%s", filename, LZMA_EXTENSION); #ifndef HAS_MKSTEMP if ( UncompressNamed(man_globals, input, filename) ) { #else if ( UncompressNamed(man_globals, input, filename, file) ) { #endif man_globals->compress = TRUE; man_globals->lzma = TRUE; sprintf(man_globals->save_file, "%s/%s%s/%s.%s", path, CAT, section + len_cat, page, LZMA_EXTENSION); return(TRUE); } } #endif /* * And lastly files in a compressed directory. */ snprintf(input, sizeof(input), "%s/%s%s.%s/%s", path, MAN, section + len_man, COMPRESSION_EXTENSION, page); #ifndef HAS_MKSTEMP if ( UncompressNamed(man_globals, input, filename) ) { #else if ( UncompressNamed(man_globals, input, filename, file) ) { #endif man_globals->compress = TRUE; man_globals->deletetempfile = TRUE; snprintf(man_globals->save_file, sizeof(man_globals->save_file), "%s/%s%s.%s/%s", path, CAT, section + len_cat, COMPRESSION_EXTENSION, page); return(TRUE); } return(FALSE); } /* Function Name: AddCursor * Description: This function adds the cursor to the window. * Arguments: w - the widget to add the cursor to. * cursor - the cursor to add to this widget. * Returns: none */ void AddCursor(Widget w, Cursor cursor) { XColor colors[2]; Arg args[10]; Cardinal num_args = 0; Colormap c_map; if (!XtIsRealized(w)) { PopupWarning(NULL, "Widget is not realized, no cursor added.\n"); return; } XtSetArg( args[num_args], XtNcolormap, &c_map); num_args++; XtGetValues( w, args, num_args); colors[0].pixel = resources.cursors.fg_color; colors[1].pixel = resources.cursors.bg_color; XQueryColors (XtDisplay(w), c_map, colors, 2); XRecolorCursor(XtDisplay(w), cursor, colors, colors+1); XDefineCursor(XtDisplay(w),XtWindow(w),cursor); } /* Function Name: ChangeLabel * Description: This function changes the label field of the * given widget to the string in str. * Arguments: w - the widget. * str - the string to change the label to. * Returns: none */ void ChangeLabel(Widget w, char * str) { Arg arglist[3]; /* An argument list. */ if (w == NULL) return; XtSetArg(arglist[0], XtNlabel, str); /* shouldn't really have to do this. */ XtSetArg(arglist[1], XtNwidth, 0); XtSetArg(arglist[2], XtNheight, 0); XtSetValues(w, arglist, (Cardinal) 1); } /* * In an ideal world this would be part of the XToolkit, and I would not * have to do it, but such is life sometimes. Perhaps in X11R3. */ /* Function Name: PositionCenter * Description: This function positions the given widgets center * in the following location. * Arguments: widget - the widget widget to postion * x,y - The location for the center of the widget * above - number of pixels above center to locate this widget * left - number of pixels left of center to locate this widget * h_space, v_space - how close to get to the edges of the * parent window. * Returns: none * Note: This should only be used with a popup widget that has override * redirect set. */ void PositionCenter(Widget widget, int x, int y, int above, int left, int v_space, int h_space) { Arg wargs[2]; int x_temp,y_temp; /* location of the new window. */ int parent_height,parent_width; /* Height and width of the parent widget or the root window if it has no parent. */ x_temp = x - left - Width(widget) / 2 + BorderWidth(widget); y_temp = y - above - Height(widget) / 2 + BorderWidth(widget); parent_height = HeightOfScreen(XtScreen(widget)); parent_width = WidthOfScreen(XtScreen(widget)); /* * Check to make sure that all edges are within the viewable part of the * root window, and if not then force them to be. */ if (x_temp < h_space) x_temp = v_space; if (y_temp < v_space) (y_temp = 2); if ( y_temp + Height(widget) + v_space > parent_height ) y_temp = parent_height - Height(widget) - v_space; if ( x_temp + Width(widget) + h_space > parent_width ) x_temp = parent_width - Width(widget) - h_space; XtSetArg(wargs[0], XtNx, x_temp); XtSetArg(wargs[1], XtNy, y_temp); XtSetValues(widget, wargs, 2); } /* Function Name: ParseEntry(entry, path, sect, page) * Description: Parses the manual pages entry filenames. * Arguments: str - the full path name. * path - the path name. RETURNED * sect - the section name. RETURNED * page - the page name. RETURNED * Returns: none. */ void ParseEntry(char *entry, char *path, char *sect, char *page) { char *c, temp[BUFSIZ]; strcpy(temp, entry); c = rindex(temp, '/'); if (c == NULL) PrintError("index failure in ParseEntry."); *c++ = '\0'; if (page != NULL) strcpy(page, c); c = rindex(temp, '/'); if (c == NULL) PrintError("index failure in ParseEntry."); *c++ = '\0'; #if defined(SFORMAT) && defined(SMAN) /* sgmltoroff sometimes puts an extra ./ in the path to .so entries */ if (strcmp(c, ".") == 0) { c = rindex(temp, '/'); if (c == NULL) PrintError("index failure in ParseEntry."); *c++ = '\0'; } #endif #if defined(__OpenBSD__) || defined(__NetBSD__) /* Skip machine subdirectory if present */ if (strcmp(c, MACHINE) == 0) { c = rindex(temp, '/'); if (c == NULL) PrintError("index failure in ParseEntry."); *c++ = '\0'; } #endif if (sect != NULL) strcpy(sect, c); if (path != NULL) strcpy(path, temp); } /* Function Name: GetGlobals * Description: Gets the psuedo globals associated with the * manpage associated with this widget. * Arguments: w - a widget in the manpage. * Returns: the psuedo globals. * Notes: initial_widget is a globals variable. * manglobals_context is a global variable. */ ManpageGlobals * GetGlobals(Widget w) { Widget temp; caddr_t data; while ( (temp = XtParent(w)) != initial_widget && (temp != NULL)) w = temp; if (temp == NULL) XtAppError(XtWidgetToApplicationContext(w), "Xman: Could not locate widget in tree, exiting"); if (XFindContext(XtDisplay(w), XtWindow(w), manglobals_context, &data) != XCSUCCESS) XtAppError(XtWidgetToApplicationContext(w), "Xman: Could not find global data, exiting"); return( (ManpageGlobals *) data); } /* Function Name: SaveGlobals * Description: Saves the psuedo globals on the widget passed * to this function, although GetGlobals assumes that * the data is associated with the popup child of topBox. * Arguments: w - the widget to associate the data with. * globals - data to associate with this widget. * Returns: none. * Notes: WIDGET MUST BE REALIZED. * manglobals_context is a global variable. */ void SaveGlobals(Widget w, ManpageGlobals * globals) { if (XSaveContext(XtDisplay(w), XtWindow(w), manglobals_context, (caddr_t) globals) != XCSUCCESS) XtAppError(XtWidgetToApplicationContext(w), "Xman: Could not save global data, are you out of memory?"); } /* Function Name: RemoveGlobals * Description: Removes the psuedo globals from the widget passed * to this function. * Arguments: w - the widget to remove the data from. * Returns: none. * Notes: WIDGET MUST BE REALIZED. * manglobals_context is a global variable. */ void RemoveGlobals(Widget w) { if (XDeleteContext(XtDisplay(w), XtWindow(w), manglobals_context) != XCSUCCESS) XtAppError(XtWidgetToApplicationContext(w), "Xman: Could not remove global data?"); }
void screen(int width, int height) { int a,r; if ((display=XOpenDisplay(NULL)) == NULL) { fprintf(stderr,"Could not connect to X server; not using X.\n"); exit(1); } scr_ptr = DefaultScreenOfDisplay(display); screen_num = DefaultScreen(display); for(a=0; a<32; a++) { r=XAllocNamedColor(display,DefaultColormap(display,screen_num),\ colornames[a],&screen_color,&exact_color); if(r==0) { fprintf(stderr,"Could not allocate color '%s'.\n",colornames[a]); exit(1); } colors[a]=screen_color.pixel; if(a==0) cursorbg=screen_color; if(a==1) cursorfg=screen_color; } totalw=width*mag; totalh=height*mag; fontwidth=0; fontheight=0; font=XLoadFont(display,fontname); if(font==BadName) { fprintf(stderr,"Font %s not found, trying \"fixed\".\n",fontname); font=XLoadFont(display,"fixed"); if(font==BadName) { fprintf(stderr,"Fixed font not found. Giving up.\n"); exit(1); } } fontinfo=XQueryFont(display,font); fontwidth=XTextWidth(fontinfo,"Z",1); fontheight=fontinfo->ascent+fontinfo->descent; if(statusline) { totalh+=fontheight+2; } main_pixmap=XCreatePixmap(display,DefaultRootWindow(display),\ totalw,totalh,DefaultDepth(display,screen_num)); main_win = XCreateSimpleWindow(display,DefaultRootWindow(display), \ 0,0,totalw,totalh,1,colors[1],colors[0]); the_GC = XCreateGC(display,main_win,0,0); XSetForeground(display,the_GC,0); XSetFont(display,the_GC,font); XStoreName(display,main_win,"xmaze"); XMapWindow(display,main_win); XSelectInput(display, main_win, ButtonReleaseMask|ButtonPressMask|ExposureMask|VisibilityChangeMask); XSetGraphicsExposures(display,the_GC,True); XSetForeground(display,the_GC,colors[bg]); XSetBackground(display,the_GC,colors[bg]); XFillRectangle(display,main_pixmap,the_GC,0,0,totalw,totalh); XFillRectangle(display,main_win,the_GC,0,0,totalw,totalh); XSetForeground(display,the_GC,colors[fg]); // cursor = XCreateFontCursor(display,XC_crosshair); // XDefineCursor(display,main_win,cursor); // // This is why X11 turns off a many budding programmers: // Make the cursor a simple red box: // cursorsource=XCreatePixmap(display,DefaultRootWindow(display),\ mag,mag,1); cursormask=XCreatePixmap(display,DefaultRootWindow(display),\ mag,mag,1); XAllocNamedColor(display,DefaultColormap(display,screen_num),\ colornames[1],&screen_color,&exact_color); cursorbg=screen_color; XAllocNamedColor(display,DefaultColormap(display,screen_num),\ colornames[0],&screen_color,&exact_color); cursorbg=screen_color; gc_mask = GCForeground; xgcv.foreground = 0; gcbg=XCreateGC(display,cursorsource,gc_mask,&xgcv); gc_mask = GCForeground; xgcv.foreground = 1; gcfg=XCreateGC(display,cursorsource,gc_mask,&xgcv); XFillRectangle(display,cursormask,gcfg,0,0,mag,mag); XFillRectangle(display,cursorsource,gcfg,0,0,mag,mag); cursor=XCreatePixmapCursor(display,cursorsource,cursormask,&cursorfg,&cursorbg,mag/2,mag/2); XDefineCursor(display,main_win,cursor); // See how simple that was? wmDeleteMessage = XInternAtom(display, "WM_DELETE_WINDOW", False); XSetWMProtocols(display, main_win, &wmDeleteMessage, 1); expose(); }
static void x11_window(void) { if(fullscreen) { XWindowAttributes attr; Window root = DefaultRootWindow(display); XGetWindowAttributes(display, root, &attr); vid_width = attr.width; vid_height = attr.height; xwin_attr.override_redirect = True; window = XCreateWindow(display, RootWindow(display, xvis->screen), 0, 0, vid_width, vid_height, 0, xvis->depth, InputOutput, xvis->visual, CWBorderPixel | CWColormap | CWEventMask | CWOverrideRedirect , &xwin_attr); XMapRaised(display, window); // window = DefaultRootWindow(display); // XF86VidModeSetViewPort(display, screen, 0, 0); // XWarpPointer(display, None, window, 0, 0, 0, 0, // vid_width/2, vid_height/2); XGrabKeyboard(display, window, True, GrabModeAsync, GrabModeAsync, CurrentTime); // XGrabPointer(display, window, True, // PointerMotionMask | ButtonPressMask | ButtonReleaseMask, // GrabModeAsync, GrabModeAsync, window, None, CurrentTime); XDefineCursor(display, window, cursor_none); } else { xwin_attr.override_redirect = False; window = XCreateWindow(display, RootWindow(display, xvis->screen), oldx, oldy, vid_width, vid_height, 0, xvis->depth, InputOutput, xvis->visual, CWBorderPixel | CWColormap | CWEventMask | CWOverrideRedirect , &xwin_attr); Atom delwm = XInternAtom(display, "WM_DELETE_WINDOW", False); XSetWMProtocols(display, window, &delwm, 1); XSetStandardProperties(display, window, "Kittens", "Kitteh", None, NULL, 0, NULL); XMapRaised(display, window); } glXMakeCurrent(display, window, glx_context); glViewport(0, 0, vid_width, vid_height); if(glXIsDirect(display, glx_context)) { printf("OpenGL w/ DRI init ok!\n"); } else { printf("OpenGL init ok!\n"); } }
void dgaux_gauy_filter(float sigma){ int i,j,k,length_gaussian,length_deriv; float gaussian[SIZE1],deriv_gaussian[SIZE1]; matrix dgaux, dgaux_gauy, total_resul, m; float rmin,rmax,rng; /* Fill in the image with background color */ for(i=0; i<IMAGE_WIDTH; i++) for(j=0; j<IMAGE_HEIGHT; j++) XPutPixel(theXImage_2,i,j,bg); /* Clear the drawing window so the image is displayed again */ XClearArea(XtDisplay(draw_1),XtWindow(draw_2),0,0,0,0,True); /* Associate the watch cursor with the main window */ XDefineCursor(XtDisplay(draw_1), XtWindow(main_window), theCursor); /* Flush the request buffer and wait for all events */ /* and errors to be processed by the server. */ XSync(XtDisplay(draw_1), False); get_gaussian(sigma,gaussian,&length_gaussian); fprintf(stderr,"long de gaussian es %i \n",length_gaussian); for(i=0;i<=length_gaussian;i++) fprintf(stderr,"el gaussian de [%i] es %f \n",i,gaussian[i]); get_derigaussian(sigma,deriv_gaussian,&length_deriv); fprintf(stderr,"long de deriv gaussian es %i \n",length_deriv); for(i=0;i<=length_deriv;i++) fprintf(stderr,"el deriv_gaussian de [%i] es %f \n",i,deriv_gaussian[i]); for(i=0;i<IMAGE_WIDTH;i++) for(j=0;j<IMAGE_HEIGHT;j++) m[i][j]= XGetPixel(theXImage_1,i,j); /* calculates the convolution of the image with the derivative of a */ /* gaussian for the rows */ convo_vectorx(m,deriv_gaussian,length_deriv,&rmax,&rmin,dgaux); /* calculate the smoothing of a gaussian(x) in y direction.*/ convo_vectory(dgaux,gaussian,length_gaussian,&rmax,&rmin, dgaux_gauy); fprintf(stderr,"Maximum is %f, Minimum is %f\n",rmax,rmin); rng=(rmax-rmin); for(i=0;i<IMAGE_WIDTH;i++) for(j=0;j<IMAGE_HEIGHT;j++) total_resul[i][j]=sqrt(pow(dgaux_gauy[i][j],2)); for(i=0;i<IMAGE_WIDTH;i++) for(j=0;j<IMAGE_HEIGHT;j++) XPutPixel(theXImage_2,i,j,(unsigned long) (((float)(total_resul[i][j]-rmin)/rng)*255.0)); /* Copy image into pixmap */ XPutImage(XtDisplay(draw_2), thePixmap_2,image_gc_2, theXImage_2, 0, 0, 0, 0, theXImage_2->width, theXImage_2->height); /* Disassociate the watch cursor from the main window */ XUndefineCursor(XtDisplay(draw_1), XtWindow(main_window)); /* Clear the drawing window so the image is displayed again */ XClearArea(XtDisplay(draw_2),XtWindow(draw_2),0,0,0,0,True); }
static void install_grabs( void ) { int res; int fevent; assert( x11display.dpy && x11display.win ); if( !x11display.features.wmStateFullscreen ) { res = XGrabKeyboard( x11display.dpy, x11display.win, False, GrabModeAsync, GrabModeAsync, CurrentTime ); if( res != GrabSuccess ) { Com_Printf( "Warning: XGrabKeyboard failed\n" ); return; } } XDefineCursor( x11display.dpy, x11display.win, CreateNullCursor( x11display.dpy, x11display.win ) ); res = XGrabPointer( x11display.dpy, x11display.win, True, 0, GrabModeAsync, GrabModeAsync, x11display.win, None, CurrentTime ); if( res != GrabSuccess ) { // TODO: Find a solution to Pointer Grabs at focus changes, which sometimes result // in Grabbing Errors. Like switches from Windowed/Fullscreen to Hidden State. //Com_Printf( "Warning: XGrabPointer failed\n" ); XUngrabKeyboard( x11display.dpy, CurrentTime ); XUndefineCursor( x11display.dpy, x11display.win ); return; } if( in_dgamouse->integer ) { int MajorVersion, MinorVersion; if( XF86DGAQueryVersion( x11display.dpy, &MajorVersion, &MinorVersion ) ) { XF86DGADirectVideo( x11display.dpy, x11display.scr, XF86DGADirectMouse ); XWarpPointer( x11display.dpy, None, x11display.win, 0, 0, 0, 0, x11display.win_width/2, x11display.win_height/2 ); dgamouse = qtrue; } else { // unable to query, probalby not supported Com_Printf( "Failed to detect XF86DGA Mouse\n" ); Cvar_Set( "in_dgamouse", "0" ); dgamouse = qfalse; } } else { XWarpPointer( x11display.dpy, None, x11display.win, 0, 0, 0, 0, x11display.win_width/2, x11display.win_height/2 ); } ignore_one = qtrue; // first mouse update after install_grabs is ignored mx = my = 0; mouse_active = qtrue; in_dgamouse->modified = qfalse; input_active = qtrue; // init X Input method, needed by Xutf8LookupString x11display.im = XOpenIM( x11display.dpy, NULL, NULL, NULL ); x11display.ic = XCreateIC( x11display.im, XNInputStyle, XIMPreeditNothing | XIMStatusNothing, XNClientWindow, x11display.win, NULL ); if ( x11display.ic ) { XGetICValues( x11display.ic, XNFilterEvents, &fevent, NULL ); XSelectInput( x11display.dpy, x11display.win, fevent | x11display.wa.event_mask ); } }
/*-------------------------- TIC ---------------------------------*/ int TIC() { int i, j, im, org_image; char tmp_name[40], tmp_cmd[80]; float rw_loc; FILE *out; /* check that an roi is defined */ if (roi_present != 1) { fprintf(stderr,"An ROI must be drawn before calculating its time course.\n"); return; } /* open output file */ tmpnam(tmp_name); if(!(out = fopen(tmp_name,"w"))){ fprintf(stderr,"Unable to open temporary file\n"); return; } /* define new cursors */ XDefineCursor(theDisp,mainW,waitCursor); XDefineCursor(theDisp,cmdW,waitCursor); XFlush(theDisp); /* save current image position */ org_image = image_number; /* cycle through images and dump results to file */ for (im=0; im<slider_length[current_dim]; im++) { fprintf(stderr,"Processing image %d\r",im+1); image_increment = im - slider_image[current_dim]; New_Image(); draw_roi(roi_x1,roi_y1,roi_x2,roi_y2); roi_stats(roi_x1*(Width-1)/(zWidth-1), roi_y1*(Height-1)/(zHeight-1), roi_x2*(Width-1)/(zWidth-1), roi_y2*(Height-1)/(zHeight-1),1); if (file_format==MINC_FORMAT && RW_valid && minc_volume_info.step[current_dim]!=0 ) { rw_loc = minc_volume_info.start[current_dim] + (float) slider_image[current_dim] * minc_volume_info.step[current_dim]; fprintf(out,"%f %f %f \n",rw_loc,tic_mean,tic_std); } else { fprintf(out,"%d %f %f\n",im+1,tic_mean,tic_std); } } /* display original image */ image_increment = org_image - image_number; New_Image(); draw_roi(roi_x1,roi_y1,roi_x2,roi_y2); /* print plot commands */ fprintf(out,"@s0 type xy \n"); fprintf(out,"@s0 symbol 2 \n"); fprintf(out,"@s0 symbol fill 1 \n"); if (file_format==MINC_FORMAT && RW_valid && minc_volume_info.step[current_dim]!=0 ) { fprintf(out,"@xaxis label \"%s (%s)\"\n", minc_volume_info.dimension_names[current_dim], minc_volume_info.dimension_units[current_dim]); } else if (file_format==MINC_FORMAT) { fprintf(out,"@xaxis label \"Frame (%s)\"\n", minc_volume_info.dimension_names[current_dim]); } else { fprintf(out,"@xaxis label \"Image Number\"\n"); } fprintf(out,"@yaxis label \"ROI Mean\"\n"); fprintf(out,"@title \"%s\"\n",basfname); fprintf(out,"@frame fill on\n"); fprintf(out,"@frame background color 7\n"); /* close file */ fclose(out); fprintf(stderr," \r"); /* issue shell commands */ if (GRACE) { sprintf(tmp_cmd,"cat %s | xmgrace -pipe &\n",tmp_name); } else { sprintf(tmp_cmd,"cat %s | xmgr -xy -source stdin &\n",tmp_name); } system (tmp_cmd); sprintf(tmp_cmd,"rm %s &\n",tmp_name); system (tmp_cmd); /* define new cursors */ XDefineCursor(theDisp,mainW,mainCursor); XDefineCursor(theDisp,cmdW,cmdCursor); XFlush(theDisp); }
void MainLoop() override { bool fullscreen = SConfig::GetInstance().m_LocalCoreStartupParameter.bFullscreen; if (fullscreen) { X11Utils::ToggleFullscreen(dpy, win); #if defined(HAVE_XRANDR) && HAVE_XRANDR XRRConfig->ToggleDisplayMode(True); #endif } // The actual loop while (running) { XEvent event; KeySym key; for (int num_events = XPending(dpy); num_events > 0; num_events--) { XNextEvent(dpy, &event); switch (event.type) { case KeyPress: key = XLookupKeysym((XKeyEvent*)&event, 0); if (key == XK_Escape) { if (Core::GetState() == Core::CORE_RUN) { if (SConfig::GetInstance().m_LocalCoreStartupParameter.bHideCursor) XUndefineCursor(dpy, win); Core::SetState(Core::CORE_PAUSE); } else { if (SConfig::GetInstance().m_LocalCoreStartupParameter.bHideCursor) XDefineCursor(dpy, win, blankCursor); Core::SetState(Core::CORE_RUN); } } else if ((key == XK_Return) && (event.xkey.state & Mod1Mask)) { fullscreen = !fullscreen; X11Utils::ToggleFullscreen(dpy, win); #if defined(HAVE_XRANDR) && HAVE_XRANDR XRRConfig->ToggleDisplayMode(fullscreen); #endif } else if (key >= XK_F1 && key <= XK_F8) { int slot_number = key - XK_F1 + 1; if (event.xkey.state & ShiftMask) State::Save(slot_number); else State::Load(slot_number); } else if (key == XK_F9) Core::SaveScreenShot(); else if (key == XK_F11) State::LoadLastSaved(); else if (key == XK_F12) { if (event.xkey.state & ShiftMask) State::UndoLoadState(); else State::UndoSaveState(); } break; case FocusIn: rendererHasFocus = true; if (SConfig::GetInstance().m_LocalCoreStartupParameter.bHideCursor && Core::GetState() != Core::CORE_PAUSE) XDefineCursor(dpy, win, blankCursor); break; case FocusOut: rendererHasFocus = false; if (SConfig::GetInstance().m_LocalCoreStartupParameter.bHideCursor) XUndefineCursor(dpy, win); break; case ClientMessage: if ((unsigned long) event.xclient.data.l[0] == XInternAtom(dpy, "WM_DELETE_WINDOW", False)) running = false; break; } } if (!fullscreen) { Window winDummy; unsigned int borderDummy, depthDummy; XGetGeometry(dpy, win, &winDummy, &SConfig::GetInstance().m_LocalCoreStartupParameter.iRenderWindowXPos, &SConfig::GetInstance().m_LocalCoreStartupParameter.iRenderWindowYPos, (unsigned int *)&SConfig::GetInstance().m_LocalCoreStartupParameter.iRenderWindowWidth, (unsigned int *)&SConfig::GetInstance().m_LocalCoreStartupParameter.iRenderWindowHeight, &borderDummy, &depthDummy); } usleep(100000); } }
void X11KeyFaker::connect() { // Open the display. dpy = XOpenDisplay(displayName.toLatin1().data()); if (!dpy) { // Try again in a few milliseconds. Xnest may not be alive yet. // Give up after 10 seconds. if (++retryCount < 50) QTimer::singleShot(200, this, SLOT(connect())); else QTimer::singleShot(0, this, SIGNAL(couldNotConnect())); return; } // Query the XTest extension, which we need to fake the key events. int event_base, error_base, major, minor; if (!XTestQueryExtension (dpy, &event_base, &error_base, &major, &minor)) { XCloseDisplay(dpy); dpy = 0; QTimer::singleShot(0, this, SIGNAL(couldNotConnect())); return; } // Modify the Xnest's keyboard mappings to add Qtopia's special keysyms. int min_keycode = 1, max_keycode = 255; XDisplayKeycodes(dpy, &min_keycode, &max_keycode); bool ok = true; for (KeySym key = QTOPIAXK_Max; key >= QTOPIAXK_Min; --key) { // This is an extension keysym, not part of the standard X11 set. if (!allocateSpecialKeysym(dpy, min_keycode, max_keycode, key)) { ok = false; break; } } static const KeySym specials[] = { XF86XK_Back, // Qt::Key_Back XF86XK_AudioLowerVolume, // Qt::Key_VolumeUp XF86XK_AudioRaiseVolume, // Qt::Key_VolumeDown XK_F28, // Qt::Key_F28 NoSymbol }; int index = 0; while (ok && specials[index] != NoSymbol) { // This is a standard X11/XFree86 keysym that Qtopia uses, // but it may not be on the user's physical keyboard. if (!allocateSpecialKeysym (dpy, min_keycode, max_keycode, specials[index])) ok = false; ++index; } if (!ok) qWarning() << "There are insufficient spare X11 keycodes to allocate the special Qtopia keys"; // Change the root cursor to something more reasonable than "X". Cursor cursor = XCreateFontCursor(dpy, XC_left_ptr); XDefineCursor(dpy, RootWindow(dpy, DefaultScreen(dpy)), cursor); // Look up the shift keys. shiftKeycode = XKeysymToKeycode(dpy, XK_Shift_L); if (shiftKeycode == NoSymbol) shiftKeycode = XKeysymToKeycode(dpy, XK_Shift_R); modeSwitchKeycode = XKeysymToKeycode(dpy, XK_Mode_switch); // Make sure all of the above changes are flushed. XFlush(dpy); // Set up event handling for the display. QSocketNotifier *notifier = new QSocketNotifier (ConnectionNumber(dpy), QSocketNotifier::Read, this); QObject::connect(notifier, SIGNAL(activated(int)), this, SLOT(readyRead())); // Make sure the file descriptor is not inherited across exec's. fcntl(ConnectionNumber(dpy), F_SETFD, 1); // Notify interested parties that we are now connected to the X display. QTimer::singleShot(0, this, SIGNAL(connected())); }
int x_wglbtn(int bouton) { wglfshlb(); XDefineCursor(wglDisp,wglWin,croix); while (True) { XtAppNextEvent(SuperWidget.contexte, &wglEvent); switch(wglEvent.type) { case ButtonPress: if (wglEvent.xbutton.window != wglWin) { XDefineCursor(wglDisp,wglWin,None); XBell(wglDisp, 0); } else { XDefineCursor(wglDisp,wglWin,None); switch(bouton) { case BGAUCH: switch(wglEvent.xbutton.button) { case Button1: return True; default: return False; } case BMLIEU: switch(wglEvent.xbutton.button) { case Button2: return True; default: return False; } case BDROIT: switch(wglEvent.xbutton.button) { case Button3: return True; default: return False; } case BTOUS: switch(wglEvent.xbutton.button) { case Button1: case Button2: case Button3: return True; default: return False; } } } default: XtDispatchEvent(&wglEvent); } } XDefineCursor(wglDisp,wglWin,None); }
static bool xdpy_set_system_mouse_cursor(ALLEGRO_DISPLAY *display, ALLEGRO_SYSTEM_MOUSE_CURSOR cursor_id) { ALLEGRO_DISPLAY_XGLX *glx = (ALLEGRO_DISPLAY_XGLX *)display; ALLEGRO_SYSTEM_XGLX *system = (ALLEGRO_SYSTEM_XGLX *)al_get_system_driver(); Display *xdisplay = system->x11display; Window xwindow = glx->window; unsigned int cursor_shape; switch (cursor_id) { case ALLEGRO_SYSTEM_MOUSE_CURSOR_DEFAULT: case ALLEGRO_SYSTEM_MOUSE_CURSOR_ARROW: case ALLEGRO_SYSTEM_MOUSE_CURSOR_PROGRESS: cursor_shape = XC_left_ptr; break; case ALLEGRO_SYSTEM_MOUSE_CURSOR_BUSY: cursor_shape = XC_watch; break; case ALLEGRO_SYSTEM_MOUSE_CURSOR_QUESTION: cursor_shape = XC_question_arrow; break; case ALLEGRO_SYSTEM_MOUSE_CURSOR_EDIT: cursor_shape = XC_xterm; break; case ALLEGRO_SYSTEM_MOUSE_CURSOR_MOVE: cursor_shape = XC_fleur; break; case ALLEGRO_SYSTEM_MOUSE_CURSOR_RESIZE_N: cursor_shape = XC_top_side; break; case ALLEGRO_SYSTEM_MOUSE_CURSOR_RESIZE_S: cursor_shape = XC_bottom_side; break; case ALLEGRO_SYSTEM_MOUSE_CURSOR_RESIZE_E: cursor_shape = XC_right_side; break; case ALLEGRO_SYSTEM_MOUSE_CURSOR_RESIZE_W: cursor_shape = XC_left_side; break; case ALLEGRO_SYSTEM_MOUSE_CURSOR_RESIZE_NE: cursor_shape = XC_top_right_corner; break; case ALLEGRO_SYSTEM_MOUSE_CURSOR_RESIZE_SW: cursor_shape = XC_bottom_left_corner; break; case ALLEGRO_SYSTEM_MOUSE_CURSOR_RESIZE_NW: cursor_shape = XC_top_left_corner; break; case ALLEGRO_SYSTEM_MOUSE_CURSOR_RESIZE_SE: cursor_shape = XC_bottom_right_corner; break; case ALLEGRO_SYSTEM_MOUSE_CURSOR_PRECISION: cursor_shape = XC_crosshair; break; case ALLEGRO_SYSTEM_MOUSE_CURSOR_LINK: cursor_shape = XC_hand2; break; case ALLEGRO_SYSTEM_MOUSE_CURSOR_ALT_SELECT: cursor_shape = XC_hand1; break; case ALLEGRO_SYSTEM_MOUSE_CURSOR_UNAVAILABLE: cursor_shape = XC_X_cursor; break; default: return false; } _al_mutex_lock(&system->lock); glx->current_cursor = XCreateFontCursor(xdisplay, cursor_shape); /* XXX: leak? */ if (!glx->cursor_hidden) { XDefineCursor(xdisplay, xwindow, glx->current_cursor); } _al_mutex_unlock(&system->lock); return true; }
/* * Set the cursor image to be used for the current window */ void fgSetCursor ( SFG_Window *window, int cursorID ) { #if TARGET_HOST_UNIX_X11 { Cursor cursor; /* * XXX FULL_CROSSHAIR demotes to plain CROSSHAIR. Old GLUT allows * for this, but if there is a system that easily supports a full- * window (or full-screen) crosshair, we might consider it. */ int cursorIDToUse = ( cursorID == GLUT_CURSOR_FULL_CROSSHAIR ) ? GLUT_CURSOR_CROSSHAIR : cursorID; if( ( cursorIDToUse >= 0 ) && ( cursorIDToUse < sizeof( cursorCache ) / sizeof( cursorCache[0] ) ) ) { cursorCacheEntry *entry = &cursorCache[ cursorIDToUse ]; if( entry->cachedCursor == None ) { entry->cachedCursor = XCreateFontCursor( fgDisplay.Display, entry->cursorShape ); } cursor = entry->cachedCursor; } else { switch( cursorIDToUse ) { case GLUT_CURSOR_NONE: cursor = getEmptyCursor( ); break; case GLUT_CURSOR_INHERIT: cursor = None; break; default: fgError( "Unknown cursor type: %d", cursorIDToUse ); return; } } if ( ( cursorIDToUse != GLUT_CURSOR_NONE ) && ( cursor == None ) ) { fgError( "Failed to create cursor" ); } XDefineCursor( fgDisplay.Display, window->Window.Handle, cursor ); } #elif TARGET_HOST_WIN32 || TARGET_HOST_WINCE /* * This is a temporary solution only... */ /* Set the cursor AND change it for this window class. */ # define MAP_CURSOR(a,b) \ case a: \ SetCursor( LoadCursor( NULL, b ) ); \ SetClassLong( window->Window.Handle, \ GCL_HCURSOR, \ ( LONG )LoadCursor( NULL, b ) ); \ break; /* Nuke the cursor AND change it for this window class. */ # define ZAP_CURSOR(a,b) \ case a: \ SetCursor( NULL ); \ SetClassLong( window->Window.Handle, \ GCL_HCURSOR, ( LONG )NULL ); \ break; switch( cursorID ) { MAP_CURSOR( GLUT_CURSOR_RIGHT_ARROW, IDC_ARROW ); MAP_CURSOR( GLUT_CURSOR_LEFT_ARROW, IDC_ARROW ); MAP_CURSOR( GLUT_CURSOR_INFO, IDC_HELP ); MAP_CURSOR( GLUT_CURSOR_DESTROY, IDC_CROSS ); MAP_CURSOR( GLUT_CURSOR_HELP, IDC_HELP ); MAP_CURSOR( GLUT_CURSOR_CYCLE, IDC_SIZEALL ); MAP_CURSOR( GLUT_CURSOR_SPRAY, IDC_CROSS ); MAP_CURSOR( GLUT_CURSOR_WAIT, IDC_WAIT ); MAP_CURSOR( GLUT_CURSOR_TEXT, IDC_IBEAM ); MAP_CURSOR( GLUT_CURSOR_CROSSHAIR, IDC_CROSS ); MAP_CURSOR( GLUT_CURSOR_UP_DOWN, IDC_SIZENS ); MAP_CURSOR( GLUT_CURSOR_LEFT_RIGHT, IDC_SIZEWE ); MAP_CURSOR( GLUT_CURSOR_TOP_SIDE, IDC_ARROW ); /* XXX ToDo */ MAP_CURSOR( GLUT_CURSOR_BOTTOM_SIDE, IDC_ARROW ); /* XXX ToDo */ MAP_CURSOR( GLUT_CURSOR_LEFT_SIDE, IDC_ARROW ); /* XXX ToDo */ MAP_CURSOR( GLUT_CURSOR_RIGHT_SIDE, IDC_ARROW ); /* XXX ToDo */ MAP_CURSOR( GLUT_CURSOR_TOP_LEFT_CORNER, IDC_SIZENWSE ); MAP_CURSOR( GLUT_CURSOR_TOP_RIGHT_CORNER, IDC_SIZENESW ); MAP_CURSOR( GLUT_CURSOR_BOTTOM_RIGHT_CORNER, IDC_SIZENWSE ); MAP_CURSOR( GLUT_CURSOR_BOTTOM_LEFT_CORNER, IDC_SIZENESW ); MAP_CURSOR( GLUT_CURSOR_INHERIT, IDC_ARROW ); /* XXX ToDo */ ZAP_CURSOR( GLUT_CURSOR_NONE, NULL ); MAP_CURSOR( GLUT_CURSOR_FULL_CROSSHAIR, IDC_CROSS ); /* XXX ToDo */ default: fgError( "Unknown cursor type: %d", cursorID ); break; } #endif window->State.Cursor = cursorID; }
void ScrollBarOn (XtermWidget xw, int init, int doalloc) { #ifdef MOTIF Cursor arrowCursor; #endif /* MOTIF */ register TScreen *screen = &xw->screen; register int i, j, k; if(screen->fullVwin.scrollbar) return; if (init) { /* then create it only */ if (screen->scrollWidget) return; /* make it a dummy size and resize later */ if ((screen->scrollWidget = CreateScrollBar (xw, -1, -1, 5)) == NULL) { Bell(XkbBI_MinorError,0); return; } return; } if (!screen->scrollWidget) { Bell (XkbBI_MinorError,0); Bell (XkbBI_MinorError,0); return; } if (doalloc && screen->allbuf) { /* FIXME: this is not integrated well with Allocate */ if((screen->allbuf = (ScrnBuf) realloc((char *) screen->visbuf, (unsigned) MAX_PTRS*(screen->max_row + 2 + screen->savelines) * sizeof(char *))) == NULL) Error (ERROR_SBRALLOC); screen->visbuf = &screen->allbuf[MAX_PTRS * screen->savelines]; memmove( (char *)screen->visbuf, (char *)screen->allbuf, MAX_PTRS * (screen->max_row + 2) * sizeof (char *)); for (i = k = 0; i < screen->savelines; i++) { k += BUF_HEAD; for (j = BUF_HEAD; j < MAX_PTRS; j++) { if((screen->allbuf[k++] = (Char *)calloc((unsigned) screen->max_col + 1, sizeof(Char))) == NULL) Error (ERROR_SBRALLOC2); } } } ResizeScrollBar (screen); XtRealizeWidget (screen->scrollWidget); #ifdef MOTIF /* define pointer cursor for it */ arrowCursor = XCreateFontCursor(XtDisplay(screen->scrollWidget), XC_left_ptr); XDefineCursor(XtDisplay(screen->scrollWidget), XtWindow(screen->scrollWidget), arrowCursor); XFreeCursor(XtDisplay(screen->scrollWidget), arrowCursor); #endif /* MOTIF */ screen->fullVwin.scrollbar = screen->scrollWidget->core.width + screen->scrollWidget->core.border_width; ScrollBarDrawThumb(screen->scrollWidget); DoResizeScreen (xw); #ifdef SCROLLBAR_RIGHT /* * Adjust the scrollbar position if we're asked to turn on scrollbars * for the first time after the xterm is already running. That makes * the window grow after we've initially configured the scrollbar's * position. (There must be a better way). */ if (term->misc.useRight && screen->fullVwin.fullwidth < term->core.width) XtVaSetValues(screen->scrollWidget, XtNx, screen->fullVwin.fullwidth - screen->scrollWidget->core.border_width, NULL); #endif XtMapWidget(screen->scrollWidget); update_scrollbar (); if (screen->visbuf) { XClearWindow (screen->display, XtWindow (term)); Redraw (); } }
/* pow(gradient,2) = pow(differencex,2)+pow(differencey,2) */ void gradient_filter(){ int i,j,first; matrix m; float mask[2]={1,-1}; matrix dx, dy, gradient; float rmax, rmin, rng; /* Fill in the image with background color */ for(i=0; i<IMAGE_WIDTH; i++) for(j=0; j<IMAGE_HEIGHT; j++) XPutPixel(theXImage_2,i,j,bg); /* Clear the drawing window so the image is displayed again */ XClearArea(XtDisplay(draw_1),XtWindow(draw_2),0,0,0,0,True); /* Associate the watch cursor with the main window */ XDefineCursor(XtDisplay(draw_1), XtWindow(main_window), theCursor); /* Flush the request buffer and wait for all events */ /* and errors to be processed by the server. */ XSync(XtDisplay(draw_1), False); /* Storing the image in a matrix */ for(i=0;i<IMAGE_WIDTH;i++) for(j=0;j<IMAGE_HEIGHT;j++) m[i][j]= XGetPixel(theXImage_1,i,j); /* Taking differences between the values of horizontally adjacent pixels */ convo_vectorx(m, mask, 1, &rmax, &rmin, dx); /* Taking differences between the values of vertical adjacent pixels */ convo_vectory(m, mask, 1, &rmax, &rmin, dy); first=1; for(i=0;i<IMAGE_WIDTH;i++) for(j=0;j<IMAGE_HEIGHT;j++){ gradient[i][j] = sqrt(pow(dx[i][j],2)+pow(dy[i][j],2)); if (first==1){ rmax = gradient[i][j]; rmin = rmax; first = 2;} if (gradient[i][j]<rmin) rmin = gradient[i][j]; if (gradient[i][j]>rmax) rmax = gradient[i][j]; } rng = (rmax-rmin); for(i=0;i<512;i++) for(j=0;j<511;j++) XPutPixel(theXImage_2,i,j,(unsigned long) (((float)(gradient[i][j]-rmin)/rng)*255.0)); /* Copy image into pixmap */ XPutImage(XtDisplay(draw_2), thePixmap_2, image_gc_2, theXImage_2, 0, 0, 0, 0, theXImage_2->width, theXImage_2->height); /* Disassociate the watch cursor from the main window */ XUndefineCursor(XtDisplay(draw_1), XtWindow(main_window)); /* Clear the drawing window so the image is displayed again */ XClearArea(XtDisplay(draw_2),XtWindow(draw_2),0,0,0,0,True); }
void X11Window::show_system_cursor() { XDefineCursor(handle.display, handle.window, system_cursor); }
void d2gaussian_filter(float sigma){ int i,j,length_d2gaussian,lon,start; float rmax, rmin, rng, value, mask_d2gaussian[SIZE2][SIZE2]; float d2gaussian[SIZE1]; matrix m,resul,d2erix,d2eriy; /* Fill in the image with background color */ for(i=0; i<IMAGE_WIDTH; i++) for(j=0; j<IMAGE_HEIGHT; j++) XPutPixel(theXImage_2,i,j,bg); /* Clear the drawing window so the image is displayed again */ XClearArea(XtDisplay(draw_1),XtWindow(draw_2),0,0,0,0,True); /* Associate the watch cursor with the main window */ XDefineCursor(XtDisplay(draw_1), XtWindow(main_window), theCursor); /* Flush the request buffer and wait for all events */ /* and errors to be processed by the server. */ XSync(XtDisplay(draw_1), False); /* Storing the matrix we want to process in m */ for(i=0;i<IMAGE_WIDTH;i++) for(j=0;j<IMAGE_HEIGHT;j++) m[i][j]= XGetPixel(theXImage_1,i,j); get_2derigaussian(sigma, d2gaussian, &length_d2gaussian); fprintf(stderr,"la long es %i \n",length_d2gaussian); /* Only the values higher than 0.01 are desirable */ start=0; value=pow(d2gaussian[0],2); fprintf(stderr,"el top es %f\n",top); while (value<0.01*pow(top,2)){ start += 1; value = pow(d2gaussian[start],2); } for(i=start;i<=length_d2gaussian-start;i++) for(j=start;j<=length_d2gaussian-start;j++){ mask_d2gaussian[i-start][j-start]= d2gaussian[i]*d2gaussian[j]; fprintf(stderr,"la %i,%i es %f, \n",i-start,j-start, mask_d2gaussian[i-start][j-start]); } length_d2gaussian = length_d2gaussian - (2*start); fprintf(stderr,"la long es %i \n",length_d2gaussian); convolution(m,mask_d2gaussian,length_d2gaussian,&rmax,&rmin,resul); /* convo_vectorx(m,d2gaussian,length_d2gaussian,&rmax,&rmin,d2erix); convo_vectory(m,d2gaussian,length_d2gaussian,&rmax,&rmin,d2eriy); for(i=0;i<IMAGE_WIDTH;i++) for(j=0;j<IMAGE_HEIGHT;j++){ resul[i][j]=sqrt(pow(d2erix[i][j],2)+pow(d2eriy[i][j],2)); if (i==0 && j==0){rmax=resul[0][0]; rmin=rmax;} if (resul[i][j]>rmax) rmax=resul[i][j]; if (resul[i][j]<rmin) rmin=resul[i][j]; } rng=(rmax-rmin); for(i=0;i<IMAGE_WIDTH;i++) for(j=0;j<IMAGE_HEIGHT;j++) XPutPixel(theXImage_2,i,j,(unsigned long) (((float)(resul[i][j]-rmin)/rng)*255.0));*/ rng = (float) (rmax - rmin); lon = length_d2gaussian/2; /* Now compute the convolution, scaling. */ for (i=lon; i<IMAGE_WIDTH-lon; i++) for (j=lon; j<IMAGE_HEIGHT-lon; j++) XPutPixel(theXImage_2,i,j, (unsigned long) (((float)(resul[i][j]-rmin)/rng)*255.0)); /* Copy image into pixmap. */ XPutImage(XtDisplay(draw_2), thePixmap_2,image_gc_2, theXImage_2, 0, 0, 0, 0, theXImage_2->width, theXImage_2->height); /* Disassociate the watch cursor from the main window */ XUndefineCursor(XtDisplay(draw_1), XtWindow(main_window)); /* Clear the drawing window so the image is displayed again */ XClearArea(XtDisplay(draw_2),XtWindow(draw_2),0,0,0,0,True); }
void X11Window::hide_system_cursor() { XDefineCursor(handle.display, handle.window, hidden_cursor); }
/* Gradient_x_y = sqrt(pow(gaussian_x,2)+pow(gaussian_y,2) */ void gradient_x_y_filter(float sigma){ int i,j,k,length_deriv; float deriv_gaussian[SIZE1]; matrix dgaux, dgauy, gradient_x_y, m; float rmin,rmax,rng; /* Fill in the image with background color */ for(i=0; i<IMAGE_WIDTH; i++) for(j=0; j<IMAGE_HEIGHT; j++) XPutPixel(theXImage_2,i,j,bg); /* Clear the drawing window so the image is displayed again */ XClearArea(XtDisplay(draw_1),XtWindow(draw_2),0,0,0,0,True); /* Associate the watch cursor with the main window */ XDefineCursor(XtDisplay(draw_1), XtWindow(main_window), theCursor); /* Flush the request buffer and wait for all events */ /* and errors to be processed by the server. */ XSync(XtDisplay(draw_1), False); get_derigaussian(sigma,deriv_gaussian,&length_deriv); for(i=0;i<IMAGE_WIDTH;i++) for(j=0;j<IMAGE_HEIGHT;j++) m[i][j]= XGetPixel(theXImage_1,i,j); /* Apply convolution with derivative of a gaussian to the rows */ convo_vectorx(m,deriv_gaussian,length_deriv,&rmax,&rmin,dgaux); /* Apply convolution with derivative of a gaussian to the columns */ convo_vectory(m,deriv_gaussian,length_deriv,&rmax,&rmin,dgauy); for(i=0;i<IMAGE_WIDTH;i++) for(j=0;j<IMAGE_HEIGHT;j++){ gradient_x_y[i][j]=sqrt(pow(dgaux[i][j],2)+ pow(dgauy[i][j],2)); if (i==0 && j==0){rmax=gradient_x_y[0][0]; rmin=rmax;} if (gradient_x_y[i][j]>rmax) rmax=gradient_x_y[i][j]; if (gradient_x_y[i][j]<rmin) rmin=gradient_x_y[i][j]; } rng=(rmax-rmin); for(i=0;i<IMAGE_WIDTH;i++) for(j=0;j<IMAGE_HEIGHT;j++) XPutPixel(theXImage_2,i,j,(unsigned long) (((float)(gradient_x_y[i][j]-rmin)/rng)*255.0)); /* Copy image into pixmap */ XPutImage(XtDisplay(draw_2), thePixmap_2,image_gc_2, theXImage_2, 0, 0, 0, 0, theXImage_2->width, theXImage_2->height); /* Disassociate the watch cursor from the main window */ XUndefineCursor(XtDisplay(draw_1), XtWindow(main_window)); /* Clear the drawing window so the image is displayed again */ XClearArea(XtDisplay(draw_2),XtWindow(draw_2),0,0,0,0,True); }
//////////////////////////////////////////////////////////// /// /see WindowImpl::ShowMouseCursor //////////////////////////////////////////////////////////// void WindowImplX11::ShowMouseCursor(bool Show) { XDefineCursor(ourDisplay, myWindow, Show ? None : myHiddenCursor); XFlush(ourDisplay); }
void keypress(XEvent *ev) { XKeyEvent *e = &ev->xkey; KeySym sym = XkbKeycodeToKeysym(dpy, (KeyCode)e->keycode, 0, 0); int mod = ((e->state & ~Mod2Mask) & ~LockMask); if (mod == (ControlMask | ShiftMask)) { if (sym == XK_q) { spect->fex = 0; running = False; } if (sym == XK_j || sym == XK_Down) threshold(-0.05); else if (sym == XK_k || sym == XK_Up) threshold(0.05); else if (sym == XK_h || sym == XK_Left) sp_floor(-0.05); else if (sym == XK_l || sym == XK_Right) sp_floor(0.05); else if (sym == XK_p) play(0.1666); } else if (mod == (Mod1Mask | ShiftMask)) { if (sym == XK_p) play(0.08333); } else if (mod == ControlMask) { if (sym == XK_q) running = False; else if (sym == XK_f) series_export(); else if (sym == XK_s) screenshot(); else if (sym == XK_i) img_draw(); else if (sym == XK_j || sym == XK_Down) zoom(-0.025); else if (sym == XK_k || sym == XK_Up) zoom(0.025); else if (sym == XK_h || sym == XK_Left) return; else if (sym == XK_l || sym == XK_Right) return; else if (sym == XK_p) play(0.33); } else if (mod == Mod1Mask) { if (sym == XK_j || sym == XK_Down) eraser_cursor(-1,-1); else if (sym == XK_k || sym == XK_Up) eraser_cursor(1,1); else if (sym == XK_h || sym == XK_Left) eraser_cursor(-1,1); else if (sym == XK_l || sym == XK_Right) eraser_cursor(1,-1); else if (sym == XK_p) play(0.25); } else if (mod == ShiftMask) { if (sym == XK_j || sym == XK_Down) pt_line(-0.2,0); else if (sym == XK_k || sym == XK_Up) pt_line(0.2,0); else if (sym == XK_h || sym == XK_Left) pt_line(0,-0.2); else if (sym == XK_l || sym == XK_Right) pt_line(0,0.2); else if (sym == XK_p) play(0.5); } else if (sym == XK_j || sym == XK_Down) move(0,0.02); else if (sym == XK_k || sym == XK_Up) move(0,-0.02); else if (sym == XK_h || sym == XK_Left) move(0.02,0); else if (sym == XK_l || sym == XK_Right) move(-0.02,0); else if (sym == XK_F1) { if (fork() == 0) { close(ConnectionNumber(dpy)); fclose(stderr); fclose(stdout); execvp(conf.help_cmd[0],(char * const *)conf.help_cmd); } } else if (sym == XK_F2) { if ( (info->vis = !info->vis) ) XMapRaised(dpy,info->win); else XUnmapWindow(dpy,info->win); XFlush(dpy); } else if (sym == XK_e) { //mode = MODE_ERASE & (mode ^= MODE_ERASE); mode = (mode & MODE_ERASE ? 0 : MODE_ERASE); eraser_cursor(0,0); info->draw(info); } else if (sym == XK_c) { //mode = MODE_CROP & (mode ^= MODE_CROP); mode = (mode & MODE_CROP ? 0 : MODE_CROP); if (!(mode & MODE_CROP)) XDefineCursor(dpy, win, None); else XDefineCursor(dpy, win, XCreateFontCursor(dpy, 34)); info->draw(info); } else if (sym == XK_Escape) { mode = MODE_NULL; XDefineCursor(dpy, win, None); info->draw(info); } else if (sym == XK_p) play(1.0); else if (sym == XK_t) { conf.layers = !conf.layers; spectro_draw(); XCopyArea(dpy, buf, win, gc, 0, 0, ww, wh, 0, 0); } else if (sym == XK_u && mode & (MODE_ERASE)) erase(-1,-1); while(XCheckMaskEvent(dpy, KeyPressMask, ev)); }
/*---------------------------- HandleEvent --------------------------*/ int HandleEvent(XEvent *event) { int i; if(theEvent.xany.window==mainW) { switch (event->type) { case Expose: { XExposeEvent *exp_event = (XExposeEvent *) event; if (exp_event->window==mainW) { DrawWindow(exp_event->x,exp_event->y, exp_event->width, exp_event->height); } } break; case EnterNotify: { if (Selected_Visual_Class==DirectColor) XStoreColors(theDisp,NewCmap,newC,ColorMapSize); if (Selected_Visual_Class!=TrueColor) XInstallColormap(theDisp,NewCmap); } break; case LeaveNotify: { if (Selected_Visual_Class==DirectColor) XStoreColors(theDisp,NewCmap,rootC,ColorMapSize); } break; case KeyPress: { /* allow a quit from the image window */ Handle_KeyPress(event); } break; case MotionNotify: { Handle_Motion(event); } break; case ConfigureNotify: { XConfigureEvent *conf_event = (XConfigureEvent *) event; if (conf_event->window == cmdW && (conf_event->width != cmd_width || conf_event->height != cmd_height)) XResizeWindow(theDisp,cmdW,cmd_width,cmd_height); if (conf_event->window == mainW && (conf_event->width != zWidth+(color_bar?color_bar_width:0) || conf_event->height != zHeight+info_height)) Resize(conf_event->width-(color_bar?color_bar_width:0), conf_event->height-info_height); } break; case ButtonPress: { if (theEvent.xbutton.button==Button1) { if (selzoom_active) { Selective_Zoom((caddr_t)&one); break; } XDefineCursor(theDisp,mainW,roiCursor); XFlush(theDisp); if (roi_present) draw_roi(roi_x1, roi_y1, roi_x2, roi_y2); roi_active = 1; roi_x1 = theEvent.xmotion.x < zWidth ? (theEvent.xmotion.x>0 ? theEvent.xmotion.x : 0) : zWidth-1; roi_y1 = theEvent.xmotion.y < zHeight ? (theEvent.xmotion.y>0 ? theEvent.xmotion.y : 0) : zHeight-1; roi_x2 = roi_x1; roi_y2 = roi_y1; draw_roi(roi_x1, roi_y1, roi_x2, roi_y2); break; } if (theEvent.xbutton.button==Button2) { XDefineCursor(theDisp,mainW,wlCursor); XClearArea(theDisp,mainW,0,zHeight, zWidth,zHeight+info_height,False); XDrawImageString(theDisp,mainW,theMGC, zWidth-XTextWidth(ol_text_finfo, wl_msg,strlen(wl_msg))-4, zHeight+info_height-4,wl_msg,strlen(wl_msg)); XDrawImageString(theDisp,mainW,theMGC,4, zHeight+info_height-4,loc_msg,strlen(loc_msg)); XFlush(theDisp); break; } if (theEvent.xbutton.button==Button3) { /* note: not really 'iconic' anymore, simply map or unmap */ if (cmdW_State==NormalState) { XUnmapWindow(theDisp,cmdW); cmdW_State = IconicState; } else { XMapWindow(theDisp,cmdW); cmdW_State = NormalState; } break; } } break; case ButtonRelease: { int xa, xb, ya, yb; if (theEvent.xbutton.button==Button1 && roi_active) { roi_active = 0; xa = roi_x1*(Width-1)/(zWidth-1); xb = roi_x2*(Width-1)/(zWidth-1); ya = roi_y1*(Height-1)/(zHeight-1); yb = roi_y2*(Height-1)/(zHeight-1); roi_stats(xa, ya, xb, yb, 0); XDefineCursor(theDisp,mainW,mainCursor); XFlush(theDisp); } if (theEvent.xbutton.button==Button2) { XDefineCursor(theDisp,mainW,mainCursor); XFlush(theDisp); if (Scale_Data && (oUpper != Upper || oLower != Lower)) { Rescale(); Window_Level(Lower,Upper); oLower=Lower; oUpper=Upper; } XClearArea(theDisp,mainW,0,zHeight, zWidth,zHeight+info_height,False); if (wl_display) XDrawImageString(theDisp,mainW,theMGC, zWidth-XTextWidth(ol_text_finfo,wl_msg,strlen(wl_msg))-4, zHeight+info_height-4,wl_msg,strlen(wl_msg)); XDrawImageString(theDisp,mainW,theMGC,4, zHeight+info_height-4,loc_msg,strlen(loc_msg)); update_sliders(); update_msgs(); } } break; case UnmapNotify: { if (bitmap_pad==8) { if (Interpolation_Type==BILINEAR) { bilinear_byte_to_byte(byte_Image, Width, Height, icon_byte_image, ICON_WIDTH, ICON_HEIGHT); } else { nneighbour_byte_to_byte(byte_Image, Width, Height, icon_byte_image, ICON_WIDTH, ICON_HEIGHT); } } else { if (Interpolation_Type==BILINEAR) { bilinear_rgbp_to_rgbp(byte_Image, Width, Height, icon_byte_image, ICON_WIDTH, ICON_HEIGHT); } else { nneighbour_rgbp_to_rgbp(byte_Image, Width, Height, icon_byte_image, ICON_WIDTH, ICON_HEIGHT); } } XPutImage(theDisp,iconW,theMGC,iconImage,0,0,0,0, ICON_WIDTH, ICON_HEIGHT); } break; case CirculateNotify: case MapNotify: case DestroyNotify: case GravityNotify: case ReparentNotify: default: break; } /* end of switch */ } /* other command Window events */ if(theEvent.xany.window==cmdW) { switch (event->type) { case Expose: { update_msgs(); } break; case EnterNotify: { if (Selected_Visual_Class==DirectColor) XStoreColors(theDisp,NewCmap,newC,ColorMapSize); if (Selected_Visual_Class!=TrueColor) XInstallColormap(theDisp,NewCmap); } break; case LeaveNotify: { if (Selected_Visual_Class==DirectColor) XStoreColors(theDisp,NewCmap,rootC,ColorMapSize); } break; case UnmapNotify: { cmdW_State = IconicState; } break; case MapNotify: { cmdW_State = NormalState; } break; case ConfigureNotify: { XConfigureEvent *conf_event = (XConfigureEvent *) event; if (conf_event->window == cmdW && (conf_event->width != cmd_width || conf_event->height != cmd_height)) XResizeWindow(theDisp,cmdW,cmd_width,cmd_height); } break; default: break; } } /* button press events */ if (XFindContext(theDisp, theEvent.xany.window, xwin_context, (caddr_t *) &which_xwin)==0) { if(*(which_xwin->event_handler)!=NULL) (*(which_xwin->event_handler))(which_xwin); if (Scale_Data && (oUpper != Upper || oLower != Lower)) { Rescale(); oLower=Lower; oUpper=Upper; } } }
void X11_MainLoop() { bool fullscreen = SConfig::GetInstance().m_LocalCoreStartupParameter.bFullscreen; while (!Core::IsRunning()) updateMainFrameEvent.Wait(); Display *dpy = XOpenDisplay(0); Window win = (Window)Core::GetWindowHandle(); XSelectInput(dpy, win, KeyPressMask | FocusChangeMask); if (SConfig::GetInstance().m_LocalCoreStartupParameter.bDisableScreenSaver) X11Utils::InhibitScreensaver(dpy, win, true); #if defined(HAVE_XRANDR) && HAVE_XRANDR X11Utils::XRRConfiguration *XRRConfig = new X11Utils::XRRConfiguration(dpy, win); #endif Cursor blankCursor = None; if (SConfig::GetInstance().m_LocalCoreStartupParameter.bHideCursor) { // make a blank cursor Pixmap Blank; XColor DummyColor; char ZeroData[1] = {0}; Blank = XCreateBitmapFromData (dpy, win, ZeroData, 1, 1); blankCursor = XCreatePixmapCursor(dpy, Blank, Blank, &DummyColor, &DummyColor, 0, 0); XFreePixmap (dpy, Blank); XDefineCursor(dpy, win, blankCursor); } if (fullscreen) { X11Utils::EWMH_Fullscreen(dpy, _NET_WM_STATE_TOGGLE); #if defined(HAVE_XRANDR) && HAVE_XRANDR XRRConfig->ToggleDisplayMode(True); #endif } // The actual loop while (running) { XEvent event; KeySym key; for (int num_events = XPending(dpy); num_events > 0; num_events--) { XNextEvent(dpy, &event); switch (event.type) { case KeyPress: key = XLookupKeysym((XKeyEvent*)&event, 0); if (key == XK_Escape) { if (Core::GetState() == Core::CORE_RUN) { if (SConfig::GetInstance().m_LocalCoreStartupParameter.bHideCursor) XUndefineCursor(dpy, win); Core::SetState(Core::CORE_PAUSE); } else { if (SConfig::GetInstance().m_LocalCoreStartupParameter.bHideCursor) XDefineCursor(dpy, win, blankCursor); Core::SetState(Core::CORE_RUN); } } else if ((key == XK_Return) && (event.xkey.state & Mod1Mask)) { fullscreen = !fullscreen; X11Utils::EWMH_Fullscreen(dpy, _NET_WM_STATE_TOGGLE); #if defined(HAVE_XRANDR) && HAVE_XRANDR XRRConfig->ToggleDisplayMode(fullscreen); #endif } else if (key >= XK_F1 && key <= XK_F8) { int slot_number = key - XK_F1 + 1; if (event.xkey.state & ShiftMask) State::Save(slot_number); else State::Load(slot_number); } else if (key == XK_F9) Core::SaveScreenShot(); else if (key == XK_F11) State::LoadLastSaved(); else if (key == XK_F12) { if (event.xkey.state & ShiftMask) State::UndoLoadState(); else State::UndoSaveState(); } break; case FocusIn: rendererHasFocus = true; if (SConfig::GetInstance().m_LocalCoreStartupParameter.bHideCursor && Core::GetState() != Core::CORE_PAUSE) XDefineCursor(dpy, win, blankCursor); break; case FocusOut: rendererHasFocus = false; if (SConfig::GetInstance().m_LocalCoreStartupParameter.bHideCursor) XUndefineCursor(dpy, win); break; } } if (!fullscreen) { Window winDummy; unsigned int borderDummy, depthDummy; XGetGeometry(dpy, win, &winDummy, &SConfig::GetInstance().m_LocalCoreStartupParameter.iRenderWindowXPos, &SConfig::GetInstance().m_LocalCoreStartupParameter.iRenderWindowYPos, (unsigned int *)&SConfig::GetInstance().m_LocalCoreStartupParameter.iRenderWindowWidth, (unsigned int *)&SConfig::GetInstance().m_LocalCoreStartupParameter.iRenderWindowHeight, &borderDummy, &depthDummy); } usleep(100000); } #if defined(HAVE_XRANDR) && HAVE_XRANDR delete XRRConfig; #endif if (SConfig::GetInstance().m_LocalCoreStartupParameter.bDisableScreenSaver) X11Utils::InhibitScreensaver(dpy, win, false); if (SConfig::GetInstance().m_LocalCoreStartupParameter.bHideCursor) XFreeCursor(dpy, blankCursor); XCloseDisplay(dpy); Core::Stop(); }
void setup_fontmenu(void) { register int i; DeclareArgs(2); Pixel bg, fg; /* get the foreground/background of the widget */ FirstArg(XtNforeground, &fg); NextArg(XtNbackground, &bg); GetValues(ps_fontpane[0]); /* Create the bitmaps */ #ifdef I18N if (appres.international) { char *lang; lang = appres.font_menu_language; if (lang[0] == '\0') lang = setlocale(LC_CTYPE, NULL); if (strncasecmp(lang, "japanese", 2) == 0) { extern unsigned char Japanese_Times_Roman_bits[], Japanese_Roman_bits[]; extern unsigned char Japanese_Times_Bold_bits[], Japanese_Bold_bits[]; psfont_menu_bits[1] = Japanese_Times_Roman_bits; latexfont_menu_bits[1] = Japanese_Roman_bits; psfont_menu_bits[3] = Japanese_Times_Bold_bits; latexfont_menu_bits[2] = Japanese_Bold_bits; } else if (strncasecmp(lang, "korean", 2) == 0) { extern unsigned char Korean_Times_Roman_bits[], Korean_Roman_bits[]; extern unsigned char Korean_Times_Bold_bits[], Korean_Bold_bits[]; psfont_menu_bits[1] = Korean_Times_Roman_bits; latexfont_menu_bits[1] = Korean_Roman_bits; psfont_menu_bits[3] = Korean_Times_Bold_bits; latexfont_menu_bits[2] = Korean_Bold_bits; } } #endif /* I18N */ for (i = 0; i < NUM_FONTS + 1; i++) psfont_menu_bitmaps[i] = XCreatePixmapFromBitmapData(tool_d, XtWindow(ind_panel), (char *) psfont_menu_bits[i], PS_FONTPANE_WD, PS_FONTPANE_HT, fg, bg, tool_dpth); for (i = 0; i < NUM_LATEX_FONTS; i++) latexfont_menu_bitmaps[i] = XCreatePixmapFromBitmapData(tool_d, XtWindow(ind_panel), (char *) latexfont_menu_bits[i], LATEX_FONTPANE_WD, LATEX_FONTPANE_HT, fg, bg, tool_dpth); /* Store the bitmaps in the menu panes */ for (i = 0; i < NUM_FONTS + 1; i++) { FirstArg(XtNbitmap, psfont_menu_bitmaps[i]); SetValues(ps_fontpane[i]); } for (i = 0; i < NUM_LATEX_FONTS; i++) { FirstArg(XtNbitmap, latexfont_menu_bitmaps[i]); SetValues(latex_fontpane[i]); } XtRealizeWidget(ps_fontmenu); XtRealizeWidget(latex_fontmenu); /* at this point the windows are realized but not drawn */ XDefineCursor(tool_d, XtWindow(ps_fontpanes), arrow_cursor); XDefineCursor(tool_d, XtWindow(latex_fontpanes), arrow_cursor); }
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_LinuxDisplay_nDefineCursor(JNIEnv *env, jclass unused, jlong display_ptr, jlong window_ptr, jlong cursor_ptr) { Display *disp = (Display *)(intptr_t)display_ptr; Window win = (Window)window_ptr; Cursor cursor = (Cursor)cursor_ptr; XDefineCursor(disp, win, cursor); }
void CL_DisplayWindow_OpenGL::show_system_cursor() { XDefineCursor(disp, window, system_cursor); }
// only used internally void makeNativeWindow() { #ifdef __FOR_XORG__ __x_display = XOpenDisplay(NULL); // open the standard display (the primary screen) if (__x_display == NULL) { printf("cannot connect to X server\n"); } Window root = DefaultRootWindow(__x_display); // get the root window (usually the whole screen) XSetWindowAttributes swa; swa.event_mask = ExposureMask | PointerMotionMask | KeyPressMask | KeyReleaseMask; __display_width=640; __display_height=480; // xorg hard coded for now int s = DefaultScreen(__x_display); __win = XCreateSimpleWindow(__x_display, root, 10, 10, __display_width, __display_height, 1, BlackPixel(__x_display, s), WhitePixel(__x_display, s)); XSelectInput(__x_display, __win, ExposureMask | KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | PointerMotionMask); XSetWindowAttributes xattr; Atom atom; int one = 1; xattr.override_redirect = False; XChangeWindowAttributes(__x_display, __win, CWOverrideRedirect, &xattr); /* atom = XInternAtom(__x_display, "_NET_WM_STATE_FULLSCREEN", True); XChangeProperty(__x_display, win, XInternAtom(__x_display, "_NET_WM_STATE", True), XA_ATOM, 32, PropModeReplace, (unsigned char *)&atom, 1); */ XWMHints hints; hints.input = True; hints.flags = InputHint; XSetWMHints(__x_display, __win, &hints); XMapWindow(__x_display, __win); // make the window visible on the screen XStoreName(__x_display, __win, "GLES2.0 framework"); // give the window a name // NB - RPi needs to use EGL_DEFAULT_DISPLAY that some X configs dont seem to like __egl_display = eglGetDisplay((EGLNativeDisplayType) __x_display); if (__egl_display == EGL_NO_DISPLAY) { printf("Got no EGL display.\n"); } __eventWin = __win; Cursor invisibleCursor; Pixmap bitmapNoData; XColor black; static char noData[] = { 0,0,0,0,0,0,0,0 }; black.red = black.green = black.blue = 0; bitmapNoData = XCreateBitmapFromData(__x_display, __win, noData, 8, 8); invisibleCursor = XCreatePixmapCursor(__x_display, bitmapNoData, bitmapNoData, &black, &black, 0, 0); XDefineCursor(__x_display,__win, invisibleCursor); XFreeCursor(__x_display, invisibleCursor); #endif //__FOR_XORG__ #ifdef __FOR_RPi__ bcm_host_init(); int32_t success = 0; // create an EGL window surface, passing context width/height success = graphics_get_display_size(0 /* LCD */ , &__display_width, &__display_height); if (success < 0) { printf("unable to get display size\n"); //return EGL_FALSE; } __x_display = XOpenDisplay(NULL); // open the standard display (the primary screen) if (__x_display == NULL) { printf("cannot connect to X server\n"); } Window root = DefaultRootWindow(__x_display); // get the root window (usually the whole screen) XSetWindowAttributes swa; swa.event_mask = ExposureMask | PointerMotionMask | KeyPressMask | KeyReleaseMask; int s = DefaultScreen(__x_display); __eventWin = XCreateSimpleWindow(__x_display, root, 0, 0, __display_width, __display_height, 1, BlackPixel(__x_display, s), WhitePixel(__x_display, s)); XSelectInput(__x_display, __eventWin, ExposureMask | KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | PointerMotionMask); XSetWindowAttributes xattr; Atom atom; int one = 1; xattr.override_redirect = False; XChangeWindowAttributes(__x_display, __eventWin, CWOverrideRedirect, &xattr); XWMHints hints; hints.input = True; hints.flags = InputHint; XSetWMHints(__x_display, __eventWin, &hints); XMapWindow(__x_display, __eventWin); // make the window visible on the screen XStoreName(__x_display, __eventWin, "Event trap"); // give the window a name // we have to be full screen to capture all mouse events // TODO consider using warp mouse to report relative motions // instead of absolute... XFlush(__x_display); // you have to flush or bcm seems to prevent window coming up? Atom wmState = XInternAtom(__x_display, "_NET_WM_STATE", False); Atom fullScreen = XInternAtom(__x_display, "_NET_WM_STATE_FULLSCREEN", False); XEvent xev; xev.xclient.type = ClientMessage; xev.xclient.serial = 0; xev.xclient.send_event = True; xev.xclient.window = __eventWin; xev.xclient.message_type = wmState; xev.xclient.format = 32; xev.xclient.data.l[0] = 1; //_NET_WM_STATE_ADD xev.xclient.data.l[1] = fullScreen; xev.xclient.data.l[2] = 0; XSendEvent(__x_display, root, False, SubstructureRedirectMask | SubstructureNotifyMask, &xev); XFlush(__x_display); // you have to flush or bcm seems to prevent window coming up? static EGL_DISPMANX_WINDOW_T nativewindow; DISPMANX_ELEMENT_HANDLE_T dispman_element; DISPMANX_DISPLAY_HANDLE_T dispman_display; DISPMANX_UPDATE_HANDLE_T dispman_update; VC_RECT_T dst_rect; VC_RECT_T src_rect; // printf("display size %i,%i\n",__display_width,__display_height); dst_rect.x = 0; dst_rect.y = 0; dst_rect.width = __display_width; dst_rect.height = __display_height; src_rect.x = 0; src_rect.y = 0; src_rect.width = __display_width << 16; src_rect.height = __display_height << 16; dispman_display = vc_dispmanx_display_open(0 /* LCD */ ); dispman_update = vc_dispmanx_update_start(0); //VC_DISPMANX_ALPHA_T alpha = { DISPMANX_FLAGS_ALPHA_FROM_SOURCE | DISPMANX_FLAGS_ALPHA_FIXED_ALL_PIXELS,255,0 }; VC_DISPMANX_ALPHA_T alpha = { DISPMANX_FLAGS_ALPHA_FIXED_ALL_PIXELS,255,0 }; dispman_element = vc_dispmanx_element_add(dispman_update, dispman_display, 0 /*layer */ , &dst_rect, 0 /*src */ , &src_rect, DISPMANX_PROTECTION_NONE, &alpha /*alpha */ , 0 /*clamp */ , 0 /*transform */ ); nativewindow.element = dispman_element; nativewindow.width = __display_width; nativewindow.height = __display_height; vc_dispmanx_update_submit_sync(dispman_update); __win = &nativewindow; __egl_display = eglGetDisplay(EGL_DEFAULT_DISPLAY); #endif //__FOR_RPi__ #ifdef __FOR_RPi_noX__ bcm_host_init(); int32_t success = 0; success = graphics_get_display_size(0 /* LCD */ , &__display_width, &__display_height); if (success < 0) { printf("unable to get display size\n"); //return EGL_FALSE; } static EGL_DISPMANX_WINDOW_T nativewindow; DISPMANX_ELEMENT_HANDLE_T dispman_element; DISPMANX_DISPLAY_HANDLE_T dispman_display; DISPMANX_UPDATE_HANDLE_T dispman_update; VC_RECT_T dst_rect; VC_RECT_T src_rect; dst_rect.x = 0; dst_rect.y = 0; dst_rect.width = __display_width; dst_rect.height = __display_height; src_rect.x = 0; src_rect.y = 0; src_rect.width = __display_width << 16; src_rect.height = __display_height << 16; dispman_display = vc_dispmanx_display_open(0 /* LCD */ ); dispman_update = vc_dispmanx_update_start(0); VC_DISPMANX_ALPHA_T alpha = { DISPMANX_FLAGS_ALPHA_FIXED_ALL_PIXELS,255,0 }; dispman_element = vc_dispmanx_element_add(dispman_update, dispman_display, 0 /*layer */ , &dst_rect, 0 /*src */ , &src_rect, DISPMANX_PROTECTION_NONE, &alpha /*alpha */ , 0 /*clamp */ , 0 /*transform */ ); nativewindow.element = dispman_element; nativewindow.width = __display_width; nativewindow.height = __display_height; vc_dispmanx_update_submit_sync(dispman_update); __win = &nativewindow; __egl_display = eglGetDisplay(EGL_DEFAULT_DISPLAY); if (__egl_display == EGL_NO_DISPLAY) { printf("Got no EGL display.\n"); } #endif //__FOR_RPi_noX__ }
void CL_DisplayWindow_OpenGL::hide_system_cursor() { XDefineCursor(disp, window, hidden_cursor); }
static void winopen(void) { XWMHints *wmhints; XClassHint *classhint; xdpy = XOpenDisplay(NULL); if (!xdpy) fz_throw(gapp.ctx, FZ_ERROR_GENERIC, "cannot open display"); XA_CLIPBOARD = XInternAtom(xdpy, "CLIPBOARD", False); XA_TARGETS = XInternAtom(xdpy, "TARGETS", False); XA_TIMESTAMP = XInternAtom(xdpy, "TIMESTAMP", False); XA_UTF8_STRING = XInternAtom(xdpy, "UTF8_STRING", False); WM_DELETE_WINDOW = XInternAtom(xdpy, "WM_DELETE_WINDOW", False); NET_WM_STATE = XInternAtom(xdpy, "_NET_WM_STATE", False); NET_WM_STATE_FULLSCREEN = XInternAtom(xdpy, "_NET_WM_STATE_FULLSCREEN", False); WM_RELOAD_PAGE = XInternAtom(xdpy, "_WM_RELOAD_PAGE", False); xscr = DefaultScreen(xdpy); ximage_init(xdpy, xscr, DefaultVisual(xdpy, xscr)); xcarrow = XCreateFontCursor(xdpy, XC_left_ptr); xchand = XCreateFontCursor(xdpy, XC_hand2); xcwait = XCreateFontCursor(xdpy, XC_watch); xccaret = XCreateFontCursor(xdpy, XC_xterm); xbgcolor.red = 0x7000; xbgcolor.green = 0x7000; xbgcolor.blue = 0x7000; xshcolor.red = 0x4000; xshcolor.green = 0x4000; xshcolor.blue = 0x4000; XAllocColor(xdpy, DefaultColormap(xdpy, xscr), &xbgcolor); XAllocColor(xdpy, DefaultColormap(xdpy, xscr), &xshcolor); xwin = XCreateWindow(xdpy, DefaultRootWindow(xdpy), 10, 10, 200, 100, 0, ximage_get_depth(), InputOutput, ximage_get_visual(), 0, NULL); if (xwin == None) fz_throw(gapp.ctx, FZ_ERROR_GENERIC, "cannot create window"); XSetWindowColormap(xdpy, xwin, ximage_get_colormap()); XSelectInput(xdpy, xwin, StructureNotifyMask | ExposureMask | KeyPressMask | PointerMotionMask | ButtonPressMask | ButtonReleaseMask); mapped = 0; xgc = XCreateGC(xdpy, xwin, 0, NULL); XDefineCursor(xdpy, xwin, xcarrow); wmhints = XAllocWMHints(); if (wmhints) { wmhints->flags = IconPixmapHint | IconMaskHint; xicon = XCreateBitmapFromData(xdpy, xwin, (char*)mupdf_icon_bitmap_16_bits, mupdf_icon_bitmap_16_width, mupdf_icon_bitmap_16_height); xmask = XCreateBitmapFromData(xdpy, xwin, (char*)mupdf_icon_bitmap_16_mask_bits, mupdf_icon_bitmap_16_mask_width, mupdf_icon_bitmap_16_mask_height); if (xicon && xmask) { wmhints->icon_pixmap = xicon; wmhints->icon_mask = xmask; XSetWMHints(xdpy, xwin, wmhints); } XFree(wmhints); } classhint = XAllocClassHint(); if (classhint) { classhint->res_name = "mupdf"; classhint->res_class = "MuPDF"; XSetClassHint(xdpy, xwin, classhint); XFree(classhint); } XSetWMProtocols(xdpy, xwin, &WM_DELETE_WINDOW, 1); x11fd = ConnectionNumber(xdpy); }
int wincreat( int x, int y, int width, int height, char *title) { XSetWindowAttributes swa; Colormap cmap; XVisualInfo *vi; int dummy; GLXContext glcx; XEvent event; int attributes[] = { GLX_RGBA, GLX_DEPTH_SIZE, 16, GLX_RED_SIZE, 8, GLX_GREEN_SIZE, 8, GLX_BLUE_SIZE, 8, GLX_ALPHA_SIZE, 8, GLX_DOUBLEBUFFER, None }; if( !(dpy = XOpenDisplay( NULL )) ) /* defaults to $DISPLAY */ { fprintf( stderr, "Unable to open display.\n" ); exit( 1 ); } else { /*printf( "Connected to display... %s (%s).\n", dpy->display_name, dpy->vendor );*/ } /* end if( ) */ if( !glXQueryExtension( dpy, &dummy, &dummy ) ) { fprintf( stderr, "Unable to query GLX extensions.\n" ); exit( 1 ); } /* end if( ) */ if( !(vi = glXChooseVisual( dpy, DefaultScreen( dpy ), attributes )) ) { fprintf( stderr, "Unable get a visual.\n" ); exit( 1 ); } /* end if( ) */ if( vi->class != TrueColor ) { fprintf( stderr, "Need TrueColor class.\n" ); exit( 1 ); } if( !(glcx = glXCreateContext( dpy, vi, None, GL_TRUE )) ) { fprintf( stderr, "Unable create a GL context.\n" ); exit( 1 ); } /* end if( ) */ cmap = XCreateColormap( dpy, RootWindow( dpy, vi->screen ), vi->visual, AllocNone ); swa.colormap = cmap; swa.border_pixel = 0; swa.event_mask = ExposureMask | KeyPressMask | StructureNotifyMask; glwin = XCreateWindow( dpy, RootWindow( dpy, vi->screen ), x, y, width, height, 0, vi->depth, InputOutput, vi->visual, CWBorderPixel | CWColormap | CWEventMask, &swa ); /* Make a clear cursor so it looks like we have none. */ { Pixmap pixmap; Cursor cursor; XColor color; char clear_bits[32]; memset(clear_bits, 0, sizeof(clear_bits)); pixmap = XCreatePixmapFromBitmapData(dpy, glwin, clear_bits, 16, 16, 1, 0, 1); cursor = XCreatePixmapCursor(dpy, pixmap, pixmap, &color, &color, 8, 8); XDefineCursor(dpy, glwin, cursor); XFreePixmap(dpy, pixmap); } XSetStandardProperties( dpy, glwin, title, title, None, NULL, 0, NULL ); if( !glXMakeCurrent( dpy, glwin, glcx ) ) { fprintf( stderr, "Failed to make the GL context current.\n" ); exit( 1 ); } XMapWindow( dpy, glwin ); XIfEvent( dpy, &event, WaitForMapNotify, (char *)glwin ); return( 1 ); } /* end int APIENTRY pglc_wincreat( ) */