JNIEXPORT void JNICALL GLX_NATIVE(glXWaitX)
(JNIEnv *env, jclass that)
{
GLX_NATIVE_ENTER(env, that, glXWaitX_FUNC);
glXWaitX();
GLX_NATIVE_EXIT(env, that, glXWaitX_FUNC);
}
DECLEXPORT(EGLBoolean) eglWaitNative(EGLint cEngine)
{
if (cEngine != EGL_CORE_NATIVE_ENGINE)
return setEGLError(EGL_BAD_PARAMETER);
glXWaitX();
return clearEGLError();
}
Word NewGameWindow(Word NewVidSize)
{
XSizeHints sizehints;
if (NewVidSize == VidSize)
return VidSize;
if (NewVidSize < 4) {
w = VidXs[NewVidSize];
h = VidYs[NewVidSize];
v = VidVs[NewVidSize];
} else {
fprintf(stderr, "Invalid Vid size: %d\n", NewVidSize);
exit(EXIT_FAILURE);
}
sizehints.min_width = w;
sizehints.min_height = h;
sizehints.flags = PMinSize;
XSetWMNormalHints(dpy, win, &sizehints);
XResizeWindow(dpy, win, w, h);
SetAPalette(rBlackPal);
ClearTheScreen(BLACK);
BlastScreen();
VidSize = NewVidSize;
XSync(dpy, False);
glXWaitGL();
glXWaitX();
HandleEvents();
return VidSize;
}
void
resize(int w, int h) {
if (w == width && h == height) {
return;
}
glXWaitGL();
// We need to ensure that pending events are processed here, and XSync
// with discard = True guarantees that, but it appears the limited
// event processing we do so far is sufficient
//XSync(display, True);
Drawable::resize(w, h);
// Tell the window manager to respect the requested size
XSizeHints size_hints;
size_hints.max_width = size_hints.min_width = w;
size_hints.max_height = size_hints.min_height = h;
size_hints.flags = PMinSize | PMaxSize;
XSetWMNormalHints(display, window, &size_hints);
XResizeWindow(display, window, w, h);
waitForEvent(ConfigureNotify);
glXWaitX();
}
void draw() {
int i;
GLfloat width, height;
glXWaitX(); check_gl(__LINE__);
//XGrabServer(dpy);
glClearColor(0.0, 0.0, 0.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT); check_gl(__LINE__);
draw_background();
for (i=0; i<MAX_CLIENTS; i++) {
if (workspace == NULL || workspace[i].window == 0)
break;
Client client = workspace[i];
width = (GLfloat) client.geom.width;
height = (GLfloat) client.geom.height;
//info("Drawing %d window => 0x%x, %g x %g\n", i, client.window, width, height);
if(client.geom.depth == 32) {
info("Using blending\n");
glEnable(GL_BLEND);
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA); // X windows are premultiplied
} else
glDisable(GL_BLEND);
glEnable(client.target); check_gl(__LINE__);
glBindTexture(client.target, client.texture); check_gl(__LINE__);
glXBindTexImageProc(dpy, client.glxpixmap, GLX_FRONT_LEFT_EXT, NULL);
check_gl(__LINE__);
glTexParameterf(GL_TEXTURE_RECTANGLE, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_RECTANGLE, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
check_gl(__LINE__);
glBegin(GL_QUADS);
glColor3d(1.0, 1.0, 1.0);
glTexCoord2f(left*width, bottom*height); glVertex3f(0.00f, 0.000f, 1.0f);
glTexCoord2f(left*width, top*height); glVertex3f(0.00f, height, 1.0f);
glTexCoord2f(right*width, top*height); glVertex3f(width, height, 1.0f);
glTexCoord2f(right*width, bottom*height); glVertex3f(width, 0.000f, 1.0f);
glEnd();
check_gl(__LINE__);
glBindTexture(client.target, 0); check_gl(__LINE__);
glDisable(client.target); check_gl(__LINE__);
glXReleaseTexImageProc(dpy, client.glxpixmap, GLX_FRONT_LEFT_EXT);
check_gl(__LINE__);
}
glXWaitGL(); check_gl(__LINE__);
glXSwapBuffers(dpy, canvas); check_gl(__LINE__);
usleep(2000); // 50Hz
XEvent ev;
ev.type = ClientMessage;
ev.xclient.display = dpy;
ev.xclient.window = root;
ev.xclient.format = 8;
XSendEvent(dpy, overlay, False, SubstructureNotifyMask, &ev);
XFlush(dpy);
//XUngrabServer(dpy);
}
//================================================================
void* GLB_Create () {
//================================================================
/// GLB_Create create opengl-window (used by GUI_gl__)
GtkWidget *area;
int xscreen, i1;
GdkScreen *screen;
GdkVisual *visual;
Window root;
XVisualInfo *xvisual;
Colormap xcolormap;
int attributes[] = {
GLX_RGBA,
GLX_RED_SIZE, 1,
GLX_GREEN_SIZE, 1,
GLX_BLUE_SIZE, 1,
GLX_DOUBLEBUFFER, True,
GLX_DEPTH_SIZE, 24,
None };
GLB_x_id = 0; // reset
area = gtk_drawing_area_new ();
gtk_widget_set_double_buffered (area, FALSE);
GLB_display = gdk_x11_get_default_xdisplay ();
xscreen = DefaultScreen (GLB_display);
screen = gdk_screen_get_default ();
// printf(" screenNr = %d\n",gdk_screen_get_number(screen));
xvisual = glXChooseVisual (GLB_display, xscreen, attributes);
// printf(" xvisualid=%d\n",xvisual->visualid);
visual = gdk_x11_screen_lookup_visual (screen, xvisual->visualid);
root = RootWindow (GLB_display, xscreen);
xcolormap = XCreateColormap (GLB_display, root, xvisual->visual, AllocNone);
glXGetConfig (GLB_display, xvisual, GLX_RED_SIZE, &i1);
printf(" GLX_RED_SIZE=%d\n",i1);
glXGetConfig (GLB_display, xvisual, GLX_DEPTH_SIZE, &i1);
printf(" GLX_DEPTH_SIZE=%d\n",i1);
// Gtk2 only:
//colormap = gdk_x11_colormap_foreign_new (visual, xcolormap);
//gtk_widget_set_colormap (area, colormap);
GLB_x_context = glXCreateContext (GLB_display, xvisual, NULL, TRUE);
// free (xvisual);
glXWaitX();
glXWaitGL();
return area;
}
GlxDrawable(const Visual *vis, int w, int h, bool pbuffer) :
Drawable(vis, w, h, pbuffer),
ever_current(false)
{
XVisualInfo *visinfo = static_cast<const GlxVisual *>(visual)->visinfo;
const char *name = "glretrace";
window = createWindow(visinfo, name, width, height);
glXWaitX();
}
void show(void) {
if (visible) {
return;
}
glXWaitGL();
showWindow(window);
glXWaitX();
Drawable::show();
}
void
S9xOpenGLDisplayDriver::gl_swap (void)
{
glXSwapBuffers (display, xwindow);
if (config->sync_every_frame)
{
usleep (0);
glXWaitX ();
glFinish ();
}
return;
}
void show(void) override {
if (!window ||
visible) {
return;
}
glXWaitGL();
showWindow(window);
glXWaitX();
Drawable::show();
}
void show(void) {
if (visible) {
return;
}
glXWaitGL();
XMapWindow(display, window);
waitForEvent(MapNotify);
glXWaitX();
Drawable::show();
}
void color_resultbg()
{
float redcol, greencol, bluecol;
redcol = (float)mr/255.0;
greencol = (float)mg/255.0;
bluecol = (float)mb/255.0;
glXWaitX();
glXMakeCurrent(dpy,bgwindowid,bg_context);
glClearColor(redcol,greencol,bluecol,1.0);
glClear(GL_COLOR_BUFFER_BIT);
if (doubleBuffer == GL_TRUE) glXSwapBuffers(dpy, bgwindowid);
glClear(GL_COLOR_BUFFER_BIT);
if (doubleBuffer == GL_TRUE) glXSwapBuffers(dpy, bgwindowid);
glXWaitGL();
}
GlxDrawable(const Visual *vis, int w, int h,
const glws::pbuffer_info *pbInfo) :
Drawable(vis, w, h, pbInfo ? true : false)
{
const GlxVisual *glxvisual = static_cast<const GlxVisual *>(visual);
XVisualInfo *visinfo = glxvisual->visinfo;
const char *name = "glretrace";
if (pbInfo) {
drawable = createPbuffer(display, glxvisual, pbInfo, w, h);
}
else {
window = createWindow(visinfo, name, width, height);
drawable = glXCreateWindow(display, glxvisual->fbconfig, window, NULL);
}
glXWaitX();
}
GlxDrawable(const Visual *vis, int w, int h, bool pbuffer) :
Drawable(vis, w, h, pbuffer)
{
XVisualInfo *visinfo = static_cast<const GlxVisual *>(visual)->visinfo;
Window root = RootWindow(display, screen);
/* window attributes */
XSetWindowAttributes attr;
attr.background_pixel = 0;
attr.border_pixel = 0;
attr.colormap = XCreateColormap(display, root, visinfo->visual, AllocNone);
attr.event_mask = StructureNotifyMask | KeyPressMask;
unsigned long mask;
mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
int x = 0, y = 0;
window = XCreateWindow(
display, root,
x, y, width, height,
0,
visinfo->depth,
InputOutput,
visinfo->visual,
mask,
&attr);
XSizeHints sizehints;
sizehints.x = x;
sizehints.y = y;
sizehints.width = width;
sizehints.height = height;
sizehints.flags = USSize | USPosition;
XSetNormalHints(display, window, &sizehints);
const char *name = "glretrace";
XSetStandardProperties(
display, window, name, name,
None, (char **)NULL, 0, &sizehints);
glXWaitX();
}
void
resize(int w, int h) {
if (w == width && h == height) {
return;
}
glXWaitGL();
// We need to ensure that pending events are processed here, and XSync
// with discard = True guarantees that, but it appears the limited
// event processing we do so far is sufficient
//XSync(display, True);
Drawable::resize(w, h);
resizeWindow(window, w, h);
glXWaitX();
}
void gl_start()
{
if (!context)
{
#ifdef _WIN32
if (!gl_choice) fl_gl_visual(0);
context = fl_create_gl_context(Fl_Window::current(), gl_choice);
#else
context = fl_create_gl_context(fl_visual);
#endif
}
fl_set_gl_context(Fl_Window::current(), context);
#ifndef _WIN32
glXWaitX();
#endif
if (pw != Fl_Window::current()->w() || ph != Fl_Window::current()->h())
{
pw = Fl_Window::current()->w();
ph = Fl_Window::current()->h();
glLoadIdentity();
glViewport(0, 0, pw, ph);
glOrtho(0, pw, 0, ph, -1, 1);
glDrawBuffer(GL_FRONT);
}
// if (clip_state_number != fl_clip_state_number) {
// clip_state_number = fl_clip_state_number;
int x, y, w, h;
if (fl_clip_box(0, 0, Fl_Window::current()->w(), Fl_Window::current()->h(),
x, y, w, h))
{
fl_clip_region(XRectangleRegion(x,y,w,h));
glScissor(x, Fl_Window::current()->h()-(y+h), w, h);
glEnable(GL_SCISSOR_TEST);
}
else
{
glDisable(GL_SCISSOR_TEST);
}
// }
}
void waitNative() {
glXWaitX();
}
static DFBResult
update_screen( DFBX11 *x11, const DFBRectangle *clip, CoreSurfaceBufferLock *lock, XWindow *xw )
{
void *dst;
void *src;
unsigned int offset = 0;
XImage *ximage;
CoreSurface *surface;
CoreSurfaceAllocation *allocation;
DFBX11Shared *shared;
DFBRectangle rect;
bool direct = false;
D_ASSERT( x11 != NULL );
DFB_RECTANGLE_ASSERT( clip );
D_DEBUG_AT( X11_Update, "%s( %4d,%4d-%4dx%4d )\n", __FUNCTION__, DFB_RECTANGLE_VALS( clip ) );
CORE_SURFACE_BUFFER_LOCK_ASSERT( lock );
shared = x11->shared;
D_ASSERT( shared != NULL );
XLockDisplay( x11->display );
if (!xw) {
XUnlockDisplay( x11->display );
return DFB_OK;
}
allocation = lock->allocation;
CORE_SURFACE_ALLOCATION_ASSERT( allocation );
surface = allocation->surface;
D_ASSERT( surface != NULL );
rect.x = rect.y = 0;
rect.w = xw->width;
rect.h = xw->height;
if (!dfb_rectangle_intersect( &rect, clip )) {
XUnlockDisplay( x11->display );
return DFB_OK;
}
D_DEBUG_AT( X11_Update, " -> %4d,%4d-%4dx%4d\n", DFB_RECTANGLE_VALS( &rect ) );
#ifdef USE_GLX
/* Check for GLX allocation... */
if (allocation->pool == shared->glx_pool && lock->handle) {
LocalPixmap *pixmap = lock->handle;
D_MAGIC_ASSERT( pixmap, LocalPixmap );
/* ...and just call SwapBuffers... */
//D_DEBUG_AT( X11_Update, " -> Calling glXSwapBuffers( 0x%lx )...\n", alloc->drawable );
//glXSwapBuffers( x11->display, alloc->drawable );
D_DEBUG_AT( X11_Update, " -> Copying from GLXPixmap...\n" );
glXWaitGL();
XCopyArea( x11->display, pixmap->pixmap, xw->window, xw->gc,
rect.x, rect.y, rect.w, rect.h, rect.x, rect.y );
glXWaitX();
XUnlockDisplay( x11->display );
return DFB_OK;
}
#endif
/* Check for our special native allocation... */
if (allocation->pool == shared->x11image_pool && lock->handle) {
x11Image *image = lock->handle;
D_MAGIC_ASSERT( image, x11Image );
/* ...and directly XShmPutImage from that. */
ximage = image->ximage;
direct = true;
}
else {
/* ...or copy or convert into XShmImage or XImage allocated with the XWindow. */
ximage = xw->ximage;
offset = xw->ximage_offset;
xw->ximage_offset = (offset ? 0 : ximage->height / 2);
/* make sure the 16-bit input formats are properly 2-pixel-clipped */
switch (surface->config.format) {
case DSPF_I420:
case DSPF_YV12:
case DSPF_NV12:
case DSPF_NV21:
if (rect.y & 1) {
rect.y--;
rect.h++;
}
/* fall through */
case DSPF_YUY2:
case DSPF_UYVY:
case DSPF_NV16:
if (rect.x & 1) {
rect.x--;
rect.w++;
}
default: /* no action */
break;
}
dst = xw->virtualscreen + rect.x * xw->bpp + (rect.y + offset) * ximage->bytes_per_line;
src = lock->addr + DFB_BYTES_PER_LINE( surface->config.format, rect.x ) + rect.y * lock->pitch;
switch (xw->depth) {
case 32:
dfb_convert_to_argb( surface->config.format, src, lock->pitch,
surface->config.size.h, dst, ximage->bytes_per_line, rect.w, rect.h );
break;
case 24:
dfb_convert_to_rgb32( surface->config.format, src, lock->pitch,
surface->config.size.h, dst, ximage->bytes_per_line, rect.w, rect.h );
break;
case 16:
if (surface->config.format == DSPF_LUT8) {
int width = rect.w; int height = rect.h;
const u8 *src8 = src;
u16 *dst16 = dst;
CorePalette *palette = surface->palette;
int x;
while (height--) {
for (x=0; x<width; x++) {
DFBColor color = palette->entries[src8[x]];
dst16[x] = PIXEL_RGB16( color.r, color.g, color.b );
}
src8 += lock->pitch;
dst16 += ximage->bytes_per_line / 2;
}
}
else {
dfb_convert_to_rgb16( surface->config.format, src, lock->pitch,
surface->config.size.h, dst, ximage->bytes_per_line, rect.w, rect.h );
}
break;
case 15:
dfb_convert_to_rgb555( surface->config.format, src, lock->pitch,
surface->config.size.h, dst, ximage->bytes_per_line, rect.w, rect.h );
break;
default:
D_ONCE( "unsupported depth %d", xw->depth );
}
}
D_ASSERT( ximage != NULL );
/* Wait for previous data to be processed... */
XSync( x11->display, False );
/* ...and immediately queue or send the next! */
if (x11->use_shm) {
/* Just queue the command, it's XShm :) */
XShmPutImage( xw->display, xw->window, xw->gc, ximage,
rect.x, rect.y + offset, rect.x, rect.y, rect.w, rect.h, False );
/* Make sure the queue has really happened! */
XFlush( x11->display );
}
else
/* Initiate transfer of buffer... */
XPutImage( xw->display, xw->window, xw->gc, ximage,
rect.x, rect.y + offset, rect.x, rect.y, rect.w, rect.h );
/* Wait for display if single buffered and not converted... */
if (direct && !(surface->config.caps & DSCAPS_FLIPPING))
XSync( x11->display, False );
XUnlockDisplay( x11->display );
return DFB_OK;
}
void GLContextGLX::waitNative()
{
glXWaitX();
}
int ui_loop(int argc, char **argv, const char *name) {
XVisualInfo *vi;
Colormap cmap;
XSetWindowAttributes swa;
XSizeHints hint;
GLXContext cx;
XEvent event;
int k, width, height;
char buf[80];
XEvent xev;
KeySym keysym;
XComposeStatus status;
/* get a connection */
dpy = XOpenDisplay(NULL);
if (dpy == NULL) {
fprintf(stderr, "Could not open X display\n");
exit(1);
}
/* get an appropriate visual */
vi = glXChooseVisual(dpy, DefaultScreen(dpy), attributeList);
if (vi == NULL) {
fprintf(stderr, "No suitable visual for glx\n");
exit(1);
}
/* create a GLX context */
cx = glXCreateContext(dpy, vi, 0, GL_TRUE);
/* create a color map */
cmap = XCreateColormap(dpy, RootWindow(dpy, vi->screen),
vi->visual, AllocNone);
/* create a window */
width = 400;
height = 300;
hint.x = 0;
hint.y = 0;
hint.width = width;
hint.height = height;
hint.flags = PPosition | PSize;
swa.colormap = cmap;
swa.border_pixel = 0;
swa.event_mask = StructureNotifyMask;
win = XCreateWindow(dpy, RootWindow(dpy, vi->screen), 0, 0, width, height,
0, vi->depth, InputOutput, vi->visual,
CWBorderPixel | CWColormap | CWEventMask, &swa);
XSetStandardProperties(dpy, win, name, name, None, NULL, 0, &hint);
XMapWindow(dpy, win);
XIfEvent(dpy, &event, WaitForNotify, (char *)win);
XSelectInput(dpy, win, KeyPressMask | StructureNotifyMask | ExposureMask);
/* connect the context to the window */
glXMakeCurrent(dpy, win, cx);
init();
reshape(width, height);
while (1) {
if (XPending(dpy) > 0) {
XNextEvent(dpy, &xev);
switch (xev.type) {
case KeyPress:
XLookupString((XKeyEvent *)&xev, buf, 80, &keysym, &status);
switch (keysym) {
case XK_Up:
k = KEY_UP;
break;
case XK_Down:
k = KEY_DOWN;
break;
case XK_Left:
k = KEY_LEFT;
break;
case XK_Right:
k = KEY_RIGHT;
break;
case XK_Escape:
k = KEY_ESCAPE;
break;
default:
k = keysym;
}
key(k, 0);
break;
case ConfigureNotify: {
int width, height;
width = xev.xconfigure.width;
height = xev.xconfigure.height;
glXWaitX();
reshape(width, height);
}
break;
}
} else {
idle();
}
}
return 0;
}
static void
processEventsAndTimeouts(void)
{
do {
#if defined(_WIN32)
MSG event;
if(!GetMessage(&event, NULL, 0, 0)) /* bail if no more messages */
exit(0);
TranslateMessage(&event); /* translate virtual-key messages */
DispatchMessage(&event); /* call the window proc */
/* see win32_event.c for event (message) processing procedures */
#else
static int mappedMenuButton;
GLUTeventParser *parser;
XEvent event, ahead;
GLUTwindow *window;
GLUTkeyboardCB keyboard;
GLUTspecialCB special;
int gotEvent, width, height;
gotEvent = interruptibleXNextEvent(__glutDisplay, &event);
if (gotEvent) {
switch (event.type) {
case MappingNotify:
XRefreshKeyboardMapping((XMappingEvent *) & event);
break;
case ConfigureNotify:
window = __glutGetWindow(event.xconfigure.window);
if (window) {
if (window->win != event.xconfigure.window) {
/* Ignore ConfigureNotify sent to the overlay
planes. GLUT could get here because overlays
select for StructureNotify events to receive
DestroyNotify. */
break;
}
width = event.xconfigure.width;
height = event.xconfigure.height;
if (width != window->width || height != window->height) {
if (window->overlay) {
XResizeWindow(__glutDisplay, window->overlay->win, width, height);
}
window->width = width;
window->height = height;
__glutSetWindow(window);
/* Do not execute OpenGL out of sequence with
respect to the XResizeWindow request! */
glXWaitX();
window->reshape(width, height);
window->forceReshape = False;
/* A reshape should be considered like posting a
repair; this is necessary for the "Mesa
glXSwapBuffers to repair damage" hack to operate
correctly. Without it, there's not an initial
back buffer render from which to blit from when
damage happens to the window. */
__glutPostRedisplay(window, GLUT_REPAIR_WORK);
}
}
break;
case Expose:
/* compress expose events */
while (XEventsQueued(__glutDisplay, QueuedAfterReading)
> 0) {
XPeekEvent(__glutDisplay, &ahead);
if (ahead.type != Expose ||
ahead.xexpose.window != event.xexpose.window) {
break;
}
XNextEvent(__glutDisplay, &event);
}
if (event.xexpose.count == 0) {
GLUTmenu *menu;
if (__glutMappedMenu &&
(menu = __glutGetMenu(event.xexpose.window))) {
__glutPaintMenu(menu);
} else {
window = __glutGetWindow(event.xexpose.window);
if (window) {
if (window->win == event.xexpose.window) {
__glutPostRedisplay(window, GLUT_REPAIR_WORK);
} else if (window->overlay && window->overlay->win == event.xexpose.window) {
__glutPostRedisplay(window, GLUT_OVERLAY_REPAIR_WORK);
}
}
}
} else {
/* there are more exposes to read; wait to redisplay */
}
break;
case ButtonPress:
case ButtonRelease:
if (__glutMappedMenu && event.type == ButtonRelease
&& mappedMenuButton == event.xbutton.button) {
/* Menu is currently popped up and its button is
released. */
__glutFinishMenu(event.xbutton.window, event.xbutton.x, event.xbutton.y);
} else {
window = __glutGetWindow(event.xbutton.window);
/* added button check for mice with > 3 buttons */
if (window) {
GLUTmenu *menu;
int menuNum;
if (event.xbutton.button <= GLUT_MAX_MENUS)
menuNum = window->menu[event.xbutton.button - 1];
else
menuNum = 0;
/* Make sure that __glutGetMenuByNum is only called if there
really is a menu present. */
if ((menuNum > 0) && (menu = __glutGetMenuByNum(menuNum))) {
if (event.type == ButtonPress && !__glutMappedMenu) {
__glutStartMenu(menu, window,
event.xbutton.x_root, event.xbutton.y_root,
event.xbutton.x, event.xbutton.y);
mappedMenuButton = event.xbutton.button;
} else {
/* Ignore a release of a button with a menu
attatched to it when no menu is popped up,
or ignore a press when another menu is
already popped up. */
}
} else if (window->mouse) {
__glutSetWindow(window);
__glutModifierMask = event.xbutton.state;
window->mouse(event.xbutton.button - 1,
event.type == ButtonRelease ?
GLUT_UP : GLUT_DOWN,
event.xbutton.x, event.xbutton.y);
__glutModifierMask = ~0;
} else {
/* Stray mouse events. Ignore. */
}
} else {
/* Window might have been destroyed and all the
events for the window may not yet be received. */
}
}
break;
case MotionNotify:
if (!__glutMappedMenu) {
window = __glutGetWindow(event.xmotion.window);
if (window) {
/* If motion function registered _and_ buttons held
* down, call motion function... */
if (window->motion && event.xmotion.state &
(Button1Mask | Button2Mask | Button3Mask)) {
__glutSetWindow(window);
window->motion(event.xmotion.x, event.xmotion.y);
}
/* If passive motion function registered _and_
buttons not held down, call passive motion
function... */
else if (window->passive &&
((event.xmotion.state &
(Button1Mask | Button2Mask | Button3Mask)) ==
0)) {
__glutSetWindow(window);
window->passive(event.xmotion.x,
event.xmotion.y);
}
}
} else {
/* Motion events are thrown away when a pop up menu
is active. */
}
break;
case KeyPress:
case KeyRelease:
window = __glutGetWindow(event.xkey.window);
if (!window) {
break;
}
if (event.type == KeyPress) {
keyboard = window->keyboard;
} else {
/* If we are ignoring auto repeated keys for this window,
check if the next event in the X event queue is a KeyPress
for the exact same key (and at the exact same time) as the
key being released. The X11 protocol will send auto
repeated keys as such KeyRelease/KeyPress pairs. */
if (window->ignoreKeyRepeat) {
if (XEventsQueued(__glutDisplay, QueuedAfterReading)) {
XPeekEvent(__glutDisplay, &ahead);
if (ahead.type == KeyPress
&& ahead.xkey.window == event.xkey.window
&& ahead.xkey.keycode == event.xkey.keycode
&& ahead.xkey.time == event.xkey.time) {
/* Pop off the repeated KeyPress and ignore
the auto repeated KeyRelease/KeyPress pair. */
XNextEvent(__glutDisplay, &event);
break;
}
}
}
keyboard = window->keyboardUp;
}
if (keyboard) {
char tmp[1];
int rc;
rc = XLookupString(&event.xkey, tmp, sizeof(tmp),
NULL, NULL);
if (rc) {
__glutSetWindow(window);
__glutModifierMask = event.xkey.state;
keyboard(tmp[0],
event.xkey.x, event.xkey.y);
__glutModifierMask = ~0;
break;
}
}
if (event.type == KeyPress) {
special = window->special;
} else {
special = window->specialUp;
}
if (special) {
KeySym ks;
int key;
/* Introduced in X11R6: (Partial list of) Keypad Functions. Define
in place in case compiling against an older pre-X11R6
X11/keysymdef.h file. */
#ifndef XK_KP_Home
#define XK_KP_Home 0xFF95
#endif
#ifndef XK_KP_Left
#define XK_KP_Left 0xFF96
#endif
#ifndef XK_KP_Up
#define XK_KP_Up 0xFF97
#endif
#ifndef XK_KP_Right
#define XK_KP_Right 0xFF98
#endif
#ifndef XK_KP_Down
#define XK_KP_Down 0xFF99
#endif
#ifndef XK_KP_Prior
#define XK_KP_Prior 0xFF9A
#endif
#ifndef XK_KP_Next
#define XK_KP_Next 0xFF9B
#endif
#ifndef XK_KP_End
#define XK_KP_End 0xFF9C
#endif
#ifndef XK_KP_Insert
#define XK_KP_Insert 0xFF9E
#endif
#ifndef XK_KP_Delete
#define XK_KP_Delete 0xFF9F
#endif
ks = XLookupKeysym((XKeyEvent *) & event, 0);
/* XXX Verbose, but makes no assumptions about keysym
layout. */
switch (ks) {
/* *INDENT-OFF* */
/* function keys */
case XK_F1: key = GLUT_KEY_F1; break;
case XK_F2: key = GLUT_KEY_F2; break;
case XK_F3: key = GLUT_KEY_F3; break;
case XK_F4: key = GLUT_KEY_F4; break;
case XK_F5: key = GLUT_KEY_F5; break;
case XK_F6: key = GLUT_KEY_F6; break;
case XK_F7: key = GLUT_KEY_F7; break;
case XK_F8: key = GLUT_KEY_F8; break;
case XK_F9: key = GLUT_KEY_F9; break;
case XK_F10: key = GLUT_KEY_F10; break;
case XK_F11: key = GLUT_KEY_F11; break;
case XK_F12: key = GLUT_KEY_F12; break;
/* directional keys */
case XK_KP_Left:
case XK_Left: key = GLUT_KEY_LEFT; break;
case XK_KP_Up: /* Introduced in X11R6. */
case XK_Up: key = GLUT_KEY_UP; break;
case XK_KP_Right: /* Introduced in X11R6. */
case XK_Right: key = GLUT_KEY_RIGHT; break;
case XK_KP_Down: /* Introduced in X11R6. */
case XK_Down: key = GLUT_KEY_DOWN; break;
/* *INDENT-ON* */
case XK_KP_Prior: /* Introduced in X11R6. */
case XK_Prior:
/* XK_Prior same as X11R6's XK_Page_Up */
key = GLUT_KEY_PAGE_UP;
break;
case XK_KP_Next: /* Introduced in X11R6. */
case XK_Next:
/* XK_Next same as X11R6's XK_Page_Down */
key = GLUT_KEY_PAGE_DOWN;
break;
case XK_KP_Home: /* Introduced in X11R6. */
case XK_Home:
key = GLUT_KEY_HOME;
break;
#ifdef __hpux
case XK_Select:
#endif
case XK_KP_End: /* Introduced in X11R6. */
case XK_End:
key = GLUT_KEY_END;
break;
#ifdef __hpux
case XK_InsertChar:
#endif
case XK_KP_Insert: /* Introduced in X11R6. */
case XK_Insert:
key = GLUT_KEY_INSERT;
break;
#ifdef __hpux
case XK_DeleteChar:
#endif
case XK_KP_Delete: /* Introduced in X11R6. */
/* The Delete character is really an ASCII key. */
__glutSetWindow(window);
keyboard(127, /* ASCII Delete character. */
event.xkey.x, event.xkey.y);
goto skip;
default:
goto skip;
}
__glutSetWindow(window);
__glutModifierMask = event.xkey.state;
special(key, event.xkey.x, event.xkey.y);
__glutModifierMask = ~0;
skip:;
}
break;
case EnterNotify:
case LeaveNotify:
if (event.xcrossing.mode != NotifyNormal ||
event.xcrossing.detail == NotifyNonlinearVirtual ||
event.xcrossing.detail == NotifyVirtual) {
/* Careful to ignore Enter/LeaveNotify events that
come from the pop-up menu pointer grab and ungrab.
Also, ignore "virtual" Enter/LeaveNotify events
since they represent the pointer passing through
the window hierarchy without actually entering or
leaving the actual real estate of a window. */
break;
}
if (__glutMappedMenu) {
GLUTmenuItem *item;
int num;
item = __glutGetMenuItem(__glutMappedMenu,
event.xcrossing.window, &num);
if (item) {
__glutMenuItemEnterOrLeave(item, num, event.type);
break;
}
}
window = __glutGetWindow(event.xcrossing.window);
if (window) {
if (window->entry) {
if (event.type == EnterNotify) {
/* With overlays established, X can report two
enter events for both the overlay and normal
plane window. Do not generate a second enter
callback if we reported one without an
intervening leave. */
if (window->entryState != EnterNotify) {
int num = window->num;
Window xid = window->win;
window->entryState = EnterNotify;
__glutSetWindow(window);
window->entry(GLUT_ENTERED);
if (__glutMappedMenu) {
/* Do not generate any passive motion events
when menus are in use. */
} else {
/* An EnterNotify event can result in a
"compound" callback if a passive motion
callback is also registered. In this case,
be a little paranoid about the possibility
the window could have been destroyed in the
entry callback. */
window = __glutWindowList[num];
if (window && window->passive && window->win == xid) {
__glutSetWindow(window);
window->passive(event.xcrossing.x, event.xcrossing.y);
}
}
}
} else {
if (window->entryState != LeaveNotify) {
/* When an overlay is established for a window
already mapped and with the pointer in it,
the X server will generate a leave/enter
event pair as the pointer leaves (without
moving) from the normal plane X window to
the newly mapped overlay X window (or vice
versa). This enter/leave pair should not be
reported to the GLUT program since the pair
is a consequence of creating (or destroying)
the overlay, not an actual leave from the
GLUT window. */
if (XEventsQueued(__glutDisplay, QueuedAfterReading)) {
XPeekEvent(__glutDisplay, &ahead);
if (ahead.type == EnterNotify &&
__glutGetWindow(ahead.xcrossing.window) == window) {
XNextEvent(__glutDisplay, &event);
break;
}
}
window->entryState = LeaveNotify;
__glutSetWindow(window);
window->entry(GLUT_LEFT);
}
}
} else if (window->passive) {
__glutSetWindow(window);
window->passive(event.xcrossing.x, event.xcrossing.y);
}
}
break;
case UnmapNotify:
/* MapNotify events are not needed to maintain
visibility state since VisibilityNotify events will
be delivered when a window becomes visible from
mapping. However, VisibilityNotify events are not
delivered when a window is unmapped (for the window
or its children). */
window = __glutGetWindow(event.xunmap.window);
if (window) {
if (window->win != event.xconfigure.window) {
/* Ignore UnmapNotify sent to the overlay planes.
GLUT could get here because overlays select for
StructureNotify events to receive DestroyNotify.
*/
break;
}
markWindowHidden(window);
}
break;
case VisibilityNotify:
window = __glutGetWindow(event.xvisibility.window);
if (window) {
/* VisibilityUnobscured+1 = GLUT_FULLY_RETAINED,
VisibilityPartiallyObscured+1 =
GLUT_PARTIALLY_RETAINED, VisibilityFullyObscured+1
= GLUT_FULLY_COVERED. */
int visState = event.xvisibility.state + 1;
if (visState != window->visState) {
if (window->windowStatus) {
window->visState = visState;
__glutSetWindow(window);
window->windowStatus(visState);
}
}
}
break;
case ClientMessage:
if (event.xclient.data.l[0] == __glutWMDeleteWindow)
exit(0);
break;
case DestroyNotify:
purgeStaleWindow(event.xdestroywindow.window);
break;
case CirculateNotify:
case CreateNotify:
case GravityNotify:
case ReparentNotify:
/* Uninteresting to GLUT (but possible for GLUT to
receive). */
break;
default:
/* Pass events not directly handled by the GLUT main
event loop to any event parsers that have been
registered. In this way, X Input extension events
are passed to the correct handler without forcing
all GLUT programs to support X Input event handling.
*/
parser = eventParserList;
while (parser) {
if (parser->func(&event))
break;
parser = parser->next;
}
break;
}
}
#endif /* _WIN32 */
if (__glutTimerList) {
handleTimeouts();
}
}
while (XPending(__glutDisplay));
}
