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); } }