/*

MiniGLUT - minimal GLUT subset without dependencies

Copyright (C) 2020-2022 John Tsiombikas <[email protected]>

This program is free software: you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation, either version 3 of the License, or

(at your option) any later version.

This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with this program. If not, see <https://www.gnu.org/licenses/>.

*/

#if defined(__unix__)

#include <X11/Xlib.h>

#include <X11/keysym.h>

#include <X11/cursorfont.h>

#include <GL/glx.h>

#define BUILD_X11

#ifndef GLX_SAMPLE_BUFFERS_ARB

#define GLX_SAMPLE_BUFFERS_ARB 100000

#define GLX_SAMPLES_ARB 100001

#endif

#ifndef GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB

#define GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB 0x20b2

#endif

static Display *dpy;

static Window win, root;

static int scr;

static GLXContext ctx;

static Atom xa_wm_proto, xa_wm_del_win;

static Atom xa_net_wm_state, xa_net_wm_state_fullscr;

static Atom xa_motif_wm_hints;

static Atom xa_motion_event, xa_button_press_event, xa_button_release_event, xa_command_event;

static unsigned int evmask;

static Cursor blank_cursor;

static int have_netwm_fullscr(void);

#elif defined(_WIN32)

#include <windows.h>

#define BUILD_WIN32

static LRESULT CALLBACK handle_message(HWND win, unsigned int msg, WPARAM wparam, LPARAM lparam);

static HINSTANCE hinst;

static HWND win;

static HDC dc;

static HGLRC ctx;

#else

#error unsupported platform

#endif

#include <GL/gl.h>

#include "miniglut.h"

struct ctx_info {

int rsize, gsize, bsize, asize;

int zsize, ssize;

int dblbuf;

int samples;

int stereo;

int srgb;

};

static void cleanup(void);

static void create_window(const char *title);

static void get_window_pos(int *x, int *y);

static void get_window_size(int *w, int *h);

static void get_screen_size(int *scrw, int *scrh);

static long get_msec(void);

static void panic(const char *msg);

static void sys_exit(int status);

static int sys_write(int fd, const void *buf, int count);

static int init_x = -1, init_y, init_width = 256, init_height = 256;

static unsigned int init_mode;

static struct ctx_info ctx_info;

static int cur_cursor = GLUT_CURSOR_INHERIT;

static int ignore_key_repeat;

static glut_cb cb_display;

static glut_cb cb_idle;

static glut_cb_reshape cb_reshape;

static glut_cb_state cb_vis, cb_entry;

static glut_cb_keyb cb_keydown, cb_keyup;

static glut_cb_special cb_skeydown, cb_skeyup;

static glut_cb_mouse cb_mouse;

static glut_cb_motion cb_motion, cb_passive;

static glut_cb_sbmotion cb_sball_motion, cb_sball_rotate;

static glut_cb_sbbutton cb_sball_button;

static int fullscreen;

static int prev_win_x, prev_win_y, prev_win_width, prev_win_height;

static int win_width, win_height;

static int mapped;

static int quit;

static int upd_pending;

static int modstate;

void glutInit(int *argc, char **argv)

{

#ifdef BUILD_X11

Pixmap blankpix = 0;

XColor xcol;

if(!(dpy = XOpenDisplay(0))) {

panic("Failed to connect to the X server\n");

}

scr = DefaultScreen(dpy);

root = RootWindow(dpy, scr);

xa_wm_proto = XInternAtom(dpy, "WM_PROTOCOLS", False);

xa_wm_del_win = XInternAtom(dpy, "WM_DELETE_WINDOW", False);

xa_motif_wm_hints = XInternAtom(dpy, "_MOTIF_WM_HINTS", False);

xa_net_wm_state_fullscr = XInternAtom(dpy, "_NET_WM_STATE_FULLSCREEN", False);

if(have_netwm_fullscr()) {

xa_net_wm_state = XInternAtom(dpy, "_NET_WM_STATE", False);

}

xa_motion_event = XInternAtom(dpy, "MotionEvent", True);

xa_button_press_event = XInternAtom(dpy, "ButtonPressEvent", True);

xa_button_release_event = XInternAtom(dpy, "ButtonReleaseEvent", True);

xa_command_event = XInternAtom(dpy, "CommandEvent", True);

evmask = ExposureMask | StructureNotifyMask;

if((blankpix = XCreateBitmapFromData(dpy, root, (char*)&blankpix, 1, 1))) {

blank_cursor = XCreatePixmapCursor(dpy, blankpix, blankpix, &xcol, &xcol, 0, 0);

XFreePixmap(dpy, blankpix);

}

#endif

#ifdef BUILD_WIN32

WNDCLASSEX wc = {0};

hinst = GetModuleHandle(0);

wc.cbSize = sizeof wc;

wc.hbrBackground = GetStockObject(BLACK_BRUSH);

wc.hCursor = LoadCursor(0, IDC_ARROW);

wc.hIcon = wc.hIconSm = LoadIcon(0, IDI_APPLICATION);

wc.hInstance = hinst;

wc.lpfnWndProc = handle_message;

wc.lpszClassName = "MiniGLUT";

wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;

if(!RegisterClassEx(&wc)) {

panic("Failed to register \"MiniGLUT\" window class\n");

}

if(init_x == -1) {

get_screen_size(&init_x, &init_y);

init_x >>= 3;

init_y >>= 3;

}

#endif

}

void glutInitWindowPosition(int x, int y)

{

init_x = x;

init_y = y;

}

void glutInitWindowSize(int xsz, int ysz)

{

init_width = xsz;

init_height = ysz;

}

void glutInitDisplayMode(unsigned int mode)

{

init_mode = mode;

}

void glutCreateWindow(const char *title)

{

create_window(title);

}

void glutExit(void)

{

quit = 1;

}

void glutMainLoop(void)

{

while(!quit) {

glutMainLoopEvent();

}

}

void glutPostRedisplay(void)

{

upd_pending = 1;

}

void glutIgnoreKeyRepeat(int ignore)

{

ignore_key_repeat = ignore;

}

#define UPD_EVMASK(x) \

do { \

if(func) { \

evmask |= x; \

} else { \

evmask &= ~(x); \

} \

if(win) XSelectInput(dpy, win, evmask); \

} while(0)

void glutIdleFunc(glut_cb func)

{

cb_idle = func;

}

void glutDisplayFunc(glut_cb func)

{

cb_display = func;

}

void glutReshapeFunc(glut_cb_reshape func)

{

cb_reshape = func;

}

void glutVisibilityFunc(glut_cb_state func)

{

cb_vis = func;

#ifdef BUILD_X11

UPD_EVMASK(VisibilityChangeMask);

#endif

}

void glutEntryFunc(glut_cb_state func)

{

cb_entry = func;

#ifdef BUILD_X11

UPD_EVMASK(EnterWindowMask | LeaveWindowMask);

#endif

}

void glutKeyboardFunc(glut_cb_keyb func)

{

cb_keydown = func;

#ifdef BUILD_X11

UPD_EVMASK(KeyPressMask);

#endif

}

void glutKeyboardUpFunc(glut_cb_keyb func)

{

cb_keyup = func;

#ifdef BUILD_X11

UPD_EVMASK(KeyReleaseMask);

#endif

}

void glutSpecialFunc(glut_cb_special func)

{

cb_skeydown = func;

#ifdef BUILD_X11

UPD_EVMASK(KeyPressMask);

#endif

}

void glutSpecialUpFunc(glut_cb_special func)

{

cb_skeyup = func;

#ifdef BUILD_X11

UPD_EVMASK(KeyReleaseMask);

#endif

}

void glutMouseFunc(glut_cb_mouse func)

{

cb_mouse = func;

#ifdef BUILD_X11

UPD_EVMASK(ButtonPressMask | ButtonReleaseMask);

#endif

}

void glutMotionFunc(glut_cb_motion func)

{

cb_motion = func;

#ifdef BUILD_X11

UPD_EVMASK(ButtonMotionMask);

#endif

}

void glutPassiveMotionFunc(glut_cb_motion func)

{

cb_passive = func;

#ifdef BUILD_X11

UPD_EVMASK(PointerMotionMask);

#endif

}

void glutSpaceballMotionFunc(glut_cb_sbmotion func)

{

cb_sball_motion = func;

}

void glutSpaceballRotateFunc(glut_cb_sbmotion func)

{

cb_sball_rotate = func;

}

void glutSpaceballButtonFunc(glut_cb_sbbutton func)

{

cb_sball_button = func;

}

int glutGet(unsigned int s)

{

int x, y;

switch(s) {

case GLUT_WINDOW_X:

get_window_pos(&x, &y);

return x;

case GLUT_WINDOW_Y:

get_window_pos(&x, &y);

return y;

case GLUT_WINDOW_WIDTH:

get_window_size(&x, &y);

return x;

case GLUT_WINDOW_HEIGHT:

get_window_size(&x, &y);

return y;

case GLUT_WINDOW_BUFFER_SIZE:

return ctx_info.rsize + ctx_info.gsize + ctx_info.bsize + ctx_info.asize;

case GLUT_WINDOW_STENCIL_SIZE:

return ctx_info.ssize;

case GLUT_WINDOW_DEPTH_SIZE:

return ctx_info.zsize;

case GLUT_WINDOW_RED_SIZE:

return ctx_info.rsize;

case GLUT_WINDOW_GREEN_SIZE:

return ctx_info.gsize;

case GLUT_WINDOW_BLUE_SIZE:

return ctx_info.bsize;

case GLUT_WINDOW_ALPHA_SIZE:

return ctx_info.asize;

case GLUT_WINDOW_DOUBLEBUFFER:

return ctx_info.dblbuf;

case GLUT_WINDOW_RGBA:

return 1;

case GLUT_WINDOW_NUM_SAMPLES:

return ctx_info.samples;

case GLUT_WINDOW_STEREO:

return ctx_info.stereo;

case GLUT_WINDOW_SRGB:

return ctx_info.srgb;

case GLUT_WINDOW_CURSOR:

return cur_cursor;

case GLUT_SCREEN_WIDTH:

get_screen_size(&x, &y);

return x;

case GLUT_SCREEN_HEIGHT:

get_screen_size(&x, &y);

return y;

case GLUT_INIT_DISPLAY_MODE:

return init_mode;

case GLUT_INIT_WINDOW_X:

return init_x;

case GLUT_INIT_WINDOW_Y:

return init_y;

case GLUT_INIT_WINDOW_WIDTH:

return init_width;

case GLUT_INIT_WINDOW_HEIGHT:

return init_height;

case GLUT_ELAPSED_TIME:

return get_msec();

default:

break;

}

return 0;

}

int glutGetModifiers(void)

{

return modstate;

}

static int is_space(int c)

{

return c == ' ' || c == '\t' || c == '\v' || c == '\n' || c == '\r';

}

static const char *skip_space(const char *s)

{

while(*s && is_space(*s)) s++;

return s;

}

int glutExtensionSupported(char *ext)

{

const char *str, *eptr;

if(!(str = (const char*)glGetString(GL_EXTENSIONS))) {

return 0;

}

while(*str) {

str = skip_space(str);

eptr = skip_space(ext);

while(*str && !is_space(*str) && *eptr && *str == *eptr) {

str++;

eptr++;

}

if((!*str || is_space(*str)) && !*eptr) {

return 1;

}

while(*str && !is_space(*str)) str++;

}

return 0;

}

/* --------------- UNIX/X11 implementation ----------------- */

#ifdef BUILD_X11

enum {

SPNAV_EVENT_ANY, /* used by spnav_remove_events() */

SPNAV_EVENT_MOTION,

SPNAV_EVENT_BUTTON /* includes both press and release */

};

struct spnav_event_motion {

int type;

int x, y, z;

int rx, ry, rz;

unsigned int period;

int *data;

};

struct spnav_event_button {

int type;

int press;

int bnum;

};

union spnav_event {

int type;

struct spnav_event_motion motion;

struct spnav_event_button button;

};

static void handle_event(XEvent *ev);

static int spnav_window(Window win);

static int spnav_event(const XEvent *xev, union spnav_event *event);

static int spnav_remove_events(int type);

void glutMainLoopEvent(void)

{

XEvent ev;

if(!cb_display) {

panic("display callback not set");

}

if(!upd_pending && !cb_idle) {

XNextEvent(dpy, &ev);

handle_event(&ev);

if(quit) goto end;

}

while(XPending(dpy)) {

XNextEvent(dpy, &ev);

handle_event(&ev);

if(quit) goto end;

}

if(cb_idle) {

cb_idle();

}

if(upd_pending && mapped) {

upd_pending = 0;

cb_display();

}

end:

if(quit) {

cleanup();

}

}

static void cleanup(void)

{

if(win) {

spnav_window(root);

glXMakeCurrent(dpy, 0, 0);

XDestroyWindow(dpy, win);

}

}

static KeySym translate_keysym(KeySym sym)

{

switch(sym) {

case XK_Escape:

return 27;

case XK_BackSpace:

return '\b';

case XK_Linefeed:

return '\r';

case XK_Return:

return '\n';

case XK_Delete:

return 127;

case XK_Tab:

return '\t';

default:

break;

}

return sym;

}

static void handle_event(XEvent *ev)

{

KeySym sym;

union spnav_event sev;

switch(ev->type) {

case MapNotify:

mapped = 1;

break;

case UnmapNotify:

mapped = 0;

break;

case ConfigureNotify:

if(cb_reshape && (ev->xconfigure.width != win_width || ev->xconfigure.height != win_height)) {

win_width = ev->xconfigure.width;

win_height = ev->xconfigure.height;

cb_reshape(ev->xconfigure.width, ev->xconfigure.height);

}

break;

case ClientMessage:

if(ev->xclient.message_type == xa_wm_proto) {

if(ev->xclient.data.l[0] == xa_wm_del_win) {

quit = 1;

}

}

if(spnav_event(ev, &sev)) {

switch(sev.type) {

case SPNAV_EVENT_MOTION:

if(cb_sball_motion) {

cb_sball_motion(sev.motion.x, sev.motion.y, sev.motion.z);

}

if(cb_sball_rotate) {

cb_sball_rotate(sev.motion.rx, sev.motion.ry, sev.motion.rz);

}

spnav_remove_events(SPNAV_EVENT_MOTION);

break;

case SPNAV_EVENT_BUTTON:

if(cb_sball_button) {

cb_sball_button(sev.button.bnum + 1, sev.button.press ? GLUT_DOWN : GLUT_UP);

}

break;

default:

break;

}

}

break;

case Expose:

upd_pending = 1;

break;

case KeyPress:

if(0) {

case KeyRelease:

if(ignore_key_repeat && XEventsQueued(dpy, QueuedAfterReading)) {

XEvent next;

XPeekEvent(dpy, &next);

if(next.type == KeyPress && next.xkey.keycode == ev->xkey.keycode &&

next.xkey.time == ev->xkey.time) {

/* this is a key-repeat event, ignore the release and consume

* the following press

*/

XNextEvent(dpy, &next);

break;

}

}

}

modstate = ev->xkey.state & (ShiftMask | ControlMask | Mod1Mask);

if(!(sym = XLookupKeysym(&ev->xkey, 0))) {

break;

}

sym = translate_keysym(sym);

if(sym < 256) {

if(ev->type == KeyPress) {

if(cb_keydown) cb_keydown((unsigned char)sym, ev->xkey.x, ev->xkey.y);

} else {

if(cb_keyup) cb_keyup((unsigned char)sym, ev->xkey.x, ev->xkey.y);

}

} else {

if(ev->type == KeyPress) {

if(cb_skeydown) cb_skeydown(sym, ev->xkey.x, ev->xkey.y);

} else {

if(cb_skeyup) cb_skeyup(sym, ev->xkey.x, ev->xkey.y);

}

}

break;

case ButtonPress:

case ButtonRelease:

modstate = ev->xbutton.state & (ShiftMask | ControlMask | Mod1Mask);

if(cb_mouse) {

int bn = ev->xbutton.button - Button1;

cb_mouse(bn, ev->type == ButtonPress ? GLUT_DOWN : GLUT_UP,

ev->xbutton.x, ev->xbutton.y);

}

break;

case MotionNotify:

if(ev->xmotion.state & (Button1Mask | Button2Mask | Button3Mask | Button4Mask | Button5Mask)) {

if(cb_motion) cb_motion(ev->xmotion.x, ev->xmotion.y);

} else {

if(cb_passive) cb_passive(ev->xmotion.x, ev->xmotion.y);

}

break;

case VisibilityNotify:

if(cb_vis) {

cb_vis(ev->xvisibility.state == VisibilityFullyObscured ? GLUT_NOT_VISIBLE : GLUT_VISIBLE);

}

break;

case EnterNotify:

if(cb_entry) cb_entry(GLUT_ENTERED);

break;

case LeaveNotify:

if(cb_entry) cb_entry(GLUT_LEFT);

break;

}

}

void glutSwapBuffers(void)

{

glXSwapBuffers(dpy, win);

}

/* BUG:

* set_fullscreen_mwm removes the decorations with MotifWM hints, and then it

* needs to resize the window to make it fullscreen. The way it does this is by

* querying the size of the root window (see get_screen_size), which in the

* case of multi-monitor setups will be the combined size of all monitors.

* This is problematic; the way to solve it is to use the XRandR extension, or

* the Xinerama extension, to figure out the dimensions of the correct video

* output, which would add potentially two extension support libraries to our

* dependencies list.

* Moreover, any X installation modern enough to support XR&R will almost

* certainly be running a window manager supporting the EHWM

* _NET_WM_STATE_FULLSCREEN method (set_fullscreen_ewmh), which does not rely

* on manual resizing, and is used in preference if available, making this

* whole endeavor pointless.

* So I'll just leave it with set_fullscreen_mwm covering the entire

* multi-monitor area for now.

*/

struct mwm_hints {

unsigned long flags;

unsigned long functions;

unsigned long decorations;

long input_mode;

unsigned long status;

};

#define MWM_HINTS_DECORATIONS 2

#define MWM_DECOR_ALL 1

static void set_fullscreen_mwm(int fs)

{

struct mwm_hints hints;

int scr_width, scr_height;

if(fs) {

get_window_pos(&prev_win_x, &prev_win_y);

get_window_size(&prev_win_width, &prev_win_height);

get_screen_size(&scr_width, &scr_height);

hints.decorations = 0;

hints.flags = MWM_HINTS_DECORATIONS;

XChangeProperty(dpy, win, xa_motif_wm_hints, xa_motif_wm_hints, 32,

PropModeReplace, (unsigned char*)&hints, 5);

XMoveResizeWindow(dpy, win, 0, 0, scr_width, scr_height);

} else {

XDeleteProperty(dpy, win, xa_motif_wm_hints);

XMoveResizeWindow(dpy, win, prev_win_x, prev_win_y, prev_win_width, prev_win_height);

}

}

static int have_netwm_fullscr(void)

{

int fmt;

long offs = 0;

unsigned long i, count, rem;

Atom *prop, type;

Atom xa_net_supported = XInternAtom(dpy, "_NET_SUPPORTED", False);

do {

XGetWindowProperty(dpy, root, xa_net_supported, offs, 8, False, AnyPropertyType,

&type, &fmt, &count, &rem, (unsigned char**)&prop);

for(i=0; i<count; i++) {

if(prop[i] == xa_net_wm_state_fullscr) {

XFree(prop);

return 1;

}

}

XFree(prop);

offs += count;

} while(rem > 0);

return 0;

}

static void set_fullscreen_ewmh(int fs)

{

XClientMessageEvent msg = {0};

msg.type = ClientMessage;

msg.window = win;

msg.message_type = xa_net_wm_state; /* _NET_WM_STATE */

msg.format = 32;

msg.data.l[0] = fs ? 1 : 0;

msg.data.l[1] = xa_net_wm_state_fullscr; /* _NET_WM_STATE_FULLSCREEN */

msg.data.l[2] = 0;

msg.data.l[3] = 1; /* source regular application */

XSendEvent(dpy, root, False, SubstructureNotifyMask | SubstructureRedirectMask, (XEvent*)&msg);

}

static void set_fullscreen(int fs)

{

if(fullscreen == fs) return;

if(xa_net_wm_state && xa_net_wm_state_fullscr) {

set_fullscreen_ewmh(fs);

fullscreen = fs;

} else if(xa_motif_wm_hints) {

set_fullscreen_mwm(fs);

fullscreen = fs;

}

}

void glutPositionWindow(int x, int y)

{

set_fullscreen(0);

XMoveWindow(dpy, win, x, y);

}

void glutReshapeWindow(int xsz, int ysz)

{

set_fullscreen(0);

XResizeWindow(dpy, win, xsz, ysz);

}

void glutFullScreen(void)

{

set_fullscreen(1);

}

void glutSetWindowTitle(const char *title)

{

XTextProperty tprop;

if(!XStringListToTextProperty((char**)&title, 1, &tprop)) {

return;

}

XSetWMName(dpy, win, &tprop);

XFree(tprop.value);

}

void glutSetIconTitle(const char *title)

{

XTextProperty tprop;

if(!XStringListToTextProperty((char**)&title, 1, &tprop)) {

return;

}

XSetWMIconName(dpy, win, &tprop);

XFree(tprop.value);

}

void glutSetCursor(int cidx)

{

Cursor cur = None;

switch(cidx) {

case GLUT_CURSOR_LEFT_ARROW:

cur = XCreateFontCursor(dpy, XC_left_ptr);

break;

case GLUT_CURSOR_INHERIT:

break;

case GLUT_CURSOR_NONE:

cur = blank_cursor;

break;

default:

return;

}

XDefineCursor(dpy, win, cur);

cur_cursor = cidx;

}

void glutSetKeyRepeat(int repmode)

{

if(repmode) {

XAutoRepeatOn(dpy);

} else {

XAutoRepeatOff(dpy);

}

}

static XVisualInfo *choose_visual(unsigned int mode)

{

XVisualInfo *vi;

int attr[32];

int *aptr = attr;

int *samples = 0;

if(mode & GLUT_DOUBLE) {

*aptr++ = GLX_DOUBLEBUFFER;

}

if(mode & GLUT_INDEX) {

*aptr++ = GLX_BUFFER_SIZE;

*aptr++ = 1;

} else {

*aptr++ = GLX_RGBA;

*aptr++ = GLX_RED_SIZE; *aptr++ = 4;

*aptr++ = GLX_GREEN_SIZE; *aptr++ = 4;

*aptr++ = GLX_BLUE_SIZE; *aptr++ = 4;

}

if(mode & GLUT_ALPHA) {

*aptr++ = GLX_ALPHA_SIZE;

*aptr++ = 4;

}

if(mode & GLUT_DEPTH) {

*aptr++ = GLX_DEPTH_SIZE;

*aptr++ = 16;

}

if(mode & GLUT_STENCIL) {

*aptr++ = GLX_STENCIL_SIZE;

*aptr++ = 1;

}

if(mode & GLUT_ACCUM) {

*aptr++ = GLX_ACCUM_RED_SIZE; *aptr++ = 1;

*aptr++ = GLX_ACCUM_GREEN_SIZE; *aptr++ = 1;

*aptr++ = GLX_ACCUM_BLUE_SIZE; *aptr++ = 1;

}

if(mode & GLUT_STEREO) {

*aptr++ = GLX_STEREO;

}

if(mode & GLUT_SRGB) {

*aptr++ = GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB;

}

if(mode & GLUT_MULTISAMPLE) {

*aptr++ = GLX_SAMPLE_BUFFERS_ARB;

*aptr++ = 1;

*aptr++ = GLX_SAMPLES_ARB;

samples = aptr;

*aptr++ = 32;

}

*aptr++ = None;

if(!samples) {

return glXChooseVisual(dpy, scr, attr);

}

while(!(vi = glXChooseVisual(dpy, scr, attr)) && *samples) {

*samples >>= 1;

if(!*samples) {

aptr[-3] = None;

}

}

return vi;

}

static void create_window(const char *title)

{

XSetWindowAttributes xattr = {0};

XVisualInfo *vi;

unsigned int xattr_mask;

unsigned int mode = init_mode;

if(!(vi = choose_visual(mode))) {

mode &= ~GLUT_SRGB;

if(!(vi = choose_visual(mode))) {

panic("Failed to find compatible visual\n");

}

}

if(!(ctx = glXCreateContext(dpy, vi, 0, True))) {

XFree(vi);

panic("Failed to create OpenGL context\n");

}

glXGetConfig(dpy, vi, GLX_RED_SIZE, &ctx_info.rsize);

glXGetConfig(dpy, vi, GLX_GREEN_SIZE, &ctx_info.gsize);

glXGetConfig(dpy, vi, GLX_BLUE_SIZE, &ctx_info.bsize);

glXGetConfig(dpy, vi, GLX_ALPHA_SIZE, &ctx_info.asize);

glXGetConfig(dpy, vi, GLX_DEPTH_SIZE, &ctx_info.zsize);

glXGetConfig(dpy, vi, GLX_STENCIL_SIZE, &ctx_info.ssize);

glXGetConfig(dpy, vi, GLX_DOUBLEBUFFER, &ctx_info.dblbuf);

glXGetConfig(dpy, vi, GLX_STEREO, &ctx_info.stereo);

glXGetConfig(dpy, vi, GLX_SAMPLES_ARB, &ctx_info.samples);

glXGetConfig(dpy, vi, GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB, &ctx_info.srgb);

xattr.background_pixel = BlackPixel(dpy, scr);

xattr.colormap = XCreateColormap(dpy, root, vi->visual, AllocNone);

xattr_mask = CWBackPixel | CWColormap | CWBackPixmap | CWBorderPixel;

if(!(win = XCreateWindow(dpy, root, init_x, init_y, init_width, init_height, 0,

vi->depth, InputOutput, vi->visual, xattr_mask, &xattr))) {

XFree(vi);

glXDestroyContext(dpy, ctx);

panic("Failed to create window\n");

}

XFree(vi);

XSelectInput(dpy, win, evmask);

spnav_window(win);

glutSetWindowTitle(title);

glutSetIconTitle(title);

XSetWMProtocols(dpy, win, &xa_wm_del_win, 1);

XMapWindow(dpy, win);

glXMakeCurrent(dpy, win, ctx);

}

static void get_window_pos(int *x, int *y)

{

Window child;

XTranslateCoordinates(dpy, win, root, 0, 0, x, y, &child);

}

static void get_window_size(int *w, int *h)

{

XWindowAttributes wattr;

XGetWindowAttributes(dpy, win, &wattr);

*w = wattr.width;

*h = wattr.height;

}

static void get_screen_size(int *scrw, int *scrh)

{

XWindowAttributes wattr;

XGetWindowAttributes(dpy, root, &wattr);

*scrw = wattr.width;

*scrh = wattr.height;

}

/* spaceball */

enum {

CMD_APP_WINDOW = 27695,

CMD_APP_SENS

};

static Window get_daemon_window(Display *dpy);

static int catch_badwin(Display *dpy, XErrorEvent *err);

#define SPNAV_INITIALIZED (xa_motion_event)

static int spnav_window(Window win)

{

int (*prev_xerr_handler)(Display*, XErrorEvent*);

XEvent xev;

Window daemon_win;

if(!SPNAV_INITIALIZED) {

return -1;

}

if(!(daemon_win = get_daemon_window(dpy))) {

return -1;

}

prev_xerr_handler = XSetErrorHandler(catch_badwin);

xev.type = ClientMessage;