static int process_event(XEvent* event) {
KeySym sym;
WindowInfo* info = find_handle(event->xany.window);
if (!info)
return 1;
if (event->type == ClientMessage) {
if ((Atom)event->xclient.data.l[0] == s_wm_delete_window) {
info->update = 0;
mfb_close(info);
return 0;
}
}
switch (event->type)
{
case KeyPress:
{
sym = XLookupKeysym(&event->xkey, 0);
if (handle_special_keys(info, event, 1))
break;
if (info->key_callback)
info->key_callback(info->rust_data, sym, 1);
if (info->char_callback) {
unsigned int t = keySym2Unicode(sym);
if (t != -1)
info->char_callback(info->rust_data, t);
}
break;
}
case KeyRelease:
{
if (handle_special_keys(info, event, 0))
break;
sym = XLookupKeysym(&event->xkey, 0);
if (info->key_callback)
info->key_callback(info->rust_data, sym, 0);
break;
}
case ButtonPress:
{
if (!info->shared_data)
break;
if (event->xbutton.button == Button1)
info->shared_data->state[0] = 1;
else if (event->xbutton.button == Button2)
info->shared_data->state[1] = 1;
else if (event->xbutton.button == Button3)
info->shared_data->state[2] = 1;
else if (event->xbutton.button == Button4)
info->shared_data->scroll_y = 10.0f;
else if (event->xbutton.button == Button5)
info->shared_data->scroll_y = -10.0f;
else if (event->xbutton.button == Button6)
info->shared_data->scroll_x = 10.0f;
else if (event->xbutton.button == Button7)
info->shared_data->scroll_y = -10.0f;
break;
}
case ButtonRelease:
{
if (!info->shared_data)
break;
if (event->xbutton.button == Button1)
info->shared_data->state[0] = 0;
else if (event->xbutton.button == Button2)
info->shared_data->state[1] = 0;
else if (event->xbutton.button == Button3)
info->shared_data->state[2] = 0;
break;
}
case ConfigureNotify:
{
info->width = event->xconfigure.width;
info->height = event->xconfigure.height;
break;
}
}
return 1;
}
void X11_MainLoop()
{
bool fullscreen = SConfig::GetInstance().m_LocalCoreStartupParameter.bFullscreen;
while (Core::GetState() == Core::CORE_UNINITIALIZED)
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 MainLoop() override
{
bool fullscreen = SConfig::GetInstance().bFullscreen;
int last_window_width = SConfig::GetInstance().iRenderWindowWidth;
int last_window_height = SConfig::GetInstance().iRenderWindowHeight;
if (fullscreen)
{
rendererIsFullscreen = X11Utils::ToggleFullscreen(dpy, win);
#if defined(HAVE_XRANDR) && HAVE_XRANDR
XRRConfig->ToggleDisplayMode(True);
#endif
}
// The actual loop
while (s_running.IsSet())
{
if (s_shutdown_requested.TestAndClear())
{
const auto ios = IOS::HLE::GetIOS();
const auto stm = ios ? ios->GetDeviceByName("/dev/stm/eventhook") : nullptr;
if (!s_tried_graceful_shutdown.IsSet() && stm &&
std::static_pointer_cast<IOS::HLE::Device::STMEventHook>(stm)->HasHookInstalled())
{
ProcessorInterface::PowerButton_Tap();
s_tried_graceful_shutdown.Set();
}
else
{
s_running.Clear();
}
}
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::State::Running)
{
if (SConfig::GetInstance().bHideCursor)
XUndefineCursor(dpy, win);
Core::SetState(Core::State::Paused);
}
else
{
if (SConfig::GetInstance().bHideCursor)
XDefineCursor(dpy, win, blankCursor);
Core::SetState(Core::State::Running);
}
}
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().bHideCursor && Core::GetState() != Core::State::Paused)
XDefineCursor(dpy, win, blankCursor);
break;
case FocusOut:
rendererHasFocus = false;
if (SConfig::GetInstance().bHideCursor)
XUndefineCursor(dpy, win);
break;
case ClientMessage:
if ((unsigned long)event.xclient.data.l[0] == XInternAtom(dpy, "WM_DELETE_WINDOW", False))
s_shutdown_requested.Set();
break;
case ConfigureNotify:
{
if (last_window_width != event.xconfigure.width ||
last_window_height != event.xconfigure.height)
{
last_window_width = event.xconfigure.width;
last_window_height = event.xconfigure.height;
// We call Renderer::ChangeSurface here to indicate the size has changed,
// but pass the same window handle. This is needed for the Vulkan backend,
// otherwise it cannot tell that the window has been resized on some drivers.
if (g_renderer)
g_renderer->ChangeSurface(s_window_handle);
}
}
break;
}
}
if (!fullscreen)
{
Window winDummy;
unsigned int borderDummy, depthDummy;
XGetGeometry(dpy, win, &winDummy, &SConfig::GetInstance().iRenderWindowXPos,
&SConfig::GetInstance().iRenderWindowYPos,
(unsigned int*)&SConfig::GetInstance().iRenderWindowWidth,
(unsigned int*)&SConfig::GetInstance().iRenderWindowHeight, &borderDummy,
&depthDummy);
rendererIsFullscreen = false;
}
Core::HostDispatchJobs();
usleep(100000);
}
}
int main() {
Engine = new LinuxEngine;
display = XOpenDisplay(NULL);
if (!display) {
LOG("Couldn't open display, terminating.");
delete Engine;
return 1;
}
root = DefaultRootWindow(display);
XVisualInfo *visualInfo = glXChooseVisual(display, 0, att);
if (!visualInfo) {
LOG("FATAL: Unable to acquire visual!");
delete Engine;
return 1;
}
cmap = XCreateColormap(display, root, visualInfo->visual, AllocNone);
swa.colormap = cmap;
swa.event_mask = ExposureMask | KeyPressMask;// | ResizeRedirectMask;
Window win = XCreateWindow(display, root, 0, 0, 1024, 600, 0, visualInfo->depth, InputOutput, visualInfo->visual, CWColormap | CWEventMask, &swa);
XMapWindow(display, win);
XStoreName(display, win, "tenn0");
GLXContext context = glXCreateContext(display, visualInfo, NULL, GL_TRUE);
glXMakeCurrent(display, win, context);
if (glewInit()) {
LOG("FATAL! glewInit failed!\n");
return 0;
}
if (!glewIsSupported("GL_VERSION_2_0")) {
LOG("FATAL! Needs OpenGL 2.0 or later!");
return 255;
}
//if (!glewIsSupported("GL_EXT_geometry_shader4")) {
// LOG("FATAL! Needs geometry shader support!");
// return 255;
//}
Engine->initRender();
Engine->setViewport(1024,768);
XEvent xev;
while (1) {
Engine->drawFrame();
glXSwapBuffers(display, win);
if (!XPending(display))
continue;
XNextEvent(display, &xev);
//XResizeRequestEvent *rev = reinterpret_cast<XResizeRequestEvent*>(&xev);
switch (xev.type) {
case Expose:
XGetWindowAttributes(display, win, &gwa);
Engine->setViewport(gwa.width, gwa.height);
Engine->drawFrame();
glXSwapBuffers(display, win);
break;
case KeyPress:
switch (XLookupKeysym(&xev.xkey, 0)) {
case XK_Escape:
case XK_space:
glXMakeCurrent(display, None, NULL);
glXDestroyContext(display, context);
XDestroyWindow(display, win);
XCloseDisplay(display);
delete Engine;
return(1);
case XK_F2:
Engine->toggleFrame();
break;
case XK_F3:
Engine->reloadShaders();
break;
default:
continue;
}
default:
break;
}
}
}
void mrutils::XWin::waitQuit() {
if (!init_) return;
XSelectInput(dis, win, MASK);
for (bool done = false;!done;) {
XEvent event; XNextEvent (dis, &event);
switch (event.type) {
case Expose:
mrutils::mutexAcquire(winMutex);
if (event.xexpose.window == win
&& saveImg != NULL
&& redrawNextExpose
) {
redrawNextExpose = false;
showImage_(*saveImg,false);
}
mrutils::mutexRelease(winMutex);
break;
case ButtonPress:
mrutils::mutexAcquire(winMutex);
if (event.xexpose.window == win
&& saveImg != NULL
) showImage_(*saveImg,false);
mrutils::mutexRelease(winMutex);
break;
case ResizeRequest:
mrutils::mutexAcquire(winMutex);
if (event.xresizerequest.window == win) {
if (imgResizes == 0) {
if (saveImg != NULL) {
if (event.xresizerequest.height < (int)height
|| event.xresizerequest.width < (int)width) {
height = event.xresizerequest.height;
width = event.xresizerequest.height;
showImage_(*saveImg,false);
}
}
} else --imgResizes;
}
mrutils::mutexRelease(winMutex);
break;
case UnmapNotify:
mrutils::mutexAcquire(winMutex);
if (event.xunmap.window == win) {
redrawNextExpose = true;
if (!init_) done = true;
}
mrutils::mutexRelease(winMutex);
break;
case KeyPress:
if (event.xkey.window == win) {
switch (int const key = XLookupKeysym (&event.xkey, 0)) {
case XK_semicolon:
this->exitKey = ';';
done = true;
break;
case XK_q:
this->exitKey = 'q';
done = true;
break;
case XK_Return:
this->exitKey = '\n';
done = true;
break;
case XK_s:
mrutils::mutexAcquire(winMutex);
if (saveImg != NULL) {
mrutils::stringstream ss;
ss << SAVE_PATH << saveImg->formatExtension[saveImg->format];
if (saveImg->saveOriginal(ss.str().c_str())) {
XStoreName(dis,win,ss.str().c_str());
}
}
mrutils::mutexRelease(winMutex);
break;
default:
break;
}
}
break;
default: break;
}
}
}
void run_app(Window forgein_window)
{
Display* dpy = XOpenDisplay(NULL);
Window window = XCreateSimpleWindow(dpy, DefaultRootWindow(dpy),
0, 0,
1024, 768,
0, // borderwidth
0, // border
0x000000); // background
XSelectInput(dpy, window,
KeyPressMask |
KeyReleaseMask |
ButtonPressMask |
ButtonReleaseMask |
StructureNotifyMask);
// FIXME: No idea why I have to do all this stuff, but it makes the
// XReparentWindow() work the first time, otherwise the program has
// to be started twice to make a successful capture
XUnmapWindow(dpy, forgein_window);
set_decorations(dpy, forgein_window, 0);
usleep(100000);
XReparentWindow(dpy, forgein_window, window, 0, 0);
XMapRaised(dpy, window);
XMapWindow(dpy, forgein_window);
bool quit = false;
while(!quit)
{
XEvent event;
XNextEvent (dpy, &event);
switch (event.type)
{
case ButtonPress:
std::cout << "ButtonPress" << std::endl;
break;
case ButtonRelease:
std::cout << "ButtonPress" << std::endl;
break;
case KeyPress:
std::cout << "KeyPress" << std::endl;
{
KeySym sym = XLookupKeysym(&event.xkey,0);
switch (sym)
{
case XK_Escape:
quit = true;
break;
default:
XSendEvent(dpy, forgein_window, True, KeyPressMask, &event);
break;
}
}
break;
case KeyRelease:
std::cout << "KeyRelease" << std::endl;
// doesn't work with Wine/Gargoyle?
XSendEvent(dpy, forgein_window, True, KeyReleaseMask, &event);
break;
case ConfigureNotify:
std::cout << "ConfigureNotify: "
<< event.xconfigure.width << "x" << event.xconfigure.height
<< "+" << event.xconfigure.x << "+" << event.xconfigure.y << std::endl;
{
XWindowAttributes attr;
XGetWindowAttributes(dpy, forgein_window, &attr);
std::cout << " -- " << attr.x << "+" << attr.y << " " << attr.width << "x" << attr.height << std::endl;
XResizeWindow(dpy, forgein_window, attr.width, event.xconfigure.height);
XGetWindowAttributes(dpy, forgein_window, &attr);
XMoveWindow(dpy, forgein_window,
event.xconfigure.width/2 - attr.width/2,
event.xconfigure.height/2 - attr.height/2);
std::cout << " -- " << attr.x << "+" << attr.y << " " << attr.width << "x" << attr.height << std::endl;
}
break;
default:
std::cout << "unhandled message type" << std::endl;
break;
}
}
// cleanup
XDestroyWindow(dpy, window);
XCloseDisplay(dpy);
}
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));
}
/*
* Defer the execution of a function to the next button press if the context is
* C_ROOT
*
* Inputs:
* cursor - the cursor to display while waiting
*/
static Bool DeferExecution(
exec_context_changes_t *ret_ecc, exec_context_change_mask_t *ret_mask,
cursor_t cursor, int trigger_evtype, int do_allow_unmanaged)
{
int done;
int finished = 0;
int just_waiting_for_finish = 0;
Window dummy;
Window original_w;
static XEvent e;
Window w;
int wcontext;
FvwmWindow *fw;
int FinishEvent;
fw = ret_ecc->w.fw;
w = ret_ecc->w.w;
original_w = w;
wcontext = ret_ecc->w.wcontext;
FinishEvent = ((fw != NULL) ? ButtonRelease : ButtonPress);
if (wcontext == C_UNMANAGED && do_allow_unmanaged)
{
return False;
}
if (wcontext != C_ROOT && wcontext != C_NO_CONTEXT && fw != NULL &&
wcontext != C_EWMH_DESKTOP)
{
if (FinishEvent == ButtonPress ||
(FinishEvent == ButtonRelease &&
trigger_evtype != ButtonPress))
{
return False;
}
else if (FinishEvent == ButtonRelease)
{
/* We are only waiting until the user releases the
* button. Do not change the cursor. */
cursor = CRS_NONE;
just_waiting_for_finish = 1;
}
}
if (Scr.flags.are_functions_silent)
{
return True;
}
if (!GrabEm(cursor, GRAB_NORMAL))
{
XBell(dpy, 0);
return True;
}
MyXGrabKeyboard(dpy);
while (!finished)
{
done = 0;
/* block until there is an event */
FMaskEvent(
dpy, ButtonPressMask | ButtonReleaseMask |
ExposureMask | KeyPressMask | VisibilityChangeMask |
ButtonMotionMask | PointerMotionMask
/* | EnterWindowMask | LeaveWindowMask*/, &e);
if (e.type == KeyPress)
{
KeySym keysym = XLookupKeysym(&e.xkey, 0);
if (keysym == XK_Escape)
{
ret_ecc->x.etrigger = &e;
*ret_mask |= ECC_ETRIGGER;
UngrabEm(GRAB_NORMAL);
MyXUngrabKeyboard(dpy);
return True;
}
Keyboard_shortcuts(&e, NULL, NULL, NULL, FinishEvent);
}
if (e.type == FinishEvent)
{
finished = 1;
}
switch (e.type)
{
case KeyPress:
case ButtonPress:
if (e.type != FinishEvent)
{
original_w = e.xany.window;
}
done = 1;
break;
case ButtonRelease:
done = 1;
break;
default:
break;
}
if (!done)
{
dispatch_event(&e);
}
}
MyXUngrabKeyboard(dpy);
UngrabEm(GRAB_NORMAL);
if (just_waiting_for_finish)
{
return False;
}
w = e.xany.window;
ret_ecc->x.etrigger = &e;
*ret_mask |= ECC_ETRIGGER | ECC_W | ECC_WCONTEXT;
if ((w == Scr.Root || w == Scr.NoFocusWin) &&
e.xbutton.subwindow != None)
{
w = e.xbutton.subwindow;
e.xany.window = w;
}
if (w == Scr.Root || IS_EWMH_DESKTOP(w))
{
ret_ecc->w.w = w;
ret_ecc->w.wcontext = C_ROOT;
XBell(dpy, 0);
return True;
}
*ret_mask |= ECC_FW;
if (XFindContext(dpy, w, FvwmContext, (caddr_t *)&fw) == XCNOENT)
{
ret_ecc->w.fw = NULL;
ret_ecc->w.w = w;
ret_ecc->w.wcontext = C_ROOT;
XBell(dpy, 0);
return (True);
}
if (w == FW_W_PARENT(fw))
{
w = FW_W(fw);
}
if (original_w == FW_W_PARENT(fw))
{
original_w = FW_W(fw);
}
/* this ugly mess attempts to ensure that the release and press
* are in the same window. */
if (w != original_w && original_w != Scr.Root &&
original_w != None && original_w != Scr.NoFocusWin &&
!IS_EWMH_DESKTOP(original_w))
{
if (w != FW_W_FRAME(fw) || original_w != FW_W(fw))
{
ret_ecc->w.fw = fw;
ret_ecc->w.w = w;
ret_ecc->w.wcontext = C_ROOT;
XBell(dpy, 0);
return True;
}
}
if (IS_EWMH_DESKTOP(FW_W(fw)))
{
ret_ecc->w.fw = fw;
ret_ecc->w.w = w;
ret_ecc->w.wcontext = C_ROOT;
XBell(dpy, 0);
return True;
}
wcontext = GetContext(NULL, fw, &e, &dummy);
ret_ecc->w.fw = fw;
ret_ecc->w.w = w;
ret_ecc->w.wcontext = C_ROOT;
return False;
}
int main(int argc, char **argv)
{
#ifdef BCMHOST
bcm_host_init();
#endif
Timing::getInstance();
//set stuff up
if (!setup()) {
std::cout << "Setup failed!" << std::endl;
return -1;
}
//wait for events
bool done = false;
while (!done) {
//render scene
interactive();
#ifdef USE_OPENGL_GLX
//retrieve display hande from window
DisplayHandle display = window->getDisplayHandle();
//handle the events in the queue
while (XPending(display) > 0) {
XEvent event;
XNextEvent(display, &event);
switch (event.type) {
case Expose:
if (event.xexpose.count != 0) {
break;
}
break;
case ConfigureNotify:
//call resizeGL only if our window-size changed
/*if ((event.xconfigure.width != GLWin.width) || (event.xconfigure.height != GLWin.height)) {
width = event.xconfigure.width;
height = event.xconfigure.height;
resizeGL(width, height);
}*/
break;
//exit in case of a mouse button press
case ButtonPress:
done = true;
break;
case KeyPress:
if (XLookupKeysym(&event.xkey, 0) == XK_Escape) {
done = true;
}
/*if (XLookupKeysym(&event.xkey,0) == XK_F11) {
destroyWindow();
fullscreen = !fullscreen;
createWindow();
}*/
break;
case ClientMessage:
if (strcmp(XGetAtomName(display, event.xclient.message_type), "WM_PROTOCOLS") == 0) {
done = true;
}
break;
default:
break;
}
}
#endif
//usleep(1000);
}
return 0;
}
void updateKeyboard()
{
XEvent xv;
KeySym key;
while(XPending(dp)) {
XNextEvent(dp, &xv);
switch(xv.type) {
case Expose:
case GraphicsExpose:
updateScreenClipped(
xv.xexpose.x,
xv.xexpose.y,
xv.xexpose.width,
xv.xexpose.height);
break;
case ButtonPress:
switch(xv.xbutton.button) {
case 1: Xmousebuttons |= 1;
break;
case 2: Xmousebuttons |= 4;
break;
case 3: Xmousebuttons |= 2;
break;
break;
case 4: Xmousebuttons |= 8;
break;
case 5: Xmousebuttons |= 16;
break;
}
break;
case ButtonRelease:
switch(xv.xbutton.button) {
case 1: Xmousebuttons &= ~1;
break;
case 2: Xmousebuttons &= ~4;
break;
case 3: Xmousebuttons &= ~2;
break;
break;
case 4: Xmousebuttons &= ~8;
break;
case 5: Xmousebuttons &= ~16;
break;
}
break;
case MotionNotify:
Xmousex = xv.xmotion.x;
Xmousey = xv.xmotion.y;
break;
case LeaveNotify :
Xmousebuttons = 0;
break;
case KeyPress:
key = XLookupKeysym(&xv.xkey, 0);
#ifdef __DEBUG__
printf("Down:%x\n", key);
#endif
#define d(x) keymap[ ( Xkeypressed = x ) ] = 1; \
if (keylinearind != -1) { \
if (keylinearind < 512) { \
keylinear[keylinearind++] = x;\
} \
}
switch(key) {
case XK_Escape: d(kbESC); break;
case XK_1: d(kb1); break;
case XK_2: d(kb2); break;
case XK_3: d(kb3); break;
case XK_4: d(kb4); break;
case XK_5: d(kb5); break;
case XK_6: d(kb6); break;
case XK_7: d(kb7); break;
case XK_8: d(kb8); break;
case XK_9: d(kb9); break;
case XK_0: d(kb0); break;
case XK_minus: d(kbMINUS); break;
case XK_BackSpace: d(kbBACKSPACE); break;
case XK_Tab: d(kbTAB); break;
case XK_a:
case XK_A: d(kbA); break;
case XK_b:
case XK_B: d(kbB); break;
case XK_c:
case XK_C: d(kbC); break;
case XK_d:
case XK_D: d(kbD); break;
case XK_e:
case XK_E: d(kbE); break;
case XK_f:
case XK_F: d(kbF); break;
case XK_g:
case XK_G: d(kbG); break;
case XK_h:
case XK_H: d(kbH); break;
case XK_i:
case XK_I: d(kbI); break;
case XK_j:
case XK_J: d(kbJ); break;
case XK_k:
case XK_K: d(kbK); break;
case XK_l:
case XK_L: d(kbL); break;
case XK_m:
case XK_M: d(kbM); break;
case XK_n:
case XK_N: d(kbN); break;
case XK_o:
case XK_O: d(kbO); break;
case XK_p:
case XK_P: d(kbP); break;
case XK_q:
case XK_Q: d(kbQ); break;
case XK_r:
case XK_R: d(kbR); break;
case XK_s:
case XK_S: d(kbS); break;
case XK_t:
case XK_T: d(kbT); break;
case XK_u:
case XK_U: d(kbU); break;
case XK_v:
case XK_V: d(kbV); break;
case XK_w:
case XK_W: d(kbW); break;
case XK_x:
case XK_X: d(kbX); break;
case XK_y:
case XK_Y: d(kbY); break;
case XK_z:
case XK_Z: d(kbZ); break;
case XK_bracketleft: d(kbSQUAREBRACKETOPEN); break;
case XK_bracketright: d(kbSQUAREBRACKETCLOSE); break;
case XK_Return: d(kbENTER); break;
case XK_Control_R:
case XK_Control_L: d(kbCTRL); break;
case XK_semicolon: d(kbSEMICOLON); break;
case XK_apostrophe: d(kbFORWARDAPOSTROPHE); break;
case XK_quoteleft: d(kbBACKWARDAPOSTROPHE); break;
case XK_Shift_L: d(kbLSHIFT); break;
case XK_backslash: d(kbBACKSLASH); break;
case XK_comma: d(kbCOMMA); break;
case XK_period: d(kbPOINT); break;
case XK_slash: d(kbFORWARDSLASH); break;
case XK_Shift_R: d(kbRSHIFT); break;
case XK_multiply: d(kbMUL); break;
case XK_Alt_L:
case XK_Alt_R: d(kbALT); break;
case XK_space: d(kbSPACE); break;
case XK_Caps_Lock: d(kbCAPS); break;
case XK_F1: d(kbF1); break;
case XK_F2: d(kbF2); break;
case XK_F3: d(kbF3); break;
case XK_F4: d(kbF4); break;
case XK_F5: d(kbF5); break;
case XK_F6: d(kbF6); break;
case XK_F7: d(kbF7); break;
case XK_F8: d(kbF8); break;
case XK_F9: d(kbF9); break;
case XK_F10: d(kbF10); break;
case XK_F11: d(kbF11); break;
case XK_F12: d(kbF12); break;
case XK_Num_Lock: d(kbNUM); break;
case XK_Scroll_Lock: d(kbSCROLL); break;
case XK_Home:
case XK_KP_Home: d(kbpHOME); break;
case XK_Up:
case XK_KP_Up: d(kbpUP); break;
case XK_Page_Up:
case XK_KP_Page_Up: d(kbpPGUP); break;
case XK_KP_Subtract: d(kbpMINUS); break;
case XK_Left:
case XK_KP_Left: d(kbpLEFT); break;
case XK_KP_5: d(kbpMIDDLE); break;
case XK_Right:
case XK_KP_Right: d(kbpRIGHT); break;
case XK_KP_Add: d(kbpPLUS); break;
case XK_End:
case XK_KP_End: d(kbpEND); break;
case XK_Down:
case XK_KP_Down: d(kbpDOWN); break;
case XK_Page_Down:
case XK_KP_Page_Down: d(kbpPGDN); break;
case XK_Insert:
case XK_KP_Insert: d(kbpINS); break;
case XK_Delete:
case XK_KP_Delete: d(kbpINS); break;
}
break;
case KeyRelease:
key = XLookupKeysym(&xv.xkey, 0);
#undef d
#define d(x) keymap[ ( Xkeyreleased = x ) ] = 0
switch(key) {
case XK_Escape: d(kbESC); break;
case XK_1: d(kb1); break;
case XK_2: d(kb2); break;
case XK_3: d(kb3); break;
case XK_4: d(kb4); break;
case XK_5: d(kb5); break;
case XK_6: d(kb6); break;
case XK_7: d(kb7); break;
case XK_8: d(kb8); break;
case XK_9: d(kb9); break;
case XK_0: d(kb0); break;
case XK_minus: d(kbMINUS); break;
case XK_BackSpace: d(kbBACKSPACE); break;
case XK_Tab: d(kbTAB); break;
case XK_a:
case XK_A: d(kbA); break;
case XK_b:
case XK_B: d(kbB); break;
case XK_c:
case XK_C: d(kbC); break;
case XK_d:
case XK_D: d(kbD); break;
case XK_e:
case XK_E: d(kbE); break;
case XK_f:
case XK_F: d(kbF); break;
case XK_g:
case XK_G: d(kbG); break;
case XK_h:
case XK_H: d(kbH); break;
case XK_i:
case XK_I: d(kbI); break;
case XK_j:
case XK_J: d(kbJ); break;
case XK_k:
case XK_K: d(kbK); break;
case XK_l:
case XK_L: d(kbL); break;
case XK_m:
case XK_M: d(kbM); break;
case XK_n:
case XK_N: d(kbN); break;
case XK_o:
case XK_O: d(kbO); break;
case XK_p:
case XK_P: d(kbP); break;
case XK_q:
case XK_Q: d(kbQ); break;
case XK_r:
case XK_R: d(kbR); break;
case XK_s:
case XK_S: d(kbS); break;
case XK_t:
case XK_T: d(kbT); break;
case XK_u:
case XK_U: d(kbU); break;
case XK_v:
case XK_V: d(kbV); break;
case XK_w:
case XK_W: d(kbW); break;
case XK_x:
case XK_X: d(kbX); break;
case XK_y:
case XK_Y: d(kbY); break;
case XK_z:
case XK_Z: d(kbZ); break;
case XK_bracketleft: d(kbSQUAREBRACKETOPEN); break;
case XK_bracketright: d(kbSQUAREBRACKETCLOSE); break;
case XK_Return: d(kbENTER); break;
case XK_Control_R:
case XK_Control_L: d(kbCTRL); break;
case XK_semicolon: d(kbSEMICOLON); break;
case XK_apostrophe: d(kbFORWARDAPOSTROPHE); break;
case XK_quoteleft: d(kbBACKWARDAPOSTROPHE); break;
case XK_Shift_L: d(kbLSHIFT); break;
case XK_backslash: d(kbBACKSLASH); break;
case XK_comma: d(kbCOMMA); break;
case XK_period: d(kbPOINT); break;
case XK_slash: d(kbFORWARDSLASH); break;
case XK_Shift_R: d(kbRSHIFT); break;
case XK_multiply: d(kbMUL); break;
case XK_Alt_L:
case XK_Alt_R: d(kbALT); break;
case XK_space: d(kbSPACE); break;
case XK_Caps_Lock: d(kbCAPS); break;
case XK_F1: d(kbF1); break;
case XK_F2: d(kbF2); break;
case XK_F3: d(kbF3); break;
case XK_F4: d(kbF4); break;
case XK_F5: d(kbF5); break;
case XK_F6: d(kbF6); break;
case XK_F7: d(kbF7); break;
case XK_F8: d(kbF8); break;
case XK_F9: d(kbF9); break;
case XK_F10: d(kbF10); break;
case XK_F11: d(kbF11); break;
case XK_F12: d(kbF12); break;
case XK_Num_Lock: d(kbNUM); break;
case XK_Scroll_Lock: d(kbSCROLL); break;
case XK_Home:
case XK_KP_Home: d(kbpHOME); break;
case XK_Up:
case XK_KP_Up: d(kbpUP); break;
case XK_Page_Up:
case XK_KP_Page_Up: d(kbpPGUP); break;
case XK_KP_Subtract: d(kbpMINUS); break;
case XK_Left:
case XK_KP_Left: d(kbpLEFT); break;
case XK_KP_5: d(kbpMIDDLE); break;
case XK_Right:
case XK_KP_Right: d(kbpRIGHT); break;
case XK_KP_Add: d(kbpPLUS); break;
case XK_End:
case XK_KP_End: d(kbpEND); break;
case XK_Down:
case XK_KP_Down: d(kbpDOWN); break;
case XK_Page_Down:
case XK_KP_Page_Down: d(kbpPGDN); break;
case XK_Insert:
case XK_KP_Insert: d(kbpINS); break;
case XK_Delete:
case XK_KP_Delete: d(kbpINS); break;
}
break;
}
}
}
int32_t run(int _argc, char** _argv)
{
XInitThreads();
m_display = XOpenDisplay(0);
int32_t screen = DefaultScreen(m_display);
int32_t depth = DefaultDepth(m_display, screen);
Visual* visual = DefaultVisual(m_display, screen);
Window root = RootWindow(m_display, screen);
XSetWindowAttributes windowAttrs;
memset(&windowAttrs, 0, sizeof(windowAttrs) );
windowAttrs.background_pixmap = 0;
windowAttrs.border_pixel = 0;
windowAttrs.event_mask = 0
| ButtonPressMask
| ButtonReleaseMask
| ExposureMask
| KeyPressMask
| KeyReleaseMask
| PointerMotionMask
| ResizeRedirectMask
| StructureNotifyMask
;
m_window = XCreateWindow(m_display
, root
, 0, 0
, ENTRY_DEFAULT_WIDTH, ENTRY_DEFAULT_HEIGHT, 0, depth
, InputOutput
, visual
, CWBorderPixel|CWEventMask
, &windowAttrs
);
const char *wmDeleteWindowName = "WM_DELETE_WINDOW";
Atom wmDeleteWindow;
XInternAtoms(m_display, (char **)&wmDeleteWindowName, 1, False, &wmDeleteWindow);
XSetWMProtocols(m_display, m_window, &wmDeleteWindow, 1);
XMapWindow(m_display, m_window);
XStoreName(m_display, m_window, "BGFX");
bgfx::x11SetDisplayWindow(m_display, m_window);
MainThreadEntry mte;
mte.m_argc = _argc;
mte.m_argv = _argv;
bx::Thread thread;
thread.init(mte.threadFunc, &mte);
while (!m_exit)
{
if (XPending(m_display) )
{
XEvent event;
XNextEvent(m_display, &event);
switch (event.type)
{
case Expose:
break;
case ConfigureNotify:
break;
case ClientMessage:
if((Atom)event.xclient.data.l[0] == wmDeleteWindow)
{
m_eventQueue.postExitEvent();
}
break;
case ButtonPress:
case ButtonRelease:
{
const XButtonEvent& xbutton = event.xbutton;
MouseButton::Enum mb;
switch (xbutton.button)
{
case Button1: mb = MouseButton::Left; break;
case Button2: mb = MouseButton::Middle; break;
case Button3: mb = MouseButton::Right; break;
default: mb = MouseButton::None; break;
}
if (MouseButton::None != mb)
{
m_eventQueue.postMouseEvent(xbutton.x
, xbutton.y
, mb
, event.type == ButtonPress
);
}
}
break;
case MotionNotify:
{
const XMotionEvent& xmotion = event.xmotion;
m_eventQueue.postMouseEvent(xmotion.x
, xmotion.y
);
}
break;
case KeyPress:
case KeyRelease:
{
XKeyEvent& xkey = event.xkey;
KeySym keysym = XLookupKeysym(&xkey, 0);
switch (keysym)
{
case XK_Meta_L: setModifier(Modifier::LeftMeta, KeyPress == event.type); break;
case XK_Meta_R: setModifier(Modifier::RightMeta, KeyPress == event.type); break;
case XK_Control_L: setModifier(Modifier::LeftCtrl, KeyPress == event.type); break;
case XK_Control_R: setModifier(Modifier::RightCtrl, KeyPress == event.type); break;
case XK_Shift_L: setModifier(Modifier::LeftShift, KeyPress == event.type); break;
case XK_Shift_R: setModifier(Modifier::RightShift, KeyPress == event.type); break;
case XK_Alt_L: setModifier(Modifier::LeftAlt, KeyPress == event.type); break;
case XK_Alt_R: setModifier(Modifier::RightAlt, KeyPress == event.type); break;
default:
{
Key::Enum key = fromXk(keysym);
if (Key::None != key)
{
m_eventQueue.postKeyEvent(key, m_modifiers, KeyPress == event.type);
}
}
break;
}
}
break;
case ResizeRequest:
{
const XResizeRequestEvent& xresize = event.xresizerequest;
XResizeWindow(m_display, m_window, xresize.width, xresize.height);
}
break;
}
}
}
thread.shutdown();
XUnmapWindow(m_display, m_window);
XDestroyWindow(m_display, m_window);
return EXIT_SUCCESS;
}
JNIEXPORT jlong JNICALL Java_org_lwjgl_opengl_LinuxKeyboard_lookupKeysym(JNIEnv *env, jclass unused, jlong event_ptr, jint index) {
XKeyEvent *event = (XKeyEvent *)(intptr_t)event_ptr;
return XLookupKeysym(event, index);
}
static void event_loop(Display *dpy, Window win)
{
while (1) {
while (XPending(dpy) > 0) {
XEvent event;
XNextEvent(dpy, &event);
switch (event.type) {
case Expose:
/* we'll redraw below */
break;
case ConfigureNotify:
reshape(event.xconfigure.width, event.xconfigure.height);
break;
case KeyPress:
{
char buffer[10];
int r, code;
code = XLookupKeysym(&event.xkey, 0);
if (code == XK_Left) {
view_roty += 5.0;
}
else if (code == XK_Right) {
view_roty -= 5.0;
}
else if (code == XK_Up) {
view_rotx += 5.0;
}
else if (code == XK_Down) {
view_rotx -= 5.0;
}
else {
r = XLookupString(&event.xkey, buffer, sizeof(buffer),
NULL, NULL);
if (buffer[0] == 27) {
/* escape */
return;
}
}
}
}
}
/* next frame */
angle += 2.0;
draw();
glXSwapBuffers(dpy, win);
/* calc framerate */
{
static int t0 = -1;
static int frames = 0;
int t = current_time();
if (t0 < 0)
t0 = t;
frames++;
if (t - t0 >= 5.0) {
GLfloat seconds = t - t0;
GLfloat fps = frames / seconds;
printf("%d frames in %3.1f seconds = %6.3f FPS\n", frames, seconds,
fps);
t0 = t;
frames = 0;
}
}
}
}
int main(int argc, char **argv)
{
opt_data opts; optproc(argc, argv, &opts);
if(audio_init(&opts) < 0) exit(1);
int x = 0, y = 0, w, h;
if(opts.w < 0 && opts.h < 0) opts.w = opts.h = 512;
else if(opts.w < 0) opts.w = opts.h;
else if(opts.h < 0) opts.h = opts.w;
w = opts.w; h = opts.h;
XEvent event;
dpy = XOpenDisplay( NULL );
if(dpy == NULL) {
printf("Error: couldn't open display %s\n", getenv("DISPLAY"));
exit(EXIT_FAILURE);
}
int glx_major, glx_minor;
if(!glXQueryVersion(dpy, &glx_major, &glx_minor)) {
printf("GLX extension missing!\n");
XCloseDisplay(dpy);
exit(EXIT_FAILURE);
}
printf("GLX version %i.%i\n", glx_major, glx_minor);
int glxErrBase, glxEventBase;
glXQueryExtension(dpy, &glxErrBase, &glxEventBase);
printf("GLX: errorBase = %i, eventBase = %i\n", glxErrBase, glxEventBase);
Window xwin, root;
int numReturned;
GLXFBConfig *fbConfigs;
fbConfigs = glXChooseFBConfig( dpy, DefaultScreen(dpy), fbattrib, &numReturned );
if(fbConfigs == NULL) { //TODO: handle this?
printf("No suitable fbconfigs!\n");
exit(EXIT_FAILURE);
}
XVisualInfo *vinfo = glXGetVisualFromFBConfig( dpy, fbConfigs[0] );
root = DefaultRootWindow(dpy);
/* window attributes */
XSetWindowAttributes attrs;
attrs.background_pixel = 0;
attrs.border_pixel = 0;
attrs.colormap = XCreateColormap(dpy, root, vinfo->visual, AllocNone);
//attrs.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask;
attrs.event_mask = StructureNotifyMask | KeyPressMask;
unsigned long mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
xwin = XCreateWindow(dpy, root, x, y, w, h,
0, vinfo->depth, InputOutput,
vinfo->visual, mask, &attrs);
XFree(vinfo);
// Set hints and properties:
{
XSizeHints sizehints;
sizehints.x = x;
sizehints.y = y;
sizehints.width = w;
sizehints.height = h;
sizehints.flags = USSize | USPosition;
XSetNormalHints(dpy, xwin, &sizehints);
XSetStandardProperties(dpy, xwin, "Julia-vis", "Julia-vis",
None, (char **)NULL, 0, &sizehints);
}
/* Create a GLX context for OpenGL rendering */
GLXContext context = glXCreateNewContext(dpy, fbConfigs[0], GLX_RGBA_TYPE, NULL, True );
#if 0
GLXContext context = 0;
glXCreateContextAttribsARBProc glXCreateContextAttribsARB = 0;
glXCreateContextAttribsARB = (glXCreateContextAttribsARBProc)glXGetProcAddressARB( (const GLubyte *) "glXCreateContextAttribsARB" );
if(strstr(glXQueryExtensionsString(dpy, 0), "GLX_ARB_create_context") || !glXCreateContextAttribsARB) {
printf("glXCreateContextAttribsARB() not found ... using old-style GLX context\n");
context = glXCreateNewContext(dpy, fbConfigs[0], GLX_RGBA_TYPE, 0, True);
} else {
const int context_attribs[] = {
GLX_RENDER_TYPE, GLX_RGBA_TYPE,
GLX_CONTEXT_MAJOR_VERSION_ARB, 2,
GLX_CONTEXT_MINOR_VERSION_ARB, 1,
None
};
context = glXCreateContextAttribsARB(dpy, fbConfigs[0], NULL, True, context_attribs);
}
if(context == NULL) {
printf("Failed to create context!\n");
return EXIT_FAILURE;
}
#endif
glxWin = glXCreateWindow(dpy, fbConfigs[0], xwin, NULL );
XMapWindow(dpy, xwin);
XIfEvent(dpy, &event, WaitForNotify, (XPointer) xwin);
glXMakeContextCurrent(dpy, glxWin, glxWin, context);
init_gl(&opts, w, h);
if(strstr(glXQueryExtensionsString(dpy, 0), "GLX_MESA_swap_control")) {
PFNGLXSWAPINTERVALMESAPROC swap_interval = glXGetProcAddressARB("glXSwapIntervalMESA");
swap_interval(1);
opts.draw_rate = 300;
}
if(strstr(glXQueryExtensionsString(dpy, 0), "GLX_INTEL_swap_event")) {
glXSelectEvent(dpy, glxWin, GLX_BUFFER_SWAP_COMPLETE_INTEL_MASK);
have_intel_swap_event = GL_TRUE;
}
int debug_maxsrc = 0, debug_pal = 0, show_mandel = 0, show_fps_hist = 0;
if(have_intel_swap_event)
render_frame(debug_maxsrc, debug_pal, show_mandel, show_fps_hist);
while(1) {
if(!have_intel_swap_event) render_frame(debug_maxsrc, debug_pal, show_mandel, show_fps_hist);
int clear_key = 1;
while (XPending(dpy) > 0)
{
XNextEvent(dpy, &event);
if(event.type == glxEventBase + GLX_BufferSwapComplete) {
render_frame(debug_maxsrc, debug_pal, show_mandel, show_fps_hist);
continue;
}
switch (event.type) {
case Expose:
/* we'll redraw below */
break;
/*case ConfigureNotify:
window_w = event.xconfigure.width;
window_h = event.xconfigure.height;
if (surface_type == EGL_WINDOW_BIT)
reshape(window_w, window_h);
break;*/
case KeyPress:
{
clear_key = 0;
char buffer[10];
int r, code;
code = XLookupKeysym(&event.xkey, 0);
if (code == XK_F1) {
debug_maxsrc = !debug_maxsrc;
} else if (code == XK_F2) {
debug_pal = !debug_pal;
} else if (code == XK_F3) {
show_mandel = !show_mandel;
} else if (code == XK_F4) {
show_fps_hist = !show_fps_hist;
} else {
code = XLookupKeysym(&event.xkey, 1);
if(code == XK_Escape) {
goto glx_main_loop_quit;
}
}
}
break;
default:
//printf("Bar %i!\n", event.type);
break;
}
}
}
glx_main_loop_quit:
audio_shutdown();
XDestroyWindow(dpy, xwin);
XCloseDisplay(dpy);
return 0;
}
void XWindow::handleEvent(XEvent& Event)
{
switch (Event.type)
{
case KeyPress:
//produceKeyPressed(determineKey(wParam),getKeyModifiers());
_LastKeyboardMouseButtonMask = Event.xkey.state;
produceKeyPressed(determineKey(XLookupKeysym(&(Event.xkey), 0)),determineKeyModifiers(Event.xkey.state));
break;
case KeyRelease:
//produceKeyReleased(determineKey(wParam),getKeyModifiers());
_LastKeyboardMouseButtonMask = Event.xkey.state;
produceKeyReleased(determineKey(XLookupKeysym(&(Event.xkey),0)),determineKeyModifiers(Event.xkey.state));
break;
case MotionNotify:
{
_LastKeyboardMouseButtonMask = Event.xmotion.state;
_LastMousePosition.setValues(Event.xbutton.x, Event.xbutton.y);
if(Event.xmotion.state & Button1MotionMask)
{
produceMouseDragged(MouseEventDetails::BUTTON1,Pnt2f(Event.xmotion.x, Event.xmotion.y), Vec2f(0.0f,0.0f));
}
if(Event.xmotion.state & Button2MotionMask)
{
produceMouseDragged(MouseEventDetails::BUTTON2,Pnt2f(Event.xmotion.x, Event.xmotion.y), Vec2f(0.0f,0.0f));
}
if(Event.xmotion.state & Button3MotionMask)
{
produceMouseDragged(MouseEventDetails::BUTTON3,Pnt2f(Event.xmotion.x, Event.xmotion.y), Vec2f(0.0f,0.0f));
}
if(Event.xmotion.state & Button4MotionMask)
{
produceMouseDragged(MouseEventDetails::BUTTON4,Pnt2f(Event.xmotion.x, Event.xmotion.y), Vec2f(0.0f,0.0f));
}
if(Event.xmotion.state & Button5MotionMask)
{
produceMouseDragged(MouseEventDetails::BUTTON5,Pnt2f(Event.xmotion.x, Event.xmotion.y), Vec2f(0.0f,0.0f));
}
produceMouseMoved(Pnt2f(Event.xmotion.x, Event.xmotion.y), Vec2f(0.0f,0.0f));
break;
}
case ButtonPress:
{
_LastKeyboardMouseButtonMask = Event.xbutton.state;
_LastMousePosition.setValues(Event.xbutton.x, Event.xbutton.y);
MouseEventDetails::MouseButton OSGButton(MouseEventDetails::NO_BUTTON);
switch(Event.xbutton.button)
{
case 1:
OSGButton = MouseEventDetails::BUTTON1;
break;
case 2:
OSGButton = MouseEventDetails::BUTTON2;
break;
case 3:
OSGButton = MouseEventDetails::BUTTON3;
break;
case 4:
produceMouseWheelMoved(1, Pnt2f(Event.xbutton.x, Event.xbutton.y));
break;
case 5:
produceMouseWheelMoved(-1, Pnt2f(Event.xbutton.x, Event.xbutton.y));
break;
case 6:
OSGButton = MouseEventDetails::BUTTON6;
break;
case 7:
OSGButton = MouseEventDetails::BUTTON7;
break;
case 8:
OSGButton = MouseEventDetails::BUTTON8;
break;
case 9:
OSGButton = MouseEventDetails::BUTTON9;
break;
case 10:
OSGButton = MouseEventDetails::BUTTON10;
break;
default:
OSGButton = MouseEventDetails::NO_BUTTON;
break;
}
if(OSGButton != MouseEventDetails::NO_BUTTON)
{
produceMousePressed(OSGButton, Pnt2f(Event.xbutton.x, Event.xbutton.y));
}
break;
}
case ButtonRelease:
{
_LastKeyboardMouseButtonMask = Event.xbutton.state;
_LastMousePosition.setValues(Event.xbutton.x, Event.xbutton.y);
MouseEventDetails::MouseButton OSGButton(MouseEventDetails::NO_BUTTON);
switch(Event.xbutton.button)
{
case 1:
OSGButton = MouseEventDetails::BUTTON1;
break;
case 2:
OSGButton = MouseEventDetails::BUTTON2;
break;
case 3:
OSGButton = MouseEventDetails::BUTTON3;
break;
case 6:
OSGButton = MouseEventDetails::BUTTON6;
break;
case 7:
OSGButton = MouseEventDetails::BUTTON7;
break;
case 8:
OSGButton = MouseEventDetails::BUTTON8;
break;
case 9:
OSGButton = MouseEventDetails::BUTTON9;
break;
case 10:
OSGButton = MouseEventDetails::BUTTON10;
break;
default:
break;
}
if(OSGButton != MouseEventDetails::NO_BUTTON)
{
produceMouseReleased(OSGButton, Pnt2f(Event.xbutton.x, Event.xbutton.y));
}
break;
}
case ConfigureNotify:
this->resize( Event.xconfigure.width,
Event.xconfigure.height );
internalReshape(Vec2f(Event.xconfigure.width, Event.xconfigure.height));
break;
case DestroyNotify:
produceWindowClosing();
produceWindowClosed();
break;
case EnterNotify:
produceWindowEntered();
break;
case LeaveNotify:
produceWindowExited();
break;
case UnmapNotify:
produceWindowIconified();
break;
case MapNotify:
produceWindowDeiconified();
break;
case FocusIn:
produceWindowActivated();
break;
case FocusOut:
produceWindowDeactivated();
break;
case Expose:
internalDraw();
break;
case ClientMessage:
{
Atom wm_delete_window=XInternAtom(this->getDisplay(), "WM_DELETE_WINDOW", False);
Atom wm_protocols=XInternAtom(this->getDisplay(), "WM_PROTOCOLS", False);
if (Event.xclient.message_type == wm_protocols &&
Event.xclient.data.l[0] == (long)wm_delete_window)
{
XDestroyWindow(this->getDisplay(),this->getWindow());
}
break;
}
default:
//std::cout << "Event Type: " << Event.type << std::endl;
break;
}
}
void
window_loop()
{
XSetWindowAttributes win_attrib;
unsigned long win_mask;
//XSizeHints win_hints;
XEvent event;
int running = 1;
win_attrib.border_pixel = BlackPixel(disp, screen);
win_attrib.background_pixel = BlackPixel(disp, screen);
win_attrib.override_redirect = 0;
win_mask = CWBackPixel | CWBorderPixel;
window = XCreateWindow(disp,
DefaultRootWindow(disp),
0, 0, gwidth, gheight,
0, depth,
InputOutput,
CopyFromParent,
win_mask,
&win_attrib);
xim = XCreateImage(disp, CopyFromParent, depth, ZPixmap, 0,
(char *)gbuf, gwidth, gheight, 32, gwidth * 4);
gc = XCreateGC(disp, window, 0, 0);
XMapWindow(disp, window);
XChangeProperty(disp, window, WM_PROTOCOLS, XA_ATOM, 32, 0,
(unsigned char *)&WM_DELETE_WINDOW, 1);
XSelectInput(disp, window, ExposureMask | StructureNotifyMask);
gactive = 1;
while (running) {
XNextEvent(disp, &event);
switch (event.type) {
case Expose:
XPutImage(disp, window, gc, xim,
0, 0, 0, 0,
gwidth, gheight);
XFlush(disp);
break;
case KeyPress:
if (XLookupKeysym(&event.xkey, 0)
== XK_Escape) {
running = 0;
}
break;
case DestroyNotify:
running = 0;
break;
case ClientMessage:
if ((Atom)(event.xclient.data.l[0])
== WM_DELETE_WINDOW) {
running = 0;
}
break;
}
}
XUnmapWindow(disp, window);
XFreeGC(disp, gc);
/* Note that XDestroyImage() frees image data set by XCreateImage(). */
XDestroyImage(xim);
XDestroyWindow(disp, window);
XCloseDisplay(disp);
}
static int process_event(XEvent* event) {
KeySym sym;
WindowInfo* info = find_handle(event->xany.window);
if (!info)
return 1;
if (event->type == ClientMessage) {
if ((Atom)event->xclient.data.l[0] == s_wm_delete_window) {
info->update = 0;
mfb_close(info);
return 0;
}
}
switch (event->type)
{
case KeyPress:
{
sym = XLookupKeysym(&event->xkey, 0);
if (info->key_callback)
info->key_callback(info->rust_data, sym, 1);
break;
}
case KeyRelease:
{
sym = XLookupKeysym(&event->xkey, 0);
if (info->key_callback)
info->key_callback(info->rust_data, sym, 0);
break;
}
case ButtonPress:
{
if (!info->shared_data)
break;
if (event->xbutton.button == Button1)
info->shared_data->state[0] = 1;
else if (event->xbutton.button == Button2)
info->shared_data->state[1] = 1;
else if (event->xbutton.button == Button3)
info->shared_data->state[2] = 1;
else if (event->xbutton.button == Button4)
info->shared_data->scroll_y = 10.0f;
else if (event->xbutton.button == Button5)
info->shared_data->scroll_y = -10.0f;
else if (event->xbutton.button == Button6)
info->shared_data->scroll_x = 10.0f;
else if (event->xbutton.button == Button7)
info->shared_data->scroll_y = -10.0f;
break;
}
case ButtonRelease:
{
if (!info->shared_data)
break;
if (event->xbutton.button == Button1)
info->shared_data->state[0] = 0;
else if (event->xbutton.button == Button2)
info->shared_data->state[1] = 0;
else if (event->xbutton.button == Button3)
info->shared_data->state[2] = 0;
break;
}
}
return 1;
}
int main(int argc, char *argv[])
{
pthread_t thread;
int screen_number;
int i;
XEvent event;
struct fp_img_dev *dev;
if (argc >= 2) {
strFilename = argv[1];
} else {
strFilename = strFilenameDefault;
}
/* Multi-thread app */
XInitThreads();
dis = XOpenDisplay(NULL);
if (NULL == dis) {
fprintf(stderr, "unable to open display\n");
return EXIT_FAILURE;
}
screen_number = DefaultScreen (dis);
//parent = RootWindow (dis, screen_number);
parent = DefaultRootWindow(dis);
fg = BlackPixel(dis, screen_number);
bg = WhitePixel(dis, screen_number);
mainwin = XCreateSimpleWindow(dis, parent, 0, 0, win_width, win_height, 0, fg, bg);
if (mainwin == None) {
fprintf (stderr, "unable to create window\n");
return EXIT_FAILURE;
}
gc = XCreateGC(dis, mainwin, 0, NULL);
if (gc == NULL) {
fprintf (stderr, "unable to allocate GC\n");
return EXIT_FAILURE;
}
// set up font
if ((font_info = XLoadQueryFont(dis, fontname)) == NULL) {
perror("XLoadQueryFont");
exit(1);
}
XSetFont(dis, gc, font_info->fid);
// Create Cursor for Buttons
mycursor = XCreateFontCursor(dis, XC_hand1);
// Quit Button
button_quit = XCreateSimpleWindow(dis, mainwin, 300, 10, BUTTON_WIDTH, BUTTON_HEIGHT, 1, fg, bg);
XChangeWindowAttributes(dis, button_quit, CWBackingStore, &setwinattr);
XSelectInput(dis, button_quit, BUTTON_MASK);
XDefineCursor(dis, button_quit, mycursor);
XMapWindow(dis, button_quit);
// Mode Buttons
for (i = 0 ; i < 3; i++) {
button_modes[i] = XCreateSimpleWindow(dis, mainwin, 300+i*65, 30, BUTTON_WIDTH, BUTTON_HEIGHT, 1, fg, bg);
XChangeWindowAttributes(dis, button_modes[i], CWBackingStore, &setwinattr);
XSelectInput(dis, button_modes[i], BUTTON_MASK);
XDefineCursor(dis, button_modes[i], mycursor);
XMapWindow(dis, button_modes[i]);
}
// Drawing area
draw_win = XCreateSimpleWindow(dis, mainwin, 0, 0, image_width, image_height, 1, fg, bg);
XSelectInput(dis, draw_win, BUTTON_MASK);
XMapWindow(dis, draw_win);
draw_gc = XCreateGC(dis, draw_win, 0, NULL);
if (draw_gc == NULL) {
fprintf (stderr, "unable to allocate Draw_win GC\n");
return EXIT_FAILURE;
}
// Create tuning buttons
int y = 60, id = 0;
MakeButton(300, y, "IncReg03", IncReg03, id);
MakeButton(400, y, "DecReg03", DecReg03, id+1);
y += 20; id += 2;
MakeButton(300, y, "IncReg04", IncReg04, id);
MakeButton(400, y, "DecReg04", DecReg04, id+1);
y += 20; id += 2;
MakeButton(300, y, "IncReg10", IncReg10, id);
MakeButton(400, y, "DecReg10", DecReg10, id+1);
y += 20; id += 2;
MakeButton(300, y, "IncReg1A", IncReg1A, id);
MakeButton(400, y, "DecReg1A", DecReg1A, id+1);
y += 20; id += 2;
MakeButton(300, y, "IncReg93", IncReg93, id);
MakeButton(400, y, "DecReg93", DecReg93, id+1);
y += 20; id += 2;
MakeButton(300, y, "IncReg94", IncReg94, id);
MakeButton(400, y, "DecReg94", DecReg94, id+1);
y += 20; id += 2;
MakeButton(300, y, "IncGain", IncGain, id);
MakeButton(400, y, "DecGain", DecGain, id+1);
y += 20; id += 2;
MakeButton(300, y, "IncVRT", IncVRT, id);
MakeButton(400, y, "DecVRT", DecVRT, id+1);
y += 20; id += 2;
MakeButton(300, y, "IncVRB", IncVRB, id);
MakeButton(400, y, "DecVRB", DecVRB, id+1);
y += 20; id += 2;
MakeButton(300, y, "IncDTVRT", IncDTVRT, id);
MakeButton(400, y, "DecDTVRT", DecDTVRT, id+1);
y += 20; id += 2;
MakeButton(300, y, "IncVCO_C", IncVCO_C, id);
MakeButton(400, y, "DecVCO_C", DecVCO_C, id+1);
y += 20; id += 2;
MakeButton(300, y, "IncDCOff", IncDCOffset, id);
MakeButton(400, y, "DecDCOff", DecDCOffset, id+1);
// XSelectInput (dis, mainwin, ExposureMask | KeyPressMask | ButtonPressMask);
XMapWindow(dis, mainwin);
XFlush(dis);
dev = global_init();
if (dev == NULL || dev->udev == NULL) {
fprintf(stderr, "Cannot open device\n");
}
/* create thread */
if (dev != NULL && dev->udev != NULL)
pthread_create(&thread, NULL, thread_entry, (void*)dev);
while (1)
{
if (XCheckWindowEvent(dis, button_quit, BUTTON_MASK, &event)) {
if (HandleQuitButton(&event))
goto finishing;
}
/* All modes buttons */
for (i = 0; i < 3; i++) {
if (XCheckWindowEvent(dis, button_modes[i], BUTTON_MASK, &event))
HandleModeButtons(&event, i);
}
/* All regs buttons */
for (i = 0; i < 128; i++) {
if (XCheckWindowEvent(dis, MenuButton[i].window, BUTTON_MASK, &event))
HandleRegButton(&event, i, dev);
}
/* TODO not BUTTON MASK but only? */
if (XCheckWindowEvent(dis, draw_win, BUTTON_MASK, &event))
HandleDraw(&event);
#if 0
XNextEvent (dis, &event);
switch (event.type)
{
case ButtonPress:
/* The man page for XButtonEvent documents this. */
printf ("You pressed button %d\n", event.xbutton.button);
modifyLive (dis, win, gc);
break;
case Expose:
//printf ("Redrawing from Expose.\n");
draw (dis, win, gc);
break;
case MapNotify:
printf ("MapNotify Event.\n");
break;
case KeyPress:
/* Close the program if q is pressed. */
printf ("KeyPress event %d key %d\n", event.type, ((XKeyEvent)event.xkey).keycode );
modifyLive (dis, win, gc);
#define REG_TUNE 0xE6
if (XK_o == XLookupKeysym (&event.xkey, 0)) {
unsigned char reg = 0;
dev_get_regs(dev->udev, 2, REG_TUNE, ®);
dev_set_regs(dev->udev, 2, REG_TUNE, ++reg);
printf("%02x: %02x\n", REG_TUNE, reg);
}
if (XK_l == XLookupKeysym (&event.xkey, 0)) {
int reg;
dev_get_regs(dev->udev, 2, REG_TUNE, ®);
dev_set_regs(dev->udev, 2, REG_TUNE, --reg);
printf("%02x: %02x\n", REG_TUNE, reg);
}
if (XK_q == XLookupKeysym (&event.xkey, 0))
goto finishing;
break;
default:
printf ("Unknown event %d\n", event.type);
break;
}
#endif
}
finishing:
stop = 1;
usleep(500*1000);
if (dev != NULL && dev->udev != NULL)
global_exit(dev);
/* For some reason the event loop stopped before q was pressed. */
return EXIT_FAILURE;
}
void RenderWindowLinux::Update( )
{
// Make sure that the window is open
if( m_Open == false )
{
return;
}
// Update the keyboard and mouse events
// m_pKeyboard->Update( );
//m_pMouse->Update( );
// Declare an x server event.
XEvent E;
// Declare our event
Bit::Event Event;
// Loop through all the events
while( XPending( m_pDisplay ) > 0 & m_Open )
{
// Get the next event
XNextEvent( m_pDisplay, &E );
switch( E.type )
{
case ClientMessage:
{
// This is ahacky way of checking if we closed the window
if( *XGetAtomName( m_pDisplay, E.xclient.message_type ) == *"WM_PROTOCOLS" )
{
Event.Type = Bit::Event::Closed;
m_Events.push( Event );
return;
}
}
break;
case ConfigureNotify: // Resized and moved event
{
// Resizing
if( E.xconfigure.width != m_Size.x || E.xconfigure.height != m_Size.y )
{
m_Size = Bit::Vector2u32( E.xconfigure.width, E.xconfigure.height );
m_Position = Bit::Vector2i32( E.xconfigure.x, E.xconfigure.y );
Event.Type = Bit::Event::Resized;
Event.Size = m_Size;
m_Events.push( Event );
}
// Moving
if( ( E.xconfigure.x != 0 || E.xconfigure.y != 0 ) &&
( E.xconfigure.x != m_Position.x || E.xconfigure.x != m_Position.y ) )
{
m_Position = Bit::Vector2i32( E.xconfigure.x, E.xconfigure.y );
Event.Type = Bit::Event::Moved;
Event.Position = m_Position;
m_Events.push( Event );
}
}
break;
case FocusIn:
{
Event.Type = Bit::Event::GainedFocus;
m_Events.push( Event );
}
break;
case FocusOut:
{
Event.Type = Bit::Event::LostFocus;
m_Events.push( Event );
}
break;
// The key and button events are a little special for x server.
// Let's just grab the just[pressed][released] events and elulate the
// KeyIsDown / ButtonIsDown events. Else, we'll get key register gaps that are
// depending on the keyboard speed. If that makes sense...
case KeyPress:
{
// Get the right key index
KeySym Keysym = XLookupKeysym( &E.xkey, 0 );
// not supporting more than 2^16 keys
if( Keysym < 65536 )
{
Keyboard::eKey Key = m_Keyboard.TranslateKeyToBitKey( static_cast< Uint16 >( Keysym ) );
if( Key != Keyboard::Unknown )
{
// Was the key just pressed? (KeyJustPressed event)
if( !m_Keyboard.GetPreviousKeyState( Key ) )
{
Event.Type = Bit::Event::KeyJustPressed;
Event.Key = Key;
m_Events.push( Event );
// Add the event to the input vector if it's not already in the list
Bool NotInList = true;
for( SizeType i = 0; i < m_PressedKeys.size( ); i++ )
{
if( Key == m_PressedKeys[ i ] )
{
NotInList = false;
break;
}
}
if( NotInList )
{
m_PressedKeys.push_back( Key );
}
}
// Set the keyboard state
m_Keyboard.SetCurrentKeyState( Key, true );
}
}
}
break;
case KeyRelease:
{
// Get the right key index
KeySym Keysym = XLookupKeysym( &E.xkey, 0 );
// not supporting more than 2^16 keys
if( Keysym < 65536 )
{
Keyboard::eKey Key = m_Keyboard.TranslateKeyToBitKey( static_cast< Uint16 >( Keysym ) );
if( Key != Keyboard::Unknown )
{
// Is the key really "just" released?
Bool JustReleased = true;
// Check if the key just was pressed(check for KeyPress event)
if( XEventsQueued( m_pDisplay, QueuedAfterReading ) )
{
XEvent NewEvent;
XPeekEvent( m_pDisplay, &NewEvent );
// Set the flag fales if the time for the two events are the same
if( NewEvent.type == KeyPress && NewEvent.xkey.time == E.xkey.time &&
NewEvent.xkey.keycode == E.xkey.keycode )
{
JustReleased = false;
}
}
// Yes, the key is just released.
if( JustReleased )
{
Event.Type = Bit::Event::KeyJustReleased;
Event.Key = Key;
m_Events.push( Event );
// Set the keyboard state
m_Keyboard.SetCurrentKeyState( Key, false );
// Remove the key from the input vector
for( SizeType i = 0; i < m_PressedKeys.size( ); i++ )
{
if( Key == m_PressedKeys[ i ] )
{
m_PressedKeys.erase( m_PressedKeys.begin( ) + i );
break;
}
}
}
}
}
}
break;
case MotionNotify:
{
Event.Type = Bit::Event::MouseMoved;
Event.MousePosition = Bit::Vector2i32( E.xmotion.x, E.xmotion.y );
m_Events.push( Event );
}
break;
case ButtonPress:
{
// not supporting more than 2^16 keys
if( E.xbutton.button <= Mouse::ButtonCount )
{
Mouse::eButton Button = m_Mouse.TranslateButtonToBitButton( static_cast< Uint16 >( E.xbutton.button ) );
if( Button != Mouse::Unknown )
{
// Was the button just pressed? (ButtonJustPressed event)
if( !m_Mouse.GetPreviousButtonState( Button ) )
{
Event.Type = Bit::Event::MouseJustPressed;
Event.Button = Button;
Event.MousePosition = Bit::Vector2i32( E.xbutton.x, E.xbutton.y );
m_Events.push( Event );
// Add the event to the input vector if it's not already in the list
Bool NotInList = true;
for( SizeType i = 0; i < m_PressedButtons.size( ); i++ )
{
if( Button == m_PressedButtons[ i ] )
{
NotInList = false;
break;
}
}
if( NotInList )
{
m_PressedButtons.push_back( Button );
}
}
// Set the mouse state
m_Mouse.SetCurrentButtonState( Button, true );
}
}
}
break;
case ButtonRelease:
{
// not supporting more than 2^16 keys
if( E.xbutton.button <= Mouse::ButtonCount )
{
Mouse::eButton Button = m_Mouse.TranslateButtonToBitButton( static_cast< Uint16 >( E.xbutton.button ) );
if( Button != Mouse::Unknown )
{
Event.Type = Bit::Event::MouseJustReleased;
Event.Button = Button;
Event.MousePosition = Bit::Vector2i32( E.xbutton.x, E.xbutton.y );
m_Events.push( Event );
// Set the mouse state
m_Mouse.SetCurrentButtonState( Button, false );
// Remove the key from the input vector
for( SizeType i = 0; i < m_PressedButtons.size( ); i++ )
{
if( Button == m_PressedButtons[ i ] )
{
m_PressedButtons.erase( m_PressedButtons.begin( ) + i );
break;
}
}
}
}
}
break;
default:
{
// ...
}
break;
}
}
// Add additional keyboard and mouse events.
// We need to fill up some event gaps.
// Add the event to the input vector if it's not already in the list
for( SizeType i = 0; i < m_PressedKeys.size( ); i++ )
{
Event.Type = Bit::Event::KeyPressed;
Event.Key = m_PressedKeys[ i ];
m_Events.push( Event );
}
for( SizeType i = 0; i < m_PressedButtons.size( ); i++ )
{
Event.Type = Bit::Event::MousePressed;
Event.Button = m_PressedButtons[ i ];
m_Events.push( Event );
}
}
int check_keys(XEvent *e, Game * game)
{
int key = XLookupKeysym(&e->xkey, 0);
killmovement = true;
if(e->type == KeyRelease)
{
keys[key] = 0;
if(key == XK_space)
killmovement = false;
if((!keys[XK_Right] || !keys[XK_Left]) && !keys[XK_space] && !game->inAir())
killmovement = true;
}
if(e->type == KeyPress)
{
keys[key] = 1;
if(STATE == HOW_TO)
{
if(key == XK_Return)
STATE = RUN_GAME;
}
if(STATE != DEATH) //this turns off keys except for ESC when you are dead
{
if(key == XK_k) // respawn
{
if(game->guts == true) //
{
game->setPos(window_width/2, window_height);
game->guts = false;
bloodToggle = false;
}
}
if(key == XK_p)
{
if(!pausegame)
pausegame = true;
else
pausegame = false;
}
if(STATE == RUN_GAME && !pausegame)
{
if(key != XK_Left || key != XK_Right)
killmovement = false;
if(key == XK_b)
{
if(bubbler)
bubbler = false;
else
bubbler = true;
}
if(key == XK_m) //Dated functionality now that missiles spawn automatically
{
//game->createMissiles();
}
}
if(key == XK_w)
{
if(setbackground)
setbackground = false;
else
setbackground = true;
}
}
else
{
if(key == XK_m)
{
//if(STATE != DEATH) //if you press M any time other than death screen, it will do nothing
//return 0;
//else
STATE = MAIN_MENU;
//pausegame = true;
}
}
if(key == XK_Escape) //lets you escape at any pointer
game->run = false;
}
return 0;
}
//
// main
//
int main(int argc, char **argv)
{
int i;
char buffer[80];
XEvent event;
KeySym key;
done = False;
// default to windowed mode
GLWin.fs = FULLSCREEN_MODE;
CreateGLWindow("glAnts", SCREEN_WIDTH, SCREEN_HEIGHT, 24, GLWin.fs);
/* wait for events*/
while (!done)
{
/* handle the events in the queue */
while (XPending(GLWin.dpy) > 0)
{
XNextEvent(GLWin.dpy, &event);
switch (event.type)
{
case Expose:
if (event.xexpose.count != 0)
break;
Run_Anim();
break;
case ConfigureNotify:
/* call resizeGLScene only if our window-size changed */
if ((event.xconfigure.width != GLWin.width) ||
(event.xconfigure.height != GLWin.height))
{
GLWin.width = event.xconfigure.width;
GLWin.height = event.xconfigure.height;
printf("Resize event\n");
ResizeGLScene(event.xconfigure.width,
event.xconfigure.height);
}
break;
case ButtonPress:
// exit on mouse press
// done = True;
break;
case KeyPress:
if (ant_globals->menu_mode == MENU_SETTINGS_MODE)
{
key = XLookupKeysym(&event.xkey, 0);
Cmd_KeyPress(key);
// handle fullscreen press differently
if (key == XK_F1)
break;
// process the key
Cmd_Keys(key);
XLookupString(&event, buffer, 10, &key, 0 ) ;
Alpha_Keys(buffer);
} else {
key = XLookupKeysym(&event.xkey, 0);
keyPressed(key);
keys[event.xkey.keycode] = true;
} // end of the if
break;
case KeyRelease:
if (ant_globals->menu_mode == MENU_SETTINGS_MODE) {
} else {
keys[event.xkey.keycode] = false;
} // end of the - if
break;
case ClientMessage:
if (*XGetAtomName(GLWin.dpy, event.xclient.message_type) ==
*"WM_PROTOCOLS")
{
printf("Exiting glants...\n");
done = True;
}
break;
default:
break;
}
}
// Check for key pressed in the camera
HandleCameraKeys(keys);
// run the gambit------
Run_Anim();
}
KillGLWindow();
return 0;
} // end of main //
void MFDisplay_HandleEventsX11()
{
MFCALLSTACK;
XEvent event;
while(XPending(xdisplay))
{
XNextEvent(xdisplay, &event);
switch(event.type)
{
case ClientMessage:
{
Atom atom;
if(event.xclient.format == 8)
{
atom = event.xclient.data.b[0];
}
else if(event.xclient.format == 16)
{
atom = event.xclient.data.s[0];
}
else if(event.xclient.format == 32)
{
atom = event.xclient.data.l[0];
}
else
{
atom = 0;
}
if(atom == wm_delete_window)
{
gQuit = 1;
}
break;
}
case KeyPress:
{
XKeyEvent *pEv = (XKeyEvent*)&event;
KeySym ks = XLookupKeysym(pEv, 0);
if(ks<=65535)
gXKeys[ks] = 1;
break;
}
case KeyRelease:
{
XKeyEvent *pEv = (XKeyEvent*)&event;
KeySym ks = XLookupKeysym(pEv, 0);
if(ks<=65535)
gXKeys[ks] = 0;
break;
}
case ButtonPress:
{
XButtonEvent *pEv = (XButtonEvent*)&event;
gXMouse.buttons[pEv->button] = 1;
if(pEv->button == 4)
gXMouse.wheel -= 1;
if(pEv->button == 5)
gXMouse.wheel += 1;
break;
}
case ButtonRelease:
{
XButtonEvent *pEv = (XButtonEvent*)&event;
gXMouse.buttons[pEv->button] = 0;
break;
}
case MotionNotify:
{
XMotionEvent *pEv = (XMotionEvent*)&event;
if(gXMouse.x == -1)
{
gXMouse.prevX = pEv->x;
gXMouse.prevY = pEv->y;
}
gXMouse.x = pEv->x;
gXMouse.y = pEv->y;
break;
}
default:
break;
}
}
}
virtual int main(int argc, char* argv[]) {
Scene scene;
Camera camera(Point3(640 / 2, 480 / 2, 0), Vector3(0, 0, 1));
Vector3 light = Vector3(320, 120, 0);
scene.lights.push_back(&light);
Sphere sphere = Sphere(Point3(50, 50, 50), 20);
sphere.color = Color(1.0, 0.2, 0.2);
scene.renderables.push_back(&sphere);
VertexArray vertex_array;
const struct aiScene* ai_scene = NULL;
const char* filename = "src/examples/models/spider.obj";
ai_scene = aiImportFile(filename, 0);
if (!ai_scene) {
printf("FAILED TO OPEN %s\n", filename);
return 1;
}
// const struct aiNode* ai_node = ai_scene->mRootNode;
for (int n = 0; n < ai_scene->mNumMeshes; n++){
const struct aiMesh* ai_mesh = ai_scene->mMeshes[n];
printf("NUM FACES: %i", ai_mesh->mNumFaces);
for (unsigned int t = 0; t < ai_mesh->mNumFaces; ++t) {
const struct aiFace* ai_face = &ai_mesh->mFaces[t];
for (unsigned int i = 0; i < ai_face->mNumIndices; ++i) {
int index = ai_face->mIndices[i];
// vertex_array.push_back(Point3(index*10, index*10, index*10));
vertex_array.push_back((Point3(
ai_mesh->mVertices[index].x+150,
ai_mesh->mVertices[index].z+150,
ai_mesh->mVertices[index].y+100
))*2);
}
}
}
TriangleList tri_list(vertex_array);
scene.renderables.push_back(&tri_list);
VertexArray vertex_array2;
vertex_array2.push_back(Point3(400, 100, 100));
vertex_array2.push_back(Point3(100, 400, 400));
vertex_array2.push_back(Point3(100, 100, 400));
vertex_array2.push_back(Point3(400, 100, 100));
vertex_array2.push_back(Point3(200, 550, 800));
vertex_array2.push_back(Point3(100, 400, 400));
TriangleList tri_soup(vertex_array2);
// scene.renderables.push_back(&tri_soup);
RaytraceRenderer rt_renderer;
X11ViewportWindow rt_viewport(640, 480, "Raytracer", display, 0, 0);
rt_viewport.show();
X11Renderer x11_renderer;
X11ViewportWindow x11_viewport(640, 480, "X11 Renderer", display, 0,
0);
x11_viewport.show();
GLUTRenderer glut_renderer;
GLXViewportWindow glx_viewport(640, 480, "GLUT Renderer", display, 0,
0);
glx_viewport.show();
real *x = NULL, *y = NULL;
XEvent event;
while (APP_STATE_RUNNING == state) {
XNextEvent(display, &event);
switch (event.type) {
case ButtonRelease:
x = y = NULL;
break;
case ButtonPress:
switch (event.xbutton.button) {
case 1:
x = &light.x;
y = &light.y;
break;
case 3:
break;
}
break;
case MotionNotify:
if (x && y && *x != event.xmotion.x) {
*x = event.xmotion.x;
*y = event.xmotion.y;
glut_renderer.render(glx_viewport, camera, scene);
glx_viewport.update();
}
// printf("MotionNotify: %d\n", event.xmotion.x);
break;
case KeyRelease:
switch (XLookupKeysym(&event.xkey, 0)) {
case XK_q:
case XK_Q:
case XK_Escape:
state = APP_STATE_STOPPING;
break;
case XK_1:
glut_renderer.render(glx_viewport, camera, scene);
glx_viewport.update();
break;
case XK_2:
x11_viewport.update();
x11_renderer.render(x11_viewport, camera, scene);
break;
case XK_3:
rt_renderer.render(rt_viewport, camera, scene);
rt_viewport.update();
break;
default:
// printf("Key event: %s\n", XKeysymToString(key_sym));
break;
}
break;
case ClientMessage:
printf("Unhandeled event: %s\n",
XGetAtomName(display, event.xclient.message_type));
break;
default:
// printf("Unhandeled event: %d\n", event.type);
break;
}
};
return state;
}
void MotifUI::DoContextualHelp()
{
Widget context_widget, shell;
#ifdef NO_CDE
XEvent event;
static Cursor cursor = (Cursor) NULL;
if (cursor == (Cursor) NULL)
cursor = XCreateFontCursor(display, XC_question_arrow);
#endif
BaseUI *window = this;
while (window->UIClass() != MAIN_WINDOW)
window = window->Parent();
shell = ((MotifUI *)window)->_w;
#ifdef NO_CDE
context_widget = XmTrackingEvent(shell, cursor, False, &event);
if (event.type == KeyPress || event.type == KeyRelease)
{
int offset;
KeySym keySym;
// Look for ESC key press and stop if we get one
if (event.xkey.state & ShiftMask)
offset = 1;
else
offset = 0;
keySym = XLookupKeysym((XKeyEvent *)&event, offset);
if (keySym == XK_Escape)
return;
}
if (context_widget != NULL)
{
#else
int returnVal = DtHelpReturnSelectedWidgetId(shell, NULL, &context_widget);
if (returnVal == DtHELP_SELECT_VALID)
{
#endif
XmAnyCallbackStruct cb;
cb.reason = XmCR_HELP;
#ifdef NO_CDE
cb.event = &event;
#endif
while (context_widget != NULL)
{
// If there is no help at this widget, back track to find help
if (XtHasCallbacks(context_widget, XmNhelpCallback) ==
XtCallbackHasSome)
{
XtCallCallbacks(context_widget, XmNhelpCallback, &cb);
break;
}
else
context_widget = XtParent(context_widget);
}
}
}
void MotifUI::WidgetHelpCB(Widget,
XtPointer clientData,
XtPointer)
{
MotifUI * obj = (MotifUI *) clientData;
obj->HandleHelpRequest();
}
int main( int argc, char *argv[] ) {
XEvent event;
GL_Window window;
Keys keys;
KeySym key;
struct timeval tv, tickCount;
window.keys = &keys;
window.init.title = "Lesson 48: NeHe & Terence J. Grant's ArcBall Rotation Tutorial";
window.init.width = 640;
window.init.height = 480;
window.init.depth = 32;
window.init.isFullScreen = true;
g_createFullScreen = window.init.isFullScreen;
if( CreateWindowGL (&window) == false ) {
exit(1);
}
initGL(&window, &keys);
while( !done ) {
while( XPending( window.init.dpy ) > 0 ) {
XNextEvent( window.init.dpy, &event );
switch( event.type ) {
case Expose:
if( event.xexpose.count != 0 )
break;
Draw();
break;
case ConfigureNotify:
if( (event.xconfigure.width != window.init.width) ||
(event.xconfigure.height != window.init.height) ) {
window.init.width = event.xconfigure.width;
window.init.height = event.xconfigure.height;
ReshapeGL( window.init.width, window.init.height );
}
break;
case ButtonPress:
switch( event.xbutton.button ) {
case 1: isClicked = true; break;
case 3: isRClicked = true; break;
}
break;
case ButtonRelease:
switch( event.xbutton.button ) {
case 1: isClicked = false; break;
case 3: isRClicked = false; break;
}
break;
case MotionNotify:
MousePt.s.X = event.xmotion.x;
MousePt.s.Y = event.xmotion.y;
break;
case KeyPress:
key = XLookupKeysym( &event.xkey, 0 );
if( key == XK_Escape )
done = true;
else if( key == XK_F1 ) {
DestroyWindowGL( &window );
window.init.isFullScreen = !window.init.isFullScreen;
CreateWindowGL( &window );
initGL(&window, &keys);
} else {
window.keys->keyDown[key] = true;
}
break;
case KeyRelease:
key = XLookupKeysym( &event.xkey, 0 );
window.keys->keyDown[key] = false;
break;
case ClientMessage:
if( *XGetAtomName( window.init.dpy, event.xclient.message_type)
== *"WM_PROTOCOLS" ) {
done = true;
}
default: break;
}
}
gettimeofday( &tv, NULL );
tickCount.tv_sec = tv.tv_sec - window.lastTickCount.tv_sec;
tickCount.tv_usec = tv.tv_usec - window.lastTickCount.tv_usec;
Update(tickCount.tv_usec / 1000 + tickCount.tv_sec * 1000 );
window.lastTickCount = tickCount;
Draw();
if( window.init.doubleBuffered )
glXSwapBuffers( window.init.dpy, window.init.win );
}
Deinitialize ();
DestroyWindowGL (&window);
}
static int XLateKey(XKeyEvent *ev, Uchar *ascii)
{
int key = 0;
//char buf[64];
KeySym keysym, shifted;
Status status;
keysym = XLookupKeysym (ev, 0);
DP_Xutf8LookupString(ev, ascii, &shifted, &status);
switch(keysym)
{
case XK_KP_Page_Up: key = K_KP_PGUP; break;
case XK_Page_Up: key = K_PGUP; break;
case XK_KP_Page_Down: key = K_KP_PGDN; break;
case XK_Page_Down: key = K_PGDN; break;
case XK_KP_Home: key = K_KP_HOME; break;
case XK_Home: key = K_HOME; break;
case XK_KP_End: key = K_KP_END; break;
case XK_End: key = K_END; break;
case XK_KP_Left: key = K_KP_LEFTARROW; break;
case XK_Left: key = K_LEFTARROW; break;
case XK_KP_Right: key = K_KP_RIGHTARROW; break;
case XK_Right: key = K_RIGHTARROW; break;
case XK_KP_Down: key = K_KP_DOWNARROW; break;
case XK_Down: key = K_DOWNARROW; break;
case XK_KP_Up: key = K_KP_UPARROW; break;
case XK_Up: key = K_UPARROW; break;
case XK_Escape: key = K_ESCAPE; break;
case XK_KP_Enter: key = K_KP_ENTER; break;
case XK_Return: key = K_ENTER; break;
case XK_Tab: key = K_TAB; break;
case XK_F1: key = K_F1; break;
case XK_F2: key = K_F2; break;
case XK_F3: key = K_F3; break;
case XK_F4: key = K_F4; break;
case XK_F5: key = K_F5; break;
case XK_F6: key = K_F6; break;
case XK_F7: key = K_F7; break;
case XK_F8: key = K_F8; break;
case XK_F9: key = K_F9; break;
case XK_F10: key = K_F10; break;
case XK_F11: key = K_F11; break;
case XK_F12: key = K_F12; break;
case XK_BackSpace: key = K_BACKSPACE; break;
case XK_KP_Delete: key = K_KP_DEL; break;
case XK_Delete: key = K_DEL; break;
case XK_Pause: key = K_PAUSE; break;
case XK_Shift_L:
case XK_Shift_R: key = K_SHIFT; break;
case XK_Execute:
case XK_Control_L:
case XK_Control_R: key = K_CTRL; break;
case XK_Alt_L:
case XK_Meta_L:
case XK_ISO_Level3_Shift:
case XK_Alt_R:
case XK_Meta_R: key = K_ALT; break;
case XK_KP_Begin: key = K_KP_5; break;
case XK_Insert:key = K_INS; break;
case XK_KP_Insert: key = K_KP_INS; break;
case XK_KP_Multiply: key = K_KP_MULTIPLY; break;
case XK_KP_Add: key = K_KP_PLUS; break;
case XK_KP_Subtract: key = K_KP_MINUS; break;
case XK_KP_Divide: key = K_KP_SLASH; break;
case XK_asciicircum: *ascii = key = '^'; break; // for some reason, XLookupString returns "" on this one for Grunt|2
case XK_section: *ascii = key = '~'; break;
default:
if (keysym < 32)
break;
if (keysym >= 'A' && keysym <= 'Z')
key = keysym - 'A' + 'a';
else
key = keysym;
break;
}
return key;
}
int main(int argc, char **argv)
{
XEvent event;
KeySym key;
done = False;
/* default to fullscreen */
GLWin.fs = True;
createGLWindow("NeHe's Rotation Tutorial", 1920, 1280, 24, GLWin.fs);
/* wait for events*/
while (!done)
{
/* handle the events in the queue */
while (XPending(GLWin.dpy) > 0)
{
XNextEvent(GLWin.dpy, &event);
switch (event.type)
{
case Expose:
if (event.xexpose.count != 0)
break;
drawGLScene();
break;
case ConfigureNotify:
/* call resizeGLScene only if our window-size changed */
if ((event.xconfigure.width != GLWin.width) ||
(event.xconfigure.height != GLWin.height))
{
GLWin.width = event.xconfigure.width;
GLWin.height = event.xconfigure.height;
printf("Resize event\n");
resizeGLScene(event.xconfigure.width,
event.xconfigure.height);
}
break;
/* exit in case of a mouse button press */
case ButtonPress:
done = True;
break;
case KeyPress:
key = XLookupKeysym(&event.xkey, 0);
keyPressed(key);
break;
case ClientMessage:
if (*XGetAtomName(GLWin.dpy, event.xclient.message_type) ==
*"WM_PROTOCOLS")
{
printf("Exiting sanely...\n");
done = True;
}
break;
default:
break;
}
}
drawGLScene();
}
killGLWindow();
return 0;
}
static void HGU_XmImageViewCanvasInputCb(
Widget w,
XtPointer client_data,
XtPointer call_data)
{
XmAnyCallbackStruct *cbs = (XmAnyCallbackStruct *) call_data;
int x, y;
/* switch on event type */
switch( cbs->event->type ) {
case ButtonPress:
switch( cbs->event->xbutton.button ) {
case Button1:
break;
case Button2:
break;
case Button3: /* unused */
default:
break;
}
break;
case ButtonRelease:
switch( cbs->event->xbutton.button ) {
case Button1:
break;
case Button2:
break;
default:
break;
}
break;
case MotionNotify: /* always display feedback on position and domain */
x = cbs->event->xmotion.x;
y = cbs->event->xmotion.y;
/*display_pointer_feedback_information(x, y);*/
break;
case KeyPress:
switch( XLookupKeysym(&(cbs->event->xkey), 0) ) {
case XK_Right:
case XK_f:
break;
case XK_Up:
case XK_p:
break;
case XK_Left:
case XK_b:
break;
case XK_Down:
case XK_n:
break;
case XK_w:
/* get a filename for the view image */
break;
}
break;
default:
break;
}
return;
}
int _ev_thread(int args, void* argp){
LibGE_LinuxContext* context = (LibGE_LinuxContext*)argp;
u32 ticks = geGetTick();
bool finished = false;
int key = 0;
if(wheel_j == -1){
while(wheel_i == -1);
wheel_j = 0;
}
while(1){
// mouse_warp_x = mouse_warp_y = 0;
while(XPending(context->dpy)){
XNextEvent(context->dpy, &event);
// if(event.type)printf("event: %d\n", event.type);
if((event.type == ButtonPress || event.type == ButtonRelease) && (event.xbutton.button == GEK_MWHEELUP || event.xbutton.button == GEK_MWHEELDOWN)){
memcpy(&wheel_ev[wheel_j], &event.xbutton, sizeof(XButtonEvent));
wheel_j = (wheel_j + 1) % 32;
}
switch (event.type){
case ClientMessage:
if (*XGetAtomName(context->dpy, event.xclient.message_type) == *"WM_PROTOCOLS"){
finished = true;
}
if (event.xclient.data.l[0] == XInternAtom(context->dpy, "WM_DELETE_WINDOW", False)){
finished = true;
}
break;
case ConfigureNotify:
new_w = event.xconfigure.width;
new_h = event.xconfigure.height;
break;
/*
case ConfigureNotify:
if(event.xexpose.width!=libge_context->width || event.xexpose.height!=libge_context->height){
libge_context->width = event.xconfigure.width;
libge_context->height = event.xconfigure.height;
libge_context->projection_matrix[0] = (float)0xFFFFFFFF;
geGraphicsInit();
geDrawingMode(libge_context->drawing_mode | 0xF0000000);
}
break;
*/
case KeymapNotify:
XRefreshKeyboardMapping(&event.xmapping);
break;
case KeyPress:
key = (int)XLookupKeysym(&event.xkey, 0);
if(key == XK_ISO_Level3_Shift){
key = XK_Alt_L;
}
if(key >= 0xFF00){
key -= 0xFF00;
}
if(key >= 'a' && key <= 'z'){
key += ('A' - 'a');
}
{
char str[25];
int len;
KeySym keysym;
len = XLookupString(&event.xkey, str, 25, &keysym, NULL);
last_pressed = (u8)str[0];
printf("key : %X %X\n", key, last_pressed);
}
keys_pressed[key] = true;
keys_released[key] = false;
if(keys_pressed[GEK_LALT] && keys_pressed[GEK_F4]){
finished = true;
}
break;
case KeyRelease:
key = (int)XLookupKeysym(&event.xkey, 0);
if(key >= 0xFF00){
key -= 0xFF00;
}
if(key <= 0xFF){
if(key >= 'a' && key <= 'z'){
key += ('A' - 'a');
}
keys_pressed[key] = false;
keys_released[key] = true;
}
break;
case ButtonPress:
if(event.xbutton.button == GEK_MWHEELUP){
wup = 1;
}else
if(event.xbutton.button == GEK_MWHEELDOWN){
wdown = 1;
}else{
keys_pressed[event.xbutton.button] = true;
keys_released[event.xbutton.button] = false;
}
break;
case ButtonRelease:
if(event.xbutton.button == GEK_MWHEELUP){
pending_wup_release = true;
}else
if(event.xbutton.button == GEK_MWHEELDOWN){
pending_wdown_release = true;
}else{
keys_pressed[event.xbutton.button] = false;
keys_released[event.xbutton.button] = true;
}
break;
case MotionNotify:
/*
if(changed){
changed = false;
continue;
}
if(libge_context->mouse_round){
if(reset){
warp_x = warp_y = 0;
reset = false;
}
warp_x += event.xmotion.x - libge_context->width / 2;
warp_y += event.xmotion.y - libge_context->height / 2;
libge_context->mouse_x = libge_context->width / 2;
libge_context->mouse_y = libge_context->height / 2;
changed = true;
XWarpPointer(context->dpy, context->win, context->win, 0, 0, 0, 0, libge_context->mouse_x, libge_context->mouse_y);
}else{
mouse_last_x = libge_context->mouse_x;
mouse_last_y = libge_context->mouse_y;
libge_context->mouse_x = event.xmotion.x;
libge_context->mouse_y = event.xmotion.y;
mouse_warp_x = libge_context->mouse_x-mouse_last_x;
mouse_warp_y = libge_context->mouse_y-mouse_last_y;
}
*/
break;
default:
break;
}
}
if(finished){
_to_close = true;
finished = false;
geSleep(1000);
exit(0);
}
ticks = geWaitTick(1000 / 120, ticks);
}
return 0;
}
void MainLoop() override
{
bool fullscreen = SConfig::GetInstance().m_LocalCoreStartupParameter.bFullscreen;
if (fullscreen)
{
rendererIsFullscreen = 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);
rendererIsFullscreen = false;
}
usleep(100000);
}
}
