int main(int argc, char *argv[])
{
TERMKEY_CHECK_VERSION;
TermKey *tk = termkey_new(0, 0);
if(!tk) {
fprintf(stderr, "Cannot allocate termkey instance\n");
exit(1);
}
struct pollfd fd;
fd.fd = 0; /* the file descriptor we passed to termkey_new() */
fd.events = POLLIN;
TermKeyResult ret;
TermKeyKey key;
int running = 1;
int nextwait = -1;
while(running) {
if(poll(&fd, 1, nextwait) == 0) {
// Timed out
if(termkey_getkey_force(tk, &key) == TERMKEY_RES_KEY)
on_key(tk, &key);
}
if(fd.revents & (POLLIN|POLLHUP|POLLERR))
termkey_advisereadable(tk);
while((ret = termkey_getkey(tk, &key)) == TERMKEY_RES_KEY) {
on_key(tk, &key);
if(key.type == TERMKEY_TYPE_UNICODE &&
key.modifiers & TERMKEY_KEYMOD_CTRL &&
(key.code.codepoint == 'C' || key.code.codepoint == 'c'))
running = 0;
}
if(ret == TERMKEY_RES_AGAIN)
nextwait = termkey_get_waittime(tk);
else
nextwait = -1;
}
termkey_destroy(tk);
}
//! Check for pending events once
bool video::next_frame()
{
if(!running) return false;
//! try acquire mutex if threaded code, returns on failure
if(vidtype == 3 || threaded && pthread_mutex_trylock(&g_mutex))
return running;
//! Refresh screen picture
g_fps++;
#ifndef X_NOSHMPIX
if(vidtype == 2 && updating) XClearWindow(dpy, win);
#endif
while( XPending(dpy) ) {
XEvent report;
XNextEvent(dpy, &report);
switch( report.type ) {
case ClientMessage:
if(report.xclient.format != 32 || report.xclient.data.l[0] != _XA_WM_DELETE_WINDOW) break;
case DestroyNotify:
running = false;
case KeyPress:
on_key( XLookupKeysym(&report.xkey, 0) );
break;
case ButtonPress:
on_mouse( report.xbutton.x, report.xbutton.y, report.xbutton.button );
break;
case ButtonRelease:
on_mouse( report.xbutton.x, report.xbutton.y, -report.xbutton.button );
break;
}
}
struct timezone tz;
struct timeval now_time;
gettimeofday(&now_time, &tz);
double sec = (now_time.tv_sec+1.0*now_time.tv_usec/1000000.0) - (g_time.tv_sec+1.0*g_time.tv_usec/1000000.0);
if(sec > 1) {
memcpy(&g_time, &now_time, sizeof(g_time));
if(calc_fps) {
double fps = g_fps;
g_fps = 0;
char buffer[256];
snprintf(buffer, 256, "%s%s: %d fps", title, updating?"":" (no updating)", int(fps/sec));
XStoreName(dpy, win, buffer);
}
#ifndef X_FULLSYNC
XSync(dpy, false); // It is often better then using XSynchronize(dpy, true)
#endif//X_FULLSYNC
}
if(threaded) pthread_mutex_unlock(&g_mutex);
return true;
}
void platform_poll_events()
{
SDL_Event e;
while (SDL_PollEvent(&e)) {
switch (e.type) {
case SDL_KEYDOWN:
case SDL_KEYUP:
on_key(e.key);
break;
case SDL_MOUSEBUTTONDOWN:
case SDL_MOUSEBUTTONUP:
on_mouse(e.button);
break;
case SDL_QUIT:
has_closed = true;
break;
default:
break;
}
}
}
void sdl_app::on_event(SDL_Event& event){
switch(event.type){
case SDL_QUIT:
keep_running = false;
break;
case SDL_VIDEORESIZE:
my_window_size.x = event.resize.w;
my_window_size.y = event.resize.h;
my_window_ratio = float(my_window_size.x)/my_window_size.y;
for(app_ptr_list_iter it = my_apps.begin();
it != my_apps.end(); ++it){
(*it)->update_aspect(my_window_ratio);
}
init_GL(event.resize.w, event.resize.h);
break;
case SDL_KEYDOWN:
case SDL_KEYUP:
on_key(event.key);
break;
default:
break;
}
}
int main (int argc, char** argv) {
const char* default_port = "23";
struct sigaction sa;
int i;
/* process command line args */
for (i = 1; i < argc; ++i) {
/* help */
if (strcmp(argv[i], "-h") == 0) {
printf(
"CLC %s by Sean Middleditch <*****@*****.**>\n"
"This program has been released into the PUBLIC DOMAIN.\n\n"
"Usage:\n"
" clc [-h] <host> [<port>]\n\n"
"Options:\n"
" -h display help\n", CLC_VERSION
);
return 0;
}
/* other unknown option */
if (argv[i][0] == '-') {
fprintf(stderr, "Unknown option %s.\nUse -h to see available options.\n", argv[i]);
exit(1);
}
/* if host is unset, this is the host */
if (host == NULL) {
host = argv[i];
/* otherwise, it's a port */
} else {
port = argv[i];
}
}
/* ensure we have a host */
if (host == NULL) {
fprintf(stderr, "No host was given.\nUse -h to see command format.\n");
exit(1);
}
/* set default port if none was given */
if (port == NULL)
port = default_port;
/* cleanup on any failure */
atexit(cleanup);
/* set terminal defaults */
memset(&terminal, 0, sizeof(struct TERMINAL));
terminal.state = TERM_ASCII;
terminal.flags = TERM_FLAGS_DEFAULT;
terminal.color = TERM_COLOR_DEFAULT;
/* initial telnet handler */
telnet = telnet_init(telnet_telopts, telnet_event, 0, 0);
/* connect to server */
sock = do_connect(host, port);
if (sock == -1) {
fprintf(stderr, "Failed to connect to %s:%s\n", host, port);
exit(1);
}
printf("Connected to %s:%s\n", host, port);
/* set initial banner */
snprintf(banner, sizeof(banner), "CLC - %s:%s (connected)", host, port);
/* configure curses */
initscr();
start_color();
nonl();
cbreak();
noecho();
win_main = newwin(LINES-2, COLS, 0, 0);
win_banner = newwin(1, COLS, LINES-2, 0);
win_input = newwin(1, COLS, LINES-1, 0);
idlok(win_main, TRUE);
scrollok(win_main, TRUE);
nodelay(win_input, FALSE);
keypad(win_input, TRUE);
use_default_colors();
init_pair(COLOR_RED, COLOR_RED, -1);
init_pair(COLOR_BLUE, COLOR_BLUE, -1);
init_pair(COLOR_GREEN, COLOR_GREEN, -1);
init_pair(COLOR_CYAN, COLOR_CYAN, -1);
init_pair(COLOR_MAGENTA, COLOR_MAGENTA, -1);
init_pair(COLOR_YELLOW, COLOR_YELLOW, -1);
init_pair(COLOR_WHITE, COLOR_WHITE, -1);
init_pair(TERM_COLOR_DEFAULT, -1, -1);
wbkgd(win_main, COLOR_PAIR(TERM_COLOR_DEFAULT));
wclear(win_main);
init_pair(10, COLOR_WHITE, COLOR_BLUE);
wbkgd(win_banner, COLOR_PAIR(10));
wclear(win_banner);
init_pair(11, -1, -1);
wbkgd(win_input, COLOR_PAIR(11));
wclear(win_input);
redraw_display();
/* set signal handlers */
memset(&sa, 0, sizeof(sa));
sa.sa_handler = handle_signal;
sigaction(SIGINT, &sa, NULL);
sigaction(SIGWINCH, &sa, NULL);
/* initial edit buffer */
memset(&editbuf, 0, sizeof(struct EDITBUF));
/* setup poll info */
struct pollfd fds[2];
fds[0].fd = 1;
fds[0].events = POLLIN;
fds[1].fd = sock;
fds[1].events = POLLIN;
/* main loop */
while (running) {
/* poll sockets */
if (poll(fds, 2, -1) == -1) {
if (errno != EAGAIN && errno != EINTR) {
endwin();
fprintf(stderr, "poll() failed: %s\n", strerror(errno));
return 1;
}
}
/* resize event? */
if (have_sigwinch) {
have_sigwinch = 0;
redraw_display();
}
/* escape? */
if (have_sigint) {
exit(0);
}
/* input? */
if (fds[0].revents & POLLIN) {
int key = wgetch(win_input);
if (key != ERR)
on_key(key);
}
/* process input data */
if (fds[1].revents & POLLIN) {
char buffer[2048];
int ret = recv(sock, buffer, sizeof(buffer), 0);
if (ret == -1) {
if (errno != EAGAIN && errno != EINTR) {
endwin();
fprintf(stderr, "recv() failed: %s\n", strerror(errno));
return 1;
}
} else if (ret == 0) {
running = 0;
} else {
recv_bytes += ret;
telnet_recv(telnet, buffer, ret);
}
}
/* flush output */
paint_banner();
wnoutrefresh(win_main);
wnoutrefresh(win_banner);
wnoutrefresh(win_input);
doupdate();
}
/* final display, pause */
sock = -1;
autobanner = 1;
paint_banner();
wnoutrefresh(win_banner);
doupdate();
wgetch(win_input);
/* clean up */
endwin();
printf("Disconnected.\n");
/* free memory (so Valgrind leak detection is useful) */
telnet_free(telnet);
return 0;
}
//------------------------------------------------------------------------
int platform_support::run()
{
SDL_Event event;
bool ev_flag = false;
for(;;)
{
if(m_specific->m_update_flag)
{
on_draw();
update_window();
m_specific->m_update_flag = false;
}
ev_flag = false;
if(m_wait_mode)
{
SDL_WaitEvent(&event);
ev_flag = true;
}
else
{
if(SDL_PollEvent(&event))
{
ev_flag = true;
}
else
{
on_idle();
}
}
if(ev_flag)
{
if(event.type == SDL_QUIT)
{
break;
}
int y;
unsigned flags = 0;
switch (event.type)
{
case SDL_VIDEORESIZE:
if(!init(event.resize.w, event.resize.h, m_window_flags)) return false;
on_resize(m_rbuf_window.width(), m_rbuf_window.height());
trans_affine_resizing(event.resize.w, event.resize.h);
m_specific->m_update_flag = true;
break;
case SDL_KEYDOWN:
{
flags = 0;
if(event.key.keysym.mod & KMOD_SHIFT) flags |= kbd_shift;
if(event.key.keysym.mod & KMOD_CTRL) flags |= kbd_ctrl;
bool left = false;
bool up = false;
bool right = false;
bool down = false;
switch(event.key.keysym.sym)
{
case key_left:
left = true;
break;
case key_up:
up = true;
break;
case key_right:
right = true;
break;
case key_down:
down = true;
break;
}
if(m_ctrls.on_arrow_keys(left, right, down, up))
{
on_ctrl_change();
force_redraw();
}
else
{
on_key(m_specific->m_cur_x,
m_specific->m_cur_y,
event.key.keysym.sym,
flags);
}
}
break;
case SDL_MOUSEMOTION:
y = m_flip_y ?
m_rbuf_window.height() - event.motion.y :
event.motion.y;
m_specific->m_cur_x = event.motion.x;
m_specific->m_cur_y = y;
flags = 0;
if(event.motion.state & SDL_BUTTON(1)) flags |= mouse_left;
if(event.motion.state & SDL_BUTTON(3)) flags |= mouse_right;
if(m_ctrls.on_mouse_move(m_specific->m_cur_x,
m_specific->m_cur_y,
(flags & mouse_left) != 0))
{
on_ctrl_change();
force_redraw();
}
else
{
on_mouse_move(m_specific->m_cur_x,
m_specific->m_cur_y,
flags);
}
SDL_Event eventtrash;
while (SDL_PeepEvents(&eventtrash, 1, SDL_GETEVENT, SDL_EVENTMASK(SDL_MOUSEMOTION))!=0){;}
break;
case SDL_MOUSEBUTTONDOWN:
y = m_flip_y ?
m_rbuf_window.height() - event.motion.y :
event.motion.y;
m_specific->m_cur_x = event.motion.x;
m_specific->m_cur_y = y;
flags = 0;
if(event.button.button == SDL_BUTTON_LEFT) flags = mouse_left;
if(event.button.button == SDL_BUTTON_RIGHT) flags = mouse_right;
if(flags & mouse_left)
{
if(m_ctrls.on_mouse_button_down(m_specific->m_cur_x,
m_specific->m_cur_y))
{
m_ctrls.set_cur(m_specific->m_cur_x,
m_specific->m_cur_y);
on_ctrl_change();
force_redraw();
}
else
{
if(m_ctrls.in_rect(m_specific->m_cur_x,
m_specific->m_cur_y))
{
if(m_ctrls.set_cur(m_specific->m_cur_x,
m_specific->m_cur_y))
{
on_ctrl_change();
force_redraw();
}
}
else
{
on_mouse_button_down(m_specific->m_cur_x,
m_specific->m_cur_y,
flags);
}
}
}
if(flags & mouse_right)
{
on_mouse_button_down(m_specific->m_cur_x,
m_specific->m_cur_y,
flags);
}
break;
case SDL_MOUSEBUTTONUP:
y = m_flip_y ?
m_rbuf_window.height() - event.motion.y :
event.motion.y;
m_specific->m_cur_x = event.motion.x;
m_specific->m_cur_y = y;
flags = 0;
if(m_ctrls.on_mouse_button_up(m_specific->m_cur_x,
m_specific->m_cur_y))
{
on_ctrl_change();
force_redraw();
}
on_mouse_button_up(m_specific->m_cur_x,
m_specific->m_cur_y,
flags);
break;
}
}
}
return 0;
}
virtual BOOL handle_key(HELEMENT he, KEY_PARAMS ¶ms)
{
return on_key(he, params.target, params.cmd, params.key_code,
params.alt_state);
}
//------------------------------------------------------------------------
int platform_support::run()
{
SDL_Event event;
bool ev_flag = false;
for(;;)
{
if(m_specific->m_update_flag)
{
on_draw();
update_window();
m_specific->m_update_flag = false;
}
ev_flag = false;
if(m_wait_mode)
{
SDL_WaitEvent(&event);
ev_flag = true;
}
else
{
if(SDL_PollEvent(&event))
{
ev_flag = true;
}
else
{
on_idle();
}
}
if(ev_flag)
{
if(event.type == SDL_QUIT)
{
break;
}
int y;
unsigned flags = 0;
switch (event.type)
{
int event_x;
int event_y;
case SDL_WINDOWEVENT:
switch (event.window.event)
{
case SDL_WINDOWEVENT_RESIZED:
ERROR_PRINT("SDL_WINDOWEVENT_RESIZED %d,%d\n", event.window.data1, event.window.data2);
#ifndef __ANDROID__
if(!init(event.window.data1, event.window.data2, m_window_flags)) return false;
on_resize(m_rbuf_window.width(), m_rbuf_window.height());
trans_affine_resizing(event.window.data1, event.window.data2);
#endif
m_specific->m_update_flag = true;
break;
default:
DEBUG_PRINT("unknown win event type %d\n", event.window.event);
break;
}
break;
case SDL_APP_DIDENTERFOREGROUND:
DEBUG_PRINT("SDL_APP_DIDENTERFOREGROUND");
enter_foreground();
break;
case SDL_APP_WILLENTERFOREGROUND:
DEBUG_PRINT("SDL_APP_WILLENTERFOREGROUND");
break;
case SDL_APP_DIDENTERBACKGROUND:
DEBUG_PRINT("SDL_APP_DIDENTERBACKGROUND");
enter_background();
break;
case SDL_APP_WILLENTERBACKGROUND:
DEBUG_PRINT("SDL_APP_WILLENTERBACKGROUND");
break;
case SDL_KEYDOWN:
{
flags = 0;
if(event.key.keysym.mod & KMOD_SHIFT) flags |= kbd_shift;
if(event.key.keysym.mod & KMOD_CTRL) flags |= kbd_ctrl;
bool left = false;
bool up = false;
bool right = false;
bool down = false;
switch(event.key.keysym.sym)
{
case key_left:
left = true;
break;
case key_up:
up = true;
break;
case key_right:
right = true;
break;
case key_down:
down = true;
break;
}
if(m_ctrls.on_arrow_keys(left, right, down, up))
{
on_ctrl_change();
force_redraw();
}
else
{
on_key(m_specific->m_cur_x,
m_specific->m_cur_y,
event.key.keysym.sym,
flags);
}
}
break;
case SDL_MOUSEMOTION:
event_x = (double)event.button.x*width_factor;
event_y = (double)event.button.y*hight_factor;
y = m_flip_y ?
m_rbuf_window.height() - event_y :
event_y;
m_specific->m_cur_x = event_x;
m_specific->m_cur_y = y;
flags = 0;
if(event.motion.state & SDL_BUTTON_LMASK) flags |= mouse_left;
if(event.motion.state & SDL_BUTTON_RMASK) flags |= mouse_right;
if(m_ctrls.on_mouse_move(m_specific->m_cur_x,
m_specific->m_cur_y,
(flags & mouse_left) != 0))
{
on_ctrl_change();
force_redraw();
}
else
{
on_mouse_move(m_specific->m_cur_x,
m_specific->m_cur_y,
flags);
}
SDL_Event eventtrash;
while (SDL_PeepEvents(&eventtrash, 1, SDL_GETEVENT, SDL_MOUSEMOTION, SDL_MOUSEMOTION)!=0){;}
break;
case SDL_MOUSEBUTTONDOWN:
event_x = (double)event.button.x*width_factor;
event_y = (double)event.button.y*hight_factor;
DEBUG_PRINT("mouse down: %d,%d %d,%d\n", event.button.x,event.button.y,
event_x,event_y);
y = m_flip_y
? m_rbuf_window.height() - event_y
: event_y;
m_specific->m_cur_x = event_x;
m_specific->m_cur_y = y;
flags = 0;
DEBUG_PRINT("mouse down: %d,%d w %d,%d\n", event_x,y,
m_rbuf_window.width(), m_rbuf_window.height());
switch(event.button.button)
{
case SDL_BUTTON_LEFT:
{
flags = mouse_left;
if(m_ctrls.on_mouse_button_down(m_specific->m_cur_x,
m_specific->m_cur_y))
{
m_ctrls.set_cur(m_specific->m_cur_x,
m_specific->m_cur_y);
on_ctrl_change();
force_redraw();
}
else
{
if(m_ctrls.in_rect(m_specific->m_cur_x,
m_specific->m_cur_y))
{
if(m_ctrls.set_cur(m_specific->m_cur_x,
m_specific->m_cur_y))
{
on_ctrl_change();
force_redraw();
}
}
else
{
on_mouse_button_down(m_specific->m_cur_x,
m_specific->m_cur_y,
flags);
}
}
}
break;
case SDL_BUTTON_RIGHT:
DEBUG_PRINT("SDL_BUTTON_RIGHT");
flags = mouse_right;
on_mouse_button_down(m_specific->m_cur_x,
m_specific->m_cur_y,
flags);
break;
} //switch(event.button.button)
break;
case SDL_MOUSEBUTTONUP:
event_x = (double)event.button.x*width_factor;
event_y = (double)event.button.y*hight_factor;
y = m_flip_y
? m_rbuf_window.height() - event_y
: event_y;
m_specific->m_cur_x = event_x;
m_specific->m_cur_y = y;
flags = 0;
if(m_ctrls.on_mouse_button_up(m_specific->m_cur_x,
m_specific->m_cur_y))
{
on_ctrl_change();
force_redraw();
}
on_mouse_button_up(m_specific->m_cur_x,
m_specific->m_cur_y,
flags);
break;
case SDL_MOUSEWHEEL:
break;
case SDL_FINGERDOWN:
case SDL_FINGERUP:
case SDL_FINGERMOTION:
DEBUG_PRINT("Finger: x=%f, y=%f dx=%f, dy=%f, %d\n",
event.tfinger.x,
event.tfinger.y,
event.tfinger.dx,
event.tfinger.dy,
(int)event.tfinger.fingerId);
on_touch_event(
event.tfinger.x,
m_flip_y ? 1-event.tfinger.y: event.tfinger.y,
event.tfinger.dx,
event.tfinger.dy,
(int)event.tfinger.fingerId,
!(event.type == SDL_FINGERUP));
break;
case SDL_MULTIGESTURE:
DEBUG_PRINT("Multi Gesture: x = %f, y = %f, dAng = %f, dR = %f numDownTouch = %i\n",
event.mgesture.x,
event.mgesture.y,
event.mgesture.dTheta,
event.mgesture.dDist,
event.mgesture.numFingers);
on_multi_gesture(
event.mgesture.x,
event.mgesture.y,
event.mgesture.dTheta,
event.mgesture.dDist,
event.mgesture.numFingers);
break;
default:
DEBUG_PRINT("unknown event type %d\n", event.type);
break;
}
}
}
return 0;
}
