/** Background thread for X11 events handling */
static void *Thread (void *data)
{
vout_window_t *wnd = data;
vout_window_sys_t *p_sys = wnd->sys;
xcb_connection_t *conn = p_sys->conn;
int fd = xcb_get_file_descriptor (conn);
if (fd == -1)
return NULL;
for (;;)
{
xcb_generic_event_t *ev;
struct pollfd ufd = { .fd = fd, .events = POLLIN, };
poll (&ufd, 1, -1);
int canc = vlc_savecancel ();
while ((ev = xcb_poll_for_event (conn)) != NULL)
{
if (ProcessKeyEvent (p_sys->keys, ev) == 0)
continue;
msg_Dbg (wnd, "unhandled event: %"PRIu8, ev->response_type);
free (ev);
}
vlc_restorecancel (canc);
if (xcb_connection_has_error (conn))
{
msg_Err (wnd, "X server failure");
break;
}
}
return NULL;
}
/*!
\fn wcurses::Application::ProcessEvent(Event* E)
*/
void Application::ProcessEvent ( Event* E )
{
Event::EVT e;
// Debug;
switch ( E->Type() )
{
case event::KeyEvent:
e.K = E->toEventType<KeyPressEvent>();
keyPressCaptured_ ( e.K );
Dbg << "Key event";
ProcessKeyEvent ( e.K );
break;
case event::MouseEvent:
e.M = E->toEventType<MouseEvent>();
mouseCaptured_ ( e.M );
Dbg << "Mouse event...";
ProcessMouseEvent ( e.M );
break;
case event::MessageEvent:
e.G = E->toEventType<MessageEvent>();
messageListeners_ ( e.G );
Dbg << "Message...";
break;
}
DEND;
}
void ProcessEvent(SDL_Event* event)
// Process the given SDL event.
{
switch (event->type) {
default:
break;
case SDL_KEYDOWN:
case SDL_KEYUP:
{
SDL_KeyboardEvent* key = &event->key;
// key->keysym.scancode;
// key->type == SDL_KEYDOWN or SDL_KEYUP
// key->keysym.unicode == unicode char
// key->keysym.mod == modifiers
// key->keysym.sym == key symbol
ProcessKeyEvent(&(key->keysym), key->type == SDL_KEYDOWN);
if (key->type == SDL_KEYDOWN && key->keysym.unicode < 0x80 && key->keysym.unicode > 0) {
// ASCII-ish key. Pass it to the Input module.
Input::NotifyAlphaKeyClick(key->keysym.unicode);
}
break;
}
case SDL_MOUSEMOTION:
{
SDL_MouseMotionEvent* m = (SDL_MouseMotionEvent*) event;
int buttons = 0;
if (SDL_BUTTON_LMASK & m->state) buttons |= 1;
if (SDL_BUTTON_RMASK & m->state) buttons |= 2;
if (SDL_BUTTON_MMASK & m->state) buttons |= 4;
Input::NotifyMouseStatus(m->x, m->y, m->state);
break;
}
case SDL_MOUSEBUTTONDOWN:
case SDL_MOUSEBUTTONUP:
{
SDL_MouseButtonEvent* m = (SDL_MouseButtonEvent*) event;
int button = 0;
if (event->type == SDL_MOUSEBUTTONDOWN) {
if (m->button == SDL_BUTTON_LEFT) button = 1;
else if (m->button == SDL_BUTTON_RIGHT) button = 2;
else if (m->button == SDL_BUTTON_MIDDLE) button = 4;
}
Input::NotifyMouseStatus(m->x, m->y, button);
break;
}
case SDL_QUIT:
Main::SetQuit(true);
break;
}
}
bool TinselEngine::pollEvent() {
Common::Event event;
if (!g_system->getEventManager()->pollEvent(event))
return false;
// Handle the various kind of events
switch (event.type) {
case Common::EVENT_LBUTTONDOWN:
case Common::EVENT_LBUTTONUP:
case Common::EVENT_RBUTTONDOWN:
case Common::EVENT_RBUTTONUP:
case Common::EVENT_WHEELUP:
case Common::EVENT_WHEELDOWN:
// Add button to queue for the mouse process
_mouseButtons.push_back(event.type);
break;
case Common::EVENT_MOUSEMOVE:
{
// This fragment takes care of Tinsel 2 when it's been compiled with
// blank areas at the top and bottom of the screen
int ySkip = TinselV2 ? (g_system->getHeight() - _vm->screen().h) / 2 : 0;
if ((event.mouse.y >= ySkip) && (event.mouse.y < (g_system->getHeight() - ySkip)))
_mousePos = Common::Point(event.mouse.x, event.mouse.y - ySkip);
}
break;
case Common::EVENT_KEYDOWN:
case Common::EVENT_KEYUP:
ProcessKeyEvent(event);
break;
default:
break;
}
return true;
}
void SDLApplication::HandleEvent (SDL_Event* event) {
switch (event->type) {
case SDL_USEREVENT:
currentUpdate = SDL_GetTicks ();
updateEvent.deltaTime = currentUpdate - lastUpdate;
lastUpdate = currentUpdate;
while (nextUpdate <= currentUpdate) {
nextUpdate += framePeriod;
}
UpdateEvent::Dispatch (&updateEvent);
RenderEvent::Dispatch (&renderEvent);
break;
case SDL_APP_WILLENTERBACKGROUND:
windowEvent.type = WINDOW_DEACTIVATE;
WindowEvent::Dispatch (&windowEvent);
break;
case SDL_APP_WILLENTERFOREGROUND:
windowEvent.type = WINDOW_ACTIVATE;
WindowEvent::Dispatch (&windowEvent);
break;
case SDL_CONTROLLERAXISMOTION:
case SDL_CONTROLLERBUTTONDOWN:
case SDL_CONTROLLERBUTTONUP:
case SDL_CONTROLLERDEVICEADDED:
case SDL_CONTROLLERDEVICEREMOVED:
ProcessGamepadEvent (event);
break;
case SDL_FINGERMOTION:
case SDL_FINGERDOWN:
case SDL_FINGERUP:
ProcessTouchEvent (event);
break;
case SDL_JOYAXISMOTION:
case SDL_JOYBALLMOTION:
case SDL_JOYBUTTONDOWN:
case SDL_JOYBUTTONUP:
case SDL_JOYHATMOTION:
case SDL_JOYDEVICEADDED:
case SDL_JOYDEVICEREMOVED:
//joy
break;
case SDL_KEYDOWN:
case SDL_KEYUP:
ProcessKeyEvent (event);
break;
case SDL_MOUSEMOTION:
case SDL_MOUSEBUTTONDOWN:
case SDL_MOUSEBUTTONUP:
case SDL_MOUSEWHEEL:
ProcessMouseEvent (event);
break;
case SDL_TEXTINPUT:
case SDL_TEXTEDITING:
ProcessTextEvent (event);
break;
case SDL_WINDOWEVENT:
switch (event->window.event) {
case SDL_WINDOWEVENT_ENTER:
case SDL_WINDOWEVENT_LEAVE:
case SDL_WINDOWEVENT_SHOWN:
case SDL_WINDOWEVENT_HIDDEN:
case SDL_WINDOWEVENT_FOCUS_GAINED:
case SDL_WINDOWEVENT_FOCUS_LOST:
case SDL_WINDOWEVENT_MINIMIZED:
case SDL_WINDOWEVENT_MOVED:
case SDL_WINDOWEVENT_RESTORED:
ProcessWindowEvent (event);
break;
case SDL_WINDOWEVENT_EXPOSED:
RenderEvent::Dispatch (&renderEvent);
break;
case SDL_WINDOWEVENT_SIZE_CHANGED:
ProcessWindowEvent (event);
RenderEvent::Dispatch (&renderEvent);
break;
case SDL_WINDOWEVENT_CLOSE:
ProcessWindowEvent (event);
active = false;
break;
}
break;
case SDL_QUIT:
//quit
active = false;
break;
}
}
int main(int argc, char* argv[])
{
printf("START! pid = %d\n", getpid());
if (!system("./restart.rb"))
exit(1);
if (signal(SIGUSR1, RestartHandler) == SIG_ERR) {
fprintf(stderr, "An error occurred while setting a signal handler.\n");
exit(1);
}
bool fullscreen = true;
s_config = new AppConfig(fullscreen, false, 1280, 800);
SDL_Init(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK);
SDL_Window* displayWindow;
SDL_Renderer* displayRenderer;
uint32_t flags = SDL_WINDOW_OPENGL | (s_config->fullscreen ? SDL_WINDOW_FULLSCREEN_DESKTOP : 0);
int err = SDL_CreateWindowAndRenderer(s_config->width, s_config->height, flags, &displayWindow, &displayRenderer);
if (err == -1 || !displayWindow || !displayRenderer) {
fprintf(stderr, "SDL_CreateWindowAndRenderer failed!\n");
}
SDL_RendererInfo displayRendererInfo;
SDL_GetRendererInfo(displayRenderer, &displayRendererInfo);
/* TODO: Check that we have OpenGL */
if ((displayRendererInfo.flags & SDL_RENDERER_ACCELERATED) == 0 ||
(displayRendererInfo.flags & SDL_RENDERER_TARGETTEXTURE) == 0) {
/* TODO: Handle this. We have no render surface and not accelerated. */
fprintf(stderr, "NO RENDERER wtf!\n");
}
atexit(SDL_Quit);
JOYSTICK_Init();
AppConfig& config = *s_config;
config.title = "riftty";
//SDL_WM_SetCaption(config.title.c_str(), config.title.c_str());
//SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
/*
// clear
glClearColor(s_clearColor.x, s_clearColor.y, s_clearColor.z, s_clearColor.w);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
SDL_GL_SwapWindow(displayWindow);
*/
RiftSetup();
RenderInit();
win_init();
init_config();
struct passwd *pw = getpwuid(getuid());
const char *homedir = pw->pw_dir;
char config_filename[512];
strncpy(config_filename, homedir, 512);
strncat(config_filename, "/.riftty", 512);
load_config(config_filename);
cs_init(); // TODO: code pages do not want
// TODO: determine this based on window-size & font-size or vice versa.
cfg.rows = 25;
cfg.cols = 80;
// TODO: load config from /etc/riffty or ~/.rifttyrc
finish_config();
win_reconfig();
// TODO: get SHELL from env
cs_reconfig(); // TODO: do not want
term_init();
term_reset();
term_resize(cfg.rows, cfg.cols);
// TODO:
int font_width = 10;
int font_height = 10;
unsigned short term_width = font_width * cfg.cols;
unsigned short term_height = font_height * cfg.rows;
char login[128];
strncpy(login, getlogin(), 128);
const char* login_argv[] = {"login", "-pfl", login, NULL};
unsigned short rows = cfg.rows;
unsigned short cols = cfg.cols;
winsize ws = {rows, cols, term_width, term_height};
child_create(login_argv, &ws);
bool done = false;
while (!done)
{
JOYSTICK_ClearFlags();
SDL_Event event;
while (SDL_PollEvent(&event))
{
switch (event.type)
{
case SDL_QUIT:
done = true;
break;
case SDL_MOUSEMOTION:
if (event.motion.state & SDL_BUTTON(1)) {
// move touch
}
break;
case SDL_MOUSEBUTTONDOWN:
if (event.button.button == SDL_BUTTON_LEFT) {
// start touch
}
break;
case SDL_MOUSEBUTTONUP:
if (event.button.button == SDL_BUTTON_LEFT) {
// end touch
}
break;
case SDL_JOYAXISMOTION:
JOYSTICK_UpdateMotion(&event.jaxis);
break;
case SDL_JOYBUTTONDOWN:
case SDL_JOYBUTTONUP:
JOYSTICK_UpdateButton(&event.jbutton);
break;
case SDL_KEYDOWN:
case SDL_KEYUP:
if (ProcessKeyEvent(&event.key)) {
done = true;
}
break;
}
}
if (!done)
{
if (s_needsRestart)
Restart();
unsigned int now = SDL_GetTicks(); // milliseconds
float dt = (now - s_ticks) / 1000.0f; // convert to seconds.
s_ticks = now;
//printf("fps = %.0f\n", 1.0f/dt);
Process(dt);
Render(dt);
}
}
child_kill(true);
win_shutdown();
RiftShutdown();
JOYSTICK_Shutdown();
return 0;
}
/** Background thread for X11 events handling */
static void *Thread (void *data)
{
vout_window_t *wnd = data;
vout_window_sys_t *p_sys = wnd->sys;
xcb_connection_t *conn = p_sys->conn;
int fd = xcb_get_file_descriptor (conn);
if (fd == -1)
return NULL;
for (;;)
{
xcb_generic_event_t *ev;
struct pollfd ufd = { .fd = fd, .events = POLLIN, };
poll (&ufd, 1, -1);
int canc = vlc_savecancel ();
while ((ev = xcb_poll_for_event (conn)) != NULL)
{
if (ProcessKeyEvent (p_sys->keys, ev) == 0)
continue;
#ifdef MATCHBOX_HACK
if (p_sys->mb_current_app_window
&& (ev->response_type & 0x7f) == XCB_PROPERTY_NOTIFY)
{
const xcb_property_notify_event_t *pne =
(xcb_property_notify_event_t *)ev;
if (pne->atom == p_sys->mb_current_app_window
&& pne->state == XCB_PROPERTY_NEW_VALUE)
{
xcb_get_property_reply_t *r =
xcb_get_property_reply (conn,
xcb_get_property (conn, 0, pne->window, pne->atom,
XA_WINDOW, 0, 4), NULL);
if (r != NULL
&& !memcmp (xcb_get_property_value (r), &wnd->handle.xid,
4))
{
msg_Dbg (wnd, "asking Matchbox for input focus");
xcb_set_input_focus (conn,
XCB_INPUT_FOCUS_POINTER_ROOT,
wnd->handle.xid, pne->time);
xcb_flush (conn);
}
free (r);
}
}
else
#endif
msg_Dbg (wnd, "unhandled event: %"PRIu8, ev->response_type);
free (ev);
}
vlc_restorecancel (canc);
if (xcb_connection_has_error (conn))
{
msg_Err (wnd, "X server failure");
break;
}
}
return NULL;
}
void SDLApplication::HandleEvent (SDL_Event* event) {
switch (event->type) {
case SDL_USEREVENT:
currentUpdate = SDL_GetTicks ();
applicationEvent.type = UPDATE;
applicationEvent.deltaTime = currentUpdate - lastUpdate;
lastUpdate = currentUpdate;
nextUpdate += framePeriod;
while (nextUpdate <= currentUpdate) {
nextUpdate += framePeriod;
}
ApplicationEvent::Dispatch (&applicationEvent);
RenderEvent::Dispatch (&renderEvent);
break;
case SDL_APP_WILLENTERBACKGROUND:
windowEvent.type = WINDOW_DEACTIVATE;
WindowEvent::Dispatch (&windowEvent);
break;
case SDL_APP_WILLENTERFOREGROUND:
windowEvent.type = WINDOW_ACTIVATE;
WindowEvent::Dispatch (&windowEvent);
break;
case SDL_CONTROLLERAXISMOTION:
case SDL_CONTROLLERBUTTONDOWN:
case SDL_CONTROLLERBUTTONUP:
case SDL_CONTROLLERDEVICEADDED:
case SDL_CONTROLLERDEVICEREMOVED:
ProcessGamepadEvent (event);
break;
case SDL_DROPFILE:
ProcessDropEvent (event);
break;
case SDL_FINGERMOTION:
case SDL_FINGERDOWN:
case SDL_FINGERUP:
#ifndef HX_MACOS
ProcessTouchEvent (event);
#endif
break;
case SDL_JOYAXISMOTION:
if (SDLJoystick::IsAccelerometer (event->jaxis.which)) {
ProcessSensorEvent (event);
} else {
ProcessJoystickEvent (event);
}
break;
case SDL_JOYBALLMOTION:
case SDL_JOYBUTTONDOWN:
case SDL_JOYBUTTONUP:
case SDL_JOYHATMOTION:
case SDL_JOYDEVICEADDED:
case SDL_JOYDEVICEREMOVED:
ProcessJoystickEvent (event);
break;
case SDL_KEYDOWN:
case SDL_KEYUP:
ProcessKeyEvent (event);
break;
case SDL_MOUSEMOTION:
case SDL_MOUSEBUTTONDOWN:
case SDL_MOUSEBUTTONUP:
case SDL_MOUSEWHEEL:
ProcessMouseEvent (event);
break;
case SDL_TEXTINPUT:
case SDL_TEXTEDITING:
ProcessTextEvent (event);
break;
case SDL_WINDOWEVENT:
switch (event->window.event) {
case SDL_WINDOWEVENT_ENTER:
case SDL_WINDOWEVENT_LEAVE:
case SDL_WINDOWEVENT_SHOWN:
case SDL_WINDOWEVENT_HIDDEN:
case SDL_WINDOWEVENT_FOCUS_GAINED:
case SDL_WINDOWEVENT_FOCUS_LOST:
case SDL_WINDOWEVENT_MINIMIZED:
case SDL_WINDOWEVENT_MOVED:
case SDL_WINDOWEVENT_RESTORED:
ProcessWindowEvent (event);
break;
case SDL_WINDOWEVENT_EXPOSED:
RenderEvent::Dispatch (&renderEvent);
break;
case SDL_WINDOWEVENT_SIZE_CHANGED:
ProcessWindowEvent (event);
RenderEvent::Dispatch (&renderEvent);
break;
case SDL_WINDOWEVENT_CLOSE:
ProcessWindowEvent (event);
break;
}
break;
case SDL_QUIT:
active = false;
break;
}
}
/**
* Process to handle keypresses
*/
void KeyboardProcess(CORO_PARAM, const void *) {
// COROUTINE
CORO_BEGIN_CONTEXT;
CORO_END_CONTEXT(_ctx);
CORO_BEGIN_CODE(_ctx);
while (true) {
if (keypresses.empty()) {
// allow scheduling
CORO_SLEEP(1);
continue;
}
// Get the next keyboard event off the stack
Common::Event evt = *keypresses.begin();
keypresses.erase(keypresses.begin());
const Common::Point mousePos = _vm->getMousePosition();
// Switch for special keys
switch (evt.kbd.keycode) {
// Drag action
case Common::KEYCODE_LALT:
case Common::KEYCODE_RALT:
if (evt.type == Common::EVENT_KEYDOWN) {
if (!bSwapButtons)
ProcessButEvent(PLR_DRAG2_START);
else
ProcessButEvent(PLR_DRAG1_START);
} else {
if (!bSwapButtons)
ProcessButEvent(PLR_DRAG1_END);
else
ProcessButEvent(PLR_DRAG2_END);
}
continue;
case Common::KEYCODE_LCTRL:
case Common::KEYCODE_RCTRL:
if (evt.type == Common::EVENT_KEYDOWN) {
ProcessKeyEvent(PLR_LOOK);
} else {
// Control key release
}
continue;
default:
break;
}
// At this point only key down events need processing
if (evt.type == Common::EVENT_KEYUP)
continue;
if (_vm->_keyHandler != NULL)
// Keyboard is hooked, so pass it on to that handler first
if (!_vm->_keyHandler(evt.kbd))
continue;
switch (evt.kbd.keycode) {
/*** SPACE = WALKTO ***/
case Common::KEYCODE_SPACE:
ProcessKeyEvent(PLR_WALKTO);
continue;
/*** RETURN = ACTION ***/
case Common::KEYCODE_RETURN:
case Common::KEYCODE_KP_ENTER:
ProcessKeyEvent(PLR_ACTION);
continue;
/*** l = LOOK ***/
case Common::KEYCODE_l: // LOOK
ProcessKeyEvent(PLR_LOOK);
continue;
case Common::KEYCODE_ESCAPE:
ProcessKeyEvent(PLR_ESCAPE);
continue;
#ifdef SLOW_RINCE_DOWN
case '>':
AddInterlude(1);
continue;
case '<':
AddInterlude(-1);
continue;
#endif
case Common::KEYCODE_F1:
// Options dialog
ProcessKeyEvent(PLR_MENU);
continue;
case Common::KEYCODE_F5:
// Save game
ProcessKeyEvent(PLR_SAVE);
continue;
case Common::KEYCODE_F7:
// Load game
ProcessKeyEvent(PLR_LOAD);
continue;
case Common::KEYCODE_m:
// Debug facility - scene hopper
if (TinselV2 && (evt.kbd.flags == Common::KBD_ALT))
ProcessKeyEvent(PLR_JUMP);
break;
case Common::KEYCODE_q:
if ((evt.kbd.flags == Common::KBD_CTRL) || (evt.kbd.flags == Common::KBD_ALT))
ProcessKeyEvent(PLR_QUIT);
continue;
case Common::KEYCODE_PAGEUP:
case Common::KEYCODE_KP9:
ProcessKeyEvent(PLR_PGUP);
continue;
case Common::KEYCODE_PAGEDOWN:
case Common::KEYCODE_KP3:
ProcessKeyEvent(PLR_PGDN);
continue;
case Common::KEYCODE_HOME:
case Common::KEYCODE_KP7:
ProcessKeyEvent(PLR_HOME);
continue;
case Common::KEYCODE_END:
case Common::KEYCODE_KP1:
ProcessKeyEvent(PLR_END);
continue;
default:
ProcessKeyEvent(PLR_NOEVENT);
break;
}
}
CORO_END_CODE;
}
void SDLApplication::HandleEvent (SDL_Event* event) {
switch (event->type) {
case SDL_USEREVENT:
currentUpdate = SDL_GetTicks ();
updateEvent.deltaTime = currentUpdate - lastUpdate;
lastUpdate = currentUpdate;
while (nextUpdate <= currentUpdate) {
nextUpdate += framePeriod;
}
UpdateEvent::Dispatch (&updateEvent);
RenderEvent::Dispatch (&renderEvent);
break;
case SDL_JOYAXISMOTION:
case SDL_JOYBALLMOTION:
case SDL_JOYBUTTONDOWN:
case SDL_JOYBUTTONUP:
case SDL_JOYHATMOTION:
case SDL_JOYDEVICEADDED:
case SDL_JOYDEVICEREMOVED:
//joy
break;
case SDL_KEYDOWN:
case SDL_KEYUP:
ProcessKeyEvent (event);
break;
case SDL_MOUSEMOTION:
case SDL_MOUSEBUTTONDOWN:
case SDL_MOUSEBUTTONUP:
case SDL_MOUSEWHEEL:
ProcessMouseEvent (event);
break;
case SDL_WINDOWEVENT:
switch (event->window.event) {
case SDL_WINDOWEVENT_SHOWN:
case SDL_WINDOWEVENT_HIDDEN:
case SDL_WINDOWEVENT_FOCUS_GAINED:
case SDL_WINDOWEVENT_FOCUS_LOST:
case SDL_WINDOWEVENT_MOVED:
ProcessWindowEvent (event);
break;
case SDL_WINDOWEVENT_EXPOSED:
RenderEvent::Dispatch (&renderEvent);
break;
case SDL_WINDOWEVENT_SIZE_CHANGED:
ProcessWindowEvent (event);
RenderEvent::Dispatch (&renderEvent);
break;
case SDL_WINDOWEVENT_CLOSE:
ProcessWindowEvent (event);
active = false;
break;
}
break;
case SDL_QUIT:
//quit
active = false;
break;
}
}
