int init(){
//Initialize all subsystems
if( SDL_Init( SDL_INIT_EVERYTHING ) == -1 ){
return false;
}
//Set up the screen
set_window_size(SCREEN_WIDTH, SCREEN_HEIGHT);
//If there was an error setting up the screen
if(screen == NULL ){
return false;
}
//Set the window caption
SDL_WM_SetCaption( "CoSwarm 0.1", NULL );
//Initialize SDL_ttf
if( TTF_Init() == -1 )
{
MessageBox(NULL, "TTF library was not initialized correctly.", "Warning!", MB_OK);
return false;
}
//If everything initialized fine
return true;
}
int main(int argc, char *argv[]) {
// Check for command-line arguments
if(argc < 3) {
fprintf(stderr, "Usage: %s: [options] model weapon skin\n",
argv[0]);
exit(1);
}
// Intialize SDL
if(SDL_Init(SDL_INIT_VIDEO) < 0) {
fprintf(stderr, "Unable to initialize SDL\n");
exit(1);
}
// Set our quit function so that we clean up properly
atexit(SDL_Quit);
// Set our desired GL attributes. I'm not sure if this is necessary,
// and I'm not sure what happens if the desired attributes cannot be
// negotiated.
/*
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 5);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 6);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 5);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16);
*/
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
if(SDL_SetVideoMode(640, 480, 16, SDL_OPENGL) == NULL) {
fprintf(stderr, "Unable set set GL mode\n");
exit(1);
}
// Set the title of the Window, and use the default icon. We could
// specify an icon for the window, if we had one.
SDL_WM_SetCaption("Model Viewer", NULL);
// Initialize the viewer
init(argv[1], argv[2], argv[3]);
// Display the model for the first time
set_window_size(640, 480);
display();
// Go into the event loop. Unlike with GTK or GLUT, this function *will*
// return.
main_loop();
return 0;
}
// SDL doesn't use callbacks, so we must check the events ourselves
void main_loop() {
SDL_Event event;
SDL_Event prev_event;
int retval;
for(;;) {
// We can wait on an event (as we are doing here), or we can poll for
// events and, if there are no events waiting to be processed, we can
// call our idle function. This allows for a slightly more versatile
// event handler than with a callback-based approach, as with GLUT.
if(!SDL_WaitEvent(&event)) continue;
event_switch:
switch(event.type) {
case SDL_MOUSEBUTTONDOWN:
case SDL_MOUSEBUTTONUP:
mouse_button(event.button.button, event.button.state,
event.button.x, event.button.y);
break;
case SDL_MOUSEMOTION:
// This is a hack to keep the motion from being so jumpy on
// slow cards
do {
prev_event = event;
retval = SDL_PollEvent(&event);
} while(retval != 0 && event.type == SDL_MOUSEMOTION);
if(retval != 0) {
// SDL_PushEvent(&event);
// event = prev_event;
mouse_motion(prev_event.motion.state,
prev_event.motion.x, prev_event.motion.y);
goto event_switch;
}
mouse_motion(event.motion.state,
event.motion.x, event.motion.y);
break;
case SDL_KEYUP:
keyfunc(event.key.keysym.sym);
break;
case SDL_VIDEORESIZE:
set_window_size(event.resize.w, event.resize.h);
break;
case SDL_QUIT:
return;
}
}
}
/* Extract any control sequences that are ment only for run_erl
* and should not be forwarded to the pty.
*/
static int extract_ctrl_seq(char* buf, int len)
{
static const char prefix[] = "\033_";
static const char suffix[] = "\033\\";
char* bufend = buf + len;
char* start = buf;
char* command;
char* end;
for (;;) {
start = find_str(start, bufend-start, prefix);
if (!start) break;
command = start + strlen(prefix);
end = find_str(command, bufend-command, suffix);
if (end) {
unsigned col, row;
if (sscanf(command,"version=%u", &protocol_ver)==1) {
/*fprintf(stderr,"to_erl v%u\n", protocol_ver);*/
}
else if (sscanf(command,"winsize=%u,%u", &col, &row)==2) {
set_window_size(col,row);
}
else {
ERROR2(LOG_ERR, "Ignoring unknown ctrl command '%.*s'\n",
(int)(end-command), command);
}
/* Remove ctrl sequence from buf */
end += strlen(suffix);
memmove(start, end, bufend-end);
bufend -= end - start;
}
else {
ERROR2(LOG_ERR, "Missing suffix in ctrl sequence '%.*s'\n",
(int)(bufend-start), start);
break;
}
}
return bufend - buf;
}
/*!
\brief Updates mouse event.
\param[in] Value InputEventMouse containing the state of the mouse event.
\return Returns dmz::True if \a Value is different than the internal mosue event value.
\note The previous mouse event values are only updated if \a Value is different from
the current mouse event value.
*/
dmz::Boolean
dmz::InputEventMouse::update (const InputEventMouse &Value) {
Boolean result (False);
if (*this != Value) {
set_window_size (Value.get_window_size_x (), Value.get_window_size_y ());
set_mouse_position (Value.get_mouse_x (), Value.get_mouse_y ());
set_mouse_screen_position (
Value.get_mouse_screen_x (),
Value.get_mouse_screen_y ());
set_button_mask (Value.get_button_mask ());
set_scroll_delta (Value.get_scroll_delta_x (), Value.get_scroll_delta_y ());
result = True;
}
return result;
}
int
main(int argc, char **argv)
{
int ch, noinit, noset, quiet, Sflag, sflag, showterm;
const char *ttype;
int terasechar = -1; /* new erase character */
int intrchar = -1; /* new interrupt character */
int tkillchar = -1; /* new kill character */
int my_fd;
bool opt_c = FALSE; /* set control-chars */
bool opt_w = FALSE; /* set window-size */
TTY mode, oldmode;
my_fd = STDERR_FILENO;
obsolete(argv);
noinit = noset = quiet = Sflag = sflag = showterm = 0;
while ((ch = getopt(argc, argv, "a:cd:e:Ii:k:m:p:qQrSsVw")) != -1) {
switch (ch) {
case 'c': /* set control-chars */
opt_c = TRUE;
break;
case 'a': /* OBSOLETE: map identifier to type */
add_mapping("arpanet", optarg);
break;
case 'd': /* OBSOLETE: map identifier to type */
add_mapping("dialup", optarg);
break;
case 'e': /* erase character */
terasechar = arg_to_char();
break;
case 'I': /* no initialization strings */
noinit = 1;
break;
case 'i': /* interrupt character */
intrchar = arg_to_char();
break;
case 'k': /* kill character */
tkillchar = arg_to_char();
break;
case 'm': /* map identifier to type */
add_mapping(0, optarg);
break;
case 'p': /* OBSOLETE: map identifier to type */
add_mapping("plugboard", optarg);
break;
case 'Q': /* don't output control key settings */
quiet = 1;
break;
case 'q': /* display term only */
noset = 1;
break;
case 'r': /* display term on stderr */
showterm = 1;
break;
case 'S': /* OBSOLETE: output TERM & TERMCAP */
Sflag = 1;
break;
case 's': /* output TERM set command */
sflag = 1;
break;
case 'V': /* print curses-version */
puts(curses_version());
ExitProgram(EXIT_SUCCESS);
case 'w': /* set window-size */
opt_w = TRUE;
break;
case '?':
default:
usage();
}
}
_nc_progname = _nc_rootname(*argv);
argc -= optind;
argv += optind;
if (argc > 1)
usage();
if (!opt_c && !opt_w)
opt_c = opt_w = TRUE;
my_fd = save_tty_settings(&mode, TRUE);
oldmode = mode;
#ifdef TERMIOS
ospeed = (NCURSES_OSPEED) cfgetospeed(&mode);
#else
ospeed = (NCURSES_OSPEED) mode.sg_ospeed;
#endif
if (same_program(_nc_progname, PROG_RESET)) {
reset_start(stderr, TRUE, FALSE);
reset_tty_settings(my_fd, &mode);
} else {
reset_start(stderr, FALSE, TRUE);
}
ttype = get_termcap_entry(my_fd, *argv);
if (!noset) {
#if HAVE_SIZECHANGE
if (opt_w) {
set_window_size(my_fd, &lines, &columns);
}
#endif
if (opt_c) {
set_control_chars(&mode, terasechar, intrchar, tkillchar);
set_conversions(&mode);
if (!noinit) {
if (send_init_strings(my_fd, &oldmode)) {
(void) putc('\r', stderr);
(void) fflush(stderr);
(void) napms(1000); /* Settle the terminal. */
}
}
update_tty_settings(&oldmode, &mode);
}
}
if (noset) {
(void) printf("%s\n", ttype);
} else {
if (showterm)
(void) fprintf(stderr, "Terminal type is %s.\n", ttype);
/*
* If erase, kill and interrupt characters could have been
* modified and not -Q, display the changes.
*/
if (!quiet) {
print_tty_chars(&oldmode, &mode);
}
}
if (Sflag)
err("The -S option is not supported under terminfo.");
if (sflag) {
print_shell_commands(ttype);
}
ExitProgram(EXIT_SUCCESS);
}
int main(int argc, char *argv[]) {
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH |
GLUT_STENCIL);
if((argc > 1) && (strcmpi(argv[1], "--helmet") == 0)) {
/*left eye*/
glutInitWindowPosition(0,0);
glutInitWindowSize(640, 480);
left_eye = glutCreateWindow("Escher World - Left Eye");
glutSetWindow(left_eye);
set_window_size(640, 480);
glutDisplayFunc(displayleft);
glutKeyboardFunc(keyfunc);
glutMouseFunc(mouse_button);
glutPassiveMotionFunc(passive_mouse_motion);
glutMotionFunc(passive_mouse_motion);
glutReshapeFunc(set_window_size);
/* glutTimerFunc(10,child,1);*/
/* right eye */
glutInitWindowPosition(641,0);
glutInitWindowSize(640, 480);
right_eye = glutCreateWindow("Escher World - Right Eye");
glutSetWindow(right_eye);
set_window_size(640, 480);
glutDisplayFunc(displayright);
glutKeyboardFunc(keyfunc);
glutMouseFunc(mouse_button);
glutPassiveMotionFunc(passive_mouse_motion);
glutMotionFunc(passive_mouse_motion);
glutReshapeFunc(set_window_size);
glutSetWindow(left_eye);
create_menus();
init();
/* Initialize the scene */
init_scene(FILENAME);
glutSetWindow(right_eye);
create_menus();
create_menus();
init();
/* Initialize the scene */
init_scene(FILENAME);
#ifdef USE_HELMET
/* main_helmet();
signal(SIGUSR1, cleanup);
*/ birdinit();
/* glutTimerFunc(10,child,1);*/
#endif
} else {
glutInitWindowPosition(64,64);
glutInitWindowSize(768, 832);
glut_window = glutCreateWindow("Escher World");
glutSetWindow(glut_window);
set_window_size(768, 832);
helmet = !helmet;
glutDisplayFunc(displaymid);
glutKeyboardFunc(keyfunc);
glutMouseFunc(mouse_button);
glutPassiveMotionFunc(passive_mouse_motion);
glutMotionFunc(passive_mouse_motion);
glutReshapeFunc(set_window_size);
create_menus();
init();
/* Initialize the scene */
init_scene(FILENAME);
}
glutMainLoop();
return 0;
}
int tty_ioctl(struct inode * inode, struct file * file,
unsigned int cmd, unsigned long arg)
{
struct tty_struct * tty;
struct tty_struct * other_tty;
struct tty_struct * termios_tty;
pid_t pgrp;
int dev;
int termios_dev;
int retval;
if (MAJOR(file->f_rdev) != TTY_MAJOR) {
printk("tty_ioctl: tty pseudo-major != TTY_MAJOR\n");
return -EINVAL;
}
dev = MINOR(file->f_rdev);
tty = TTY_TABLE(dev);
if (!tty)
return -EINVAL;
if (IS_A_PTY(dev))
other_tty = tty_table[PTY_OTHER(dev)];
else
other_tty = NULL;
if (IS_A_PTY_MASTER(dev)) {
termios_tty = other_tty;
termios_dev = PTY_OTHER(dev);
} else {
termios_tty = tty;
termios_dev = dev;
}
switch (cmd) {
case TCGETS:
retval = verify_area(VERIFY_WRITE, (void *) arg,
sizeof (struct termios));
if (retval)
return retval;
memcpy_tofs((struct termios *) arg,
termios_tty->termios,
sizeof (struct termios));
return 0;
case TCSETSF:
case TCSETSW:
case TCSETS:
retval = check_change(termios_tty, termios_dev);
if (retval)
return retval;
if (cmd == TCSETSF || cmd == TCSETSW) {
if (cmd == TCSETSF)
flush_input(termios_tty);
wait_until_sent(termios_tty, 0);
}
return set_termios(termios_tty, (struct termios *) arg,
termios_dev);
case TCGETA:
return get_termio(termios_tty,(struct termio *) arg);
case TCSETAF:
case TCSETAW:
case TCSETA:
retval = check_change(termios_tty, termios_dev);
if (retval)
return retval;
if (cmd == TCSETAF || cmd == TCSETAW) {
if (cmd == TCSETAF)
flush_input(termios_tty);
wait_until_sent(termios_tty, 0);
}
return set_termio(termios_tty, (struct termio *) arg,
termios_dev);
case TCXONC:
retval = check_change(tty, dev);
if (retval)
return retval;
switch (arg) {
case TCOOFF:
stop_tty(tty);
break;
case TCOON:
start_tty(tty);
break;
case TCIOFF:
if (STOP_CHAR(tty) != __DISABLED_CHAR)
put_tty_queue(STOP_CHAR(tty),
&tty->write_q);
break;
case TCION:
if (START_CHAR(tty) != __DISABLED_CHAR)
put_tty_queue(START_CHAR(tty),
&tty->write_q);
break;
default:
return -EINVAL;
}
return 0;
case TCFLSH:
retval = check_change(tty, dev);
if (retval)
return retval;
switch (arg) {
case TCIFLUSH:
flush_input(tty);
break;
case TCIOFLUSH:
flush_input(tty);
/* fall through */
case TCOFLUSH:
flush_output(tty);
break;
default:
return -EINVAL;
}
return 0;
case TIOCEXCL:
set_bit(TTY_EXCLUSIVE, &tty->flags);
return 0;
case TIOCNXCL:
clear_bit(TTY_EXCLUSIVE, &tty->flags);
return 0;
case TIOCSCTTY:
if (current->leader &&
(current->session == tty->session))
return 0;
/*
* The process must be a session leader and
* not have a controlling tty already.
*/
if (!current->leader || (current->tty >= 0))
return -EPERM;
if (tty->session > 0) {
/*
* This tty is already the controlling
* tty for another session group!
*/
if ((arg == 1) && suser()) {
/*
* Steal it away
*/
struct task_struct *p;
for_each_task(p)
if (p->tty == dev)
p->tty = -1;
} else
return -EPERM;
}
current->tty = dev;
tty->session = current->session;
tty->pgrp = current->pgrp;
return 0;
case TIOCGPGRP:
retval = verify_area(VERIFY_WRITE, (void *) arg,
sizeof (pid_t));
if (retval)
return retval;
if (current->tty != termios_dev)
return -ENOTTY;
put_fs_long(termios_tty->pgrp, (pid_t *) arg);
return 0;
case TIOCSPGRP:
retval = check_change(termios_tty, termios_dev);
if (retval)
return retval;
if ((current->tty < 0) ||
(current->tty != termios_dev) ||
(termios_tty->session != current->session))
return -ENOTTY;
pgrp = get_fs_long((pid_t *) arg);
if (pgrp < 0)
return -EINVAL;
if (session_of_pgrp(pgrp) != current->session)
return -EPERM;
termios_tty->pgrp = pgrp;
return 0;
case TIOCOUTQ:
retval = verify_area(VERIFY_WRITE, (void *) arg,
sizeof (unsigned long));
if (retval)
return retval;
put_fs_long(CHARS(&tty->write_q),
(unsigned long *) arg);
return 0;
case TIOCINQ:
retval = verify_area(VERIFY_WRITE, (void *) arg,
sizeof (unsigned long));
if (retval)
return retval;
if (L_ICANON(tty))
put_fs_long(inq_canon(tty),
(unsigned long *) arg);
else
put_fs_long(CHARS(&tty->secondary),
(unsigned long *) arg);
return 0;
case TIOCSTI:
if ((current->tty != dev) && !suser())
return -EPERM;
retval = verify_area(VERIFY_READ, (void *) arg, 1);
if (retval)
return retval;
put_tty_queue(get_fs_byte((char *) arg), &tty->read_q);
TTY_READ_FLUSH(tty);
return 0;
case TIOCGWINSZ:
retval = verify_area(VERIFY_WRITE, (void *) arg,
sizeof (struct winsize));
if (retval)
return retval;
memcpy_tofs((struct winsize *) arg, &tty->winsize,
sizeof (struct winsize));
return 0;
case TIOCSWINSZ:
if (IS_A_PTY_MASTER(dev))
set_window_size(other_tty,(struct winsize *) arg);
return set_window_size(tty,(struct winsize *) arg);
case TIOCLINUX:
switch (get_fs_byte((char *)arg))
{
case 0:
return do_screendump(arg);
case 1:
return do_get_ps_info(arg);
#ifdef CONFIG_SELECTION
case 2:
return set_selection(arg);
case 3:
return paste_selection(tty);
case 4:
unblank_screen();
return 0;
#endif /* CONFIG_SELECTION */
default:
return -EINVAL;
}
case TIOCCONS:
if (IS_A_CONSOLE(dev)) {
if (!suser())
return -EPERM;
redirect = NULL;
return 0;
}
if (redirect)
return -EBUSY;
if (!suser())
return -EPERM;
if (IS_A_PTY_MASTER(dev))
redirect = other_tty;
else if (IS_A_PTY_SLAVE(dev))
redirect = tty;
else
return -ENOTTY;
return 0;
case FIONBIO:
arg = get_fs_long((unsigned long *) arg);
if (arg)
file->f_flags |= O_NONBLOCK;
else
file->f_flags &= ~O_NONBLOCK;
return 0;
case TIOCNOTTY:
if (current->tty != dev)
return -ENOTTY;
if (current->leader)
disassociate_ctty(0);
current->tty = -1;
return 0;
case TIOCGETD:
retval = verify_area(VERIFY_WRITE, (void *) arg,
sizeof (unsigned long));
if (retval)
return retval;
put_fs_long(tty->disc, (unsigned long *) arg);
return 0;
case TIOCSETD:
retval = check_change(tty, dev);
if (retval)
return retval;
arg = get_fs_long((unsigned long *) arg);
return tty_set_ldisc(tty, arg);
case TIOCGLCKTRMIOS:
arg = get_fs_long((unsigned long *) arg);
retval = verify_area(VERIFY_WRITE, (void *) arg,
sizeof (struct termios));
if (retval)
return retval;
memcpy_tofs((struct termios *) arg,
&termios_locked[termios_dev],
sizeof (struct termios));
return 0;
case TIOCSLCKTRMIOS:
if (!suser())
return -EPERM;
arg = get_fs_long((unsigned long *) arg);
memcpy_fromfs(&termios_locked[termios_dev],
(struct termios *) arg,
sizeof (struct termios));
return 0;
case TIOCPKT:
if (!IS_A_PTY_MASTER(dev))
return -ENOTTY;
retval = verify_area(VERIFY_READ, (void *) arg,
sizeof (unsigned long));
if (retval)
return retval;
if (get_fs_long(arg)) {
if (!tty->packet) {
tty->packet = 1;
tty->link->ctrl_status = 0;
}
} else
tty->packet = 0;
return 0;
case TCSBRK: case TCSBRKP:
retval = check_change(tty, dev);
if (retval)
return retval;
wait_until_sent(tty, 0);
if (!tty->ioctl)
return 0;
tty->ioctl(tty, file, cmd, arg);
return 0;
default:
if (tty->ioctl) {
retval = (tty->ioctl)(tty, file, cmd, arg);
if (retval != -EINVAL)
return retval;
}
if (ldiscs[tty->disc].ioctl) {
retval = (ldiscs[tty->disc].ioctl)
(tty, file, cmd, arg);
return retval;
}
return -EINVAL;
}
void OS_X11::initialize(const VideoMode& p_desired,int p_video_driver,int p_audio_driver) {
last_button_state=0;
xmbstring=NULL;
event_id=0;
x11_window=0;
last_click_ms=0;
args=OS::get_singleton()->get_cmdline_args();
current_videomode=p_desired;
main_loop=NULL;
last_timestamp=0;
last_mouse_pos_valid=false;
last_keyrelease_time=0;
if (get_render_thread_mode()==RENDER_SEPARATE_THREAD) {
XInitThreads();
}
/** XLIB INITIALIZATION **/
x11_display = XOpenDisplay(NULL);
char * modifiers = XSetLocaleModifiers ("@im=none");
ERR_FAIL_COND( modifiers == NULL );
xim = XOpenIM (x11_display, NULL, NULL, NULL);
if (xim == NULL) {
WARN_PRINT("XOpenIM failed");
xim_style=0L;
} else {
::XIMStyles *xim_styles=NULL;
xim_style=0L;
char *imvalret=NULL;
imvalret = XGetIMValues(xim, XNQueryInputStyle, &xim_styles, NULL);
if (imvalret != NULL || xim_styles == NULL) {
fprintf (stderr, "Input method doesn't support any styles\n");
}
if (xim_styles) {
xim_style = 0L;
for (int i=0;i<xim_styles->count_styles;i++) {
if (xim_styles->supported_styles[i] ==
(XIMPreeditNothing | XIMStatusNothing)) {
xim_style = xim_styles->supported_styles[i];
break;
}
}
XFree (xim_styles);
}
XFree( imvalret );
}
/*
char* windowid = getenv("GODOT_WINDOWID");
if (windowid) {
//freopen("/home/punto/stdout", "w", stdout);
//reopen("/home/punto/stderr", "w", stderr);
x11_window = atol(windowid);
XWindowAttributes xwa;
XGetWindowAttributes(x11_display,x11_window,&xwa);
current_videomode.width = xwa.width;
current_videomode.height = xwa.height;
};
*/
// maybe contextgl wants to be in charge of creating the window
//print_line("def videomode "+itos(current_videomode.width)+","+itos(current_videomode.height));
#if defined(OPENGL_ENABLED) || defined(LEGACYGL_ENABLED)
context_gl = memnew( ContextGL_X11( x11_display, x11_window,current_videomode, false ) );
context_gl->initialize();
rasterizer = memnew( RasterizerGLES2 );
#endif
visual_server = memnew( VisualServerRaster(rasterizer) );
if (get_render_thread_mode()!=RENDER_THREAD_UNSAFE) {
visual_server =memnew(VisualServerWrapMT(visual_server,get_render_thread_mode()==RENDER_SEPARATE_THREAD));
}
#if 1
// NEW_WM_API
// borderless fullscreen window mode
if (current_videomode.fullscreen) {
// needed for lxde/openbox, possibly others
Hints hints;
Atom property;
hints.flags = 2;
hints.decorations = 0;
property = XInternAtom(x11_display, "_MOTIF_WM_HINTS", True);
XChangeProperty(x11_display, x11_window, property, property, 32, PropModeReplace, (unsigned char *)&hints, 5);
XMapRaised(x11_display, x11_window);
XWindowAttributes xwa;
XGetWindowAttributes(x11_display, DefaultRootWindow(x11_display), &xwa);
XMoveResizeWindow(x11_display, x11_window, 0, 0, xwa.width, xwa.height);
// code for netwm-compliants
XEvent xev;
Atom wm_state = XInternAtom(x11_display, "_NET_WM_STATE", False);
Atom fullscreen = XInternAtom(x11_display, "_NET_WM_STATE_FULLSCREEN", False);
memset(&xev, 0, sizeof(xev));
xev.type = ClientMessage;
xev.xclient.window = x11_window;
xev.xclient.message_type = wm_state;
xev.xclient.format = 32;
xev.xclient.data.l[0] = 1;
xev.xclient.data.l[1] = fullscreen;
xev.xclient.data.l[2] = 0;
XSendEvent(x11_display, DefaultRootWindow(x11_display), False, SubstructureNotifyMask, &xev);
}
// disable resizable window
if (!current_videomode.resizable) {
XSizeHints *xsh;
xsh = XAllocSizeHints();
xsh->flags = PMinSize | PMaxSize;
XWindowAttributes xwa;
if (current_videomode.fullscreen) {
XGetWindowAttributes(x11_display,DefaultRootWindow(x11_display),&xwa);
} else {
XGetWindowAttributes(x11_display,x11_window,&xwa);
}
xsh->min_width = xwa.width;
xsh->max_width = xwa.width;
xsh->min_height = xwa.height;
xsh->max_height = xwa.height;
XSetWMNormalHints(x11_display, x11_window, xsh);
XFree(xsh);
}
#else
capture_idle = 0;
minimized = false;
maximized = false;
if (current_videomode.fullscreen) {
//set_wm_border(false);
set_wm_fullscreen(true);
}
if (!current_videomode.resizable) {
int screen = get_current_screen();
Size2i screen_size = get_screen_size(screen);
set_window_size(screen_size);
set_window_resizable(false);
}
#endif
AudioDriverManagerSW::get_driver(p_audio_driver)->set_singleton();
audio_driver_index=p_audio_driver;
if (AudioDriverManagerSW::get_driver(p_audio_driver)->init()!=OK) {
bool success=false;
audio_driver_index=-1;
for(int i=0;i<AudioDriverManagerSW::get_driver_count();i++) {
if (i==p_audio_driver)
continue;
AudioDriverManagerSW::get_driver(i)->set_singleton();
if (AudioDriverManagerSW::get_driver(i)->init()==OK) {
success=true;
print_line("Audio Driver Failed: "+String(AudioDriverManagerSW::get_driver(p_audio_driver)->get_name()));
print_line("Using alternate audio driver: "+String(AudioDriverManagerSW::get_driver(i)->get_name()));
audio_driver_index=i;
break;
}
}
if (!success) {
ERR_PRINT("Initializing audio failed.");
}
}
sample_manager = memnew( SampleManagerMallocSW );
audio_server = memnew( AudioServerSW(sample_manager) );
audio_server->init();
spatial_sound_server = memnew( SpatialSoundServerSW );
spatial_sound_server->init();
spatial_sound_2d_server = memnew( SpatialSound2DServerSW );
spatial_sound_2d_server->init();
ERR_FAIL_COND(!visual_server);
ERR_FAIL_COND(x11_window==0);
XSetWindowAttributes new_attr;
new_attr.event_mask=KeyPressMask | KeyReleaseMask | ButtonPressMask |
ButtonReleaseMask | EnterWindowMask |
LeaveWindowMask | PointerMotionMask |
Button1MotionMask |
Button2MotionMask | Button3MotionMask |
Button4MotionMask | Button5MotionMask |
ButtonMotionMask | KeymapStateMask |
ExposureMask | VisibilityChangeMask |
StructureNotifyMask |
SubstructureNotifyMask | SubstructureRedirectMask |
FocusChangeMask | PropertyChangeMask |
ColormapChangeMask | OwnerGrabButtonMask;
XChangeWindowAttributes(x11_display, x11_window,CWEventMask,&new_attr);
XClassHint* classHint;
/* set the titlebar name */
XStoreName(x11_display, x11_window, "Godot");
/* set the name and class hints for the window manager to use */
classHint = XAllocClassHint();
if (classHint) {
classHint->res_name = (char *)"Godot";
classHint->res_class = (char *)"Godot";
}
XSetClassHint(x11_display, x11_window, classHint);
XFree(classHint);
wm_delete = XInternAtom(x11_display, "WM_DELETE_WINDOW", true);
XSetWMProtocols(x11_display, x11_window, &wm_delete, 1);
if (xim && xim_style) {
xic = XCreateIC (xim,XNInputStyle, xim_style,XNClientWindow,x11_window,XNFocusWindow, x11_window, (char*)NULL);
} else {
xic=NULL;
WARN_PRINT("XCreateIC couldn't create xic");
}
XcursorSetTheme(x11_display,"default");
cursor_size = XcursorGetDefaultSize(x11_display);
cursor_theme = XcursorGetTheme(x11_display);
if (!cursor_theme) {
print_line("not found theme");
cursor_theme="default";
}
for(int i=0;i<CURSOR_MAX;i++) {
cursors[i]=None;
img[i]=NULL;
}
current_cursor=CURSOR_ARROW;
if (cursor_theme) {
//print_line("cursor theme: "+String(cursor_theme));
for(int i=0;i<CURSOR_MAX;i++) {
static const char *cursor_file[]={
"left_ptr",
"xterm",
"hand2",
"cross",
"watch",
"left_ptr_watch",
"fleur",
"hand1",
"X_cursor",
"sb_v_double_arrow",
"sb_h_double_arrow",
"size_bdiag",
"size_fdiag",
"hand1",
"sb_v_double_arrow",
"sb_h_double_arrow",
"question_arrow"
};
img[i] = XcursorLibraryLoadImage(cursor_file[i],cursor_theme,cursor_size);
if (img[i]) {
cursors[i]=XcursorImageLoadCursor(x11_display,img[i]);
//print_line("found cursor: "+String(cursor_file[i])+" id "+itos(cursors[i]));
} else {
if (OS::is_stdout_verbose())
print_line("failed cursor: "+String(cursor_file[i]));
}
}
}
{
Pixmap cursormask;
XGCValues xgc;
GC gc;
XColor col;
Cursor cursor;
cursormask = XCreatePixmap(x11_display, RootWindow(x11_display,DefaultScreen(x11_display)), 1, 1, 1);
xgc.function = GXclear;
gc = XCreateGC(x11_display, cursormask, GCFunction, &xgc);
XFillRectangle(x11_display, cursormask, gc, 0, 0, 1, 1);
col.pixel = 0;
col.red = 0;
col.flags = 4;
cursor = XCreatePixmapCursor(x11_display,
cursormask, cursormask,
&col, &col, 0, 0);
XFreePixmap(x11_display, cursormask);
XFreeGC(x11_display, gc);
if (cursor == None)
{
ERR_PRINT("FAILED CREATING CURSOR");
}
null_cursor=cursor;
}
set_cursor_shape(CURSOR_BUSY);
visual_server->init();
//
physics_server = memnew( PhysicsServerSW );
physics_server->init();
//physics_2d_server = memnew( Physics2DServerSW );
physics_2d_server = Physics2DServerWrapMT::init_server<Physics2DServerSW>();
physics_2d_server->init();
input = memnew( InputDefault );
#ifdef JOYDEV_ENABLED
joystick = memnew( joystick_linux(input));
#endif
_ensure_data_dir();
}
extern int main(int argc, char **argv)
#endif
{
struct termios mode;
enum output_type output_type;
int optc;
int require_set_attr;
int speed_was_set;
int verbose_output;
int recoverable_output;
int k;
int noargs = 1;
char * file_name = NULL;
int fd;
const char *device_name;
output_type = changed;
verbose_output = 0;
recoverable_output = 0;
/* Don't print error messages for unrecognized options. */
opterr = 0;
while ((optc = getopt(argc, argv, "agF:")) != -1) {
switch (optc) {
case 'a':
verbose_output = 1;
output_type = all;
break;
case 'g':
recoverable_output = 1;
output_type = recoverable;
break;
case 'F':
if (file_name)
error_msg_and_die("only one device may be specified");
file_name = optarg;
break;
default: /* unrecognized option */
noargs = 0;
break;
}
if (noargs == 0)
break;
}
if (optind < argc)
noargs = 0;
/* Specifying both -a and -g gets an error. */
if (verbose_output && recoverable_output)
error_msg_and_die ("verbose and stty-readable output styles are mutually exclusive");
/* Specifying any other arguments with -a or -g gets an error. */
if (!noargs && (verbose_output || recoverable_output))
error_msg_and_die ("modes may not be set when specifying an output style");
/* FIXME: it'd be better not to open the file until we've verified
that all arguments are valid. Otherwise, we could end up doing
only some of the requested operations and then failing, probably
leaving things in an undesirable state. */
if (file_name) {
int fdflags;
device_name = file_name;
fd = open(device_name, O_RDONLY | O_NONBLOCK);
if (fd < 0)
perror_msg_and_die("%s", device_name);
if ((fdflags = fcntl(fd, F_GETFL)) == -1
|| fcntl(fd, F_SETFL, fdflags & ~O_NONBLOCK) < 0)
perror_msg_and_die("%s: couldn't reset non-blocking mode",
device_name);
} else {
fd = 0;
device_name = "standard input";
}
/* Initialize to all zeroes so there is no risk memcmp will report a
spurious difference in an uninitialized portion of the structure. */
memset(&mode, 0, sizeof(mode));
if (tcgetattr(fd, &mode))
perror_msg_and_die("%s", device_name);
if (verbose_output || recoverable_output || noargs) {
max_col = screen_columns();
current_col = 0;
display_settings(output_type, &mode, fd, device_name);
return EXIT_SUCCESS;
}
speed_was_set = 0;
require_set_attr = 0;
k = 0;
while (++k < argc) {
int match_found = 0;
int reversed = 0;
int i;
if (argv[k][0] == '-') {
char *find_dev_opt;
++argv[k];
/* Handle "-a", "-ag", "-aF/dev/foo", "-aF /dev/foo", etc.
Find the options that have been parsed. This is really
gross, but it's needed because stty SETTINGS look like options to
getopt(), so we need to work around things in a really horrible
way. If any new options are ever added to stty, the short option
MUST NOT be a letter which is the first letter of one of the
possible stty settings.
*/
find_dev_opt = strchr(argv[k], 'F'); /* find -*F* */
if(find_dev_opt) {
if(find_dev_opt[1]==0) /* -*F /dev/foo */
k++; /* skip /dev/foo */
continue; /* else -*F/dev/foo - no skip */
}
if(argv[k][0]=='a' || argv[k][0]=='g')
continue;
/* Is not options - is reverse params */
reversed = 1;
}
for (i = 0; i < NUM_mode_info; ++i)
if (STREQ(argv[k], mode_info[i].name)) {
match_found = set_mode(&mode_info[i], reversed, &mode);
require_set_attr = 1;
break;
}
if (match_found == 0 && reversed)
error_msg_and_die("invalid argument `%s'", --argv[k]);
if (match_found == 0)
for (i = 0; i < NUM_control_info; ++i)
if (STREQ(argv[k], control_info[i].name)) {
if (k == argc - 1)
error_msg_and_die("missing argument to `%s'", argv[k]);
match_found = 1;
++k;
set_control_char(&control_info[i], argv[k], &mode);
require_set_attr = 1;
break;
}
if (match_found == 0) {
if (STREQ(argv[k], "ispeed")) {
if (k == argc - 1)
error_msg_and_die("missing argument to `%s'", argv[k]);
++k;
set_speed(input_speed, argv[k], &mode);
speed_was_set = 1;
require_set_attr = 1;
} else if (STREQ(argv[k], "ospeed")) {
if (k == argc - 1)
error_msg_and_die("missing argument to `%s'", argv[k]);
++k;
set_speed(output_speed, argv[k], &mode);
speed_was_set = 1;
require_set_attr = 1;
}
#ifdef TIOCGWINSZ
else if (STREQ(argv[k], "rows")) {
if (k == argc - 1)
error_msg_and_die("missing argument to `%s'", argv[k]);
++k;
set_window_size((int) parse_number(argv[k], stty_suffixes),
-1, fd, device_name);
} else if (STREQ(argv[k], "cols") || STREQ(argv[k], "columns")) {
if (k == argc - 1)
error_msg_and_die("missing argument to `%s'", argv[k]);
++k;
set_window_size(-1,
(int) parse_number(argv[k], stty_suffixes),
fd, device_name);
} else if (STREQ(argv[k], "size")) {
max_col = screen_columns();
current_col = 0;
display_window_size(0, fd, device_name);
}
#endif
#ifdef HAVE_C_LINE
else if (STREQ(argv[k], "line")) {
if (k == argc - 1)
error_msg_and_die("missing argument to `%s'", argv[k]);
++k;
mode.c_line = parse_number(argv[k], stty_suffixes);
require_set_attr = 1;
}
#endif
else if (STREQ(argv[k], "speed")) {
max_col = screen_columns();
display_speed(&mode, 0);
} else if (recover_mode(argv[k], &mode) == 1)
require_set_attr = 1;
else if (string_to_baud(argv[k]) != (speed_t) - 1) {
set_speed(both_speeds, argv[k], &mode);
speed_was_set = 1;
require_set_attr = 1;
} else
error_msg_and_die("invalid argument `%s'", argv[k]);
}
}
if (require_set_attr) {
struct termios new_mode;
if (tcsetattr(fd, TCSADRAIN, &mode))
perror_msg_and_die("%s", device_name);
/* POSIX (according to Zlotnick's book) tcsetattr returns zero if
it performs *any* of the requested operations. This means it
can report `success' when it has actually failed to perform
some proper subset of the requested operations. To detect
this partial failure, get the current terminal attributes and
compare them to the requested ones. */
/* Initialize to all zeroes so there is no risk memcmp will report a
spurious difference in an uninitialized portion of the structure. */
memset(&new_mode, 0, sizeof(new_mode));
if (tcgetattr(fd, &new_mode))
perror_msg_and_die("%s", device_name);
/* Normally, one shouldn't use memcmp to compare structures that
may have `holes' containing uninitialized data, but we have been
careful to initialize the storage of these two variables to all
zeroes. One might think it more efficient simply to compare the
modified fields, but that would require enumerating those fields --
and not all systems have the same fields in this structure. */
if (memcmp(&mode, &new_mode, sizeof(mode)) != 0) {
#ifdef CIBAUD
/* SunOS 4.1.3 (at least) has the problem that after this sequence,
tcgetattr (&m1); tcsetattr (&m1); tcgetattr (&m2);
sometimes (m1 != m2). The only difference is in the four bits
of the c_cflag field corresponding to the baud rate. To save
Sun users a little confusion, don't report an error if this
happens. But suppress the error only if we haven't tried to
set the baud rate explicitly -- otherwise we'd never give an
error for a true failure to set the baud rate. */
new_mode.c_cflag &= (~CIBAUD);
if (speed_was_set || memcmp(&mode, &new_mode, sizeof(mode)) != 0)
#endif
error_msg_and_die ("%s: unable to perform all requested operations",
device_name);
}
}
return EXIT_SUCCESS;
}
static void
set_window_size(int fd, const struct window_size* ws)
{
int ret;
struct winsize wz = {
.ws_row = ws->row,
.ws_col = ws->col,
.ws_xpixel = ws->xpixel,
.ws_ypixel = ws->ypixel,
};
do {
ret = ioctl(fd, TIOCSWINSZ, &wz);
} while (ret == -1 && errno == EINTR);
dbg("TIOCSWINSZ(%ux%u): %d", wz.ws_row, wz.ws_col, ret);
}
struct stub {
struct fb_adb_sh sh;
struct child* child;
};
static void
stub_process_msg(struct fb_adb_sh* sh, struct msg mhdr)
{
if (mhdr.type == MSG_WINDOW_SIZE) {
struct msg_window_size m;
read_cmdmsg(sh, mhdr, &m, sizeof (m));
dbgmsg(&m.msg, "recv");
struct stub* stub = (struct stub*) sh;
if (stub->child->pty_master)
set_window_size(stub->child->pty_master->fd, &m.ws);
return;
}
fb_adb_sh_process_msg(sh, mhdr);
}
static void
setup_pty(int master, int slave, void* arg)
{
struct msg_shex_hello* shex_hello = arg;
char* hello_end = (char*) shex_hello + shex_hello->msg.size;
struct termios attr = { 0 };
xtcgetattr(slave, &attr);
if (shex_hello->ispeed)
cfsetispeed(&attr, shex_hello->ispeed);
if (shex_hello->ospeed)
cfsetospeed(&attr, shex_hello->ospeed);
const struct termbit* tb = &termbits[0];
const struct termbit* tb_end = tb + nr_termbits;
struct term_control* tc = &shex_hello->tctl[0];
while ((char*)(tc+1) <= hello_end && tb < tb_end) {
int cmp = strncmp(tc->name, tb->name, sizeof (tc->name));
if (cmp < 0) {
dbg("tc not present: %.*s", (int) sizeof (tc->name), tc->name);
tc++;
continue;
}
if (cmp > 0) {
dbg("tc not sent: %s", tb->name);
tb++;
continue;
}
tcflag_t* flg = NULL;
if (tb->thing == TERM_IFLAG) {
flg = &attr.c_iflag;
} else if (tb->thing == TERM_OFLAG) {
flg = &attr.c_oflag;
} else if (tb->thing == TERM_LFLAG) {
flg = &attr.c_lflag;
} else if (tb->thing == TERM_C_CC) {
if (tc->value == shex_hello->posix_vdisable_value)
attr.c_cc[tb->value] = _POSIX_VDISABLE;
else
attr.c_cc[tb->value] = tc->value;
dbg("c_cc[%s] = %d", tb->name, tc->value);
}
if (flg) {
if (tc->value) {
dbg("pty %s: set", tb->name);
*flg |= tb->value;
} else {
dbg("pty %s: reset", tb->name);
*flg &= ~tb->value;
}
}
tc++;
tb++;
}
xtcsetattr(slave, &attr);
if (shex_hello->have_ws) {
dbg("ws %ux%u (%ux%u)",
shex_hello->ws.row,
shex_hello->ws.col,
shex_hello->ws.xpixel,
shex_hello->ws.ypixel);
set_window_size(master, &shex_hello->ws);
}
}
static char**
read_child_arglist(size_t expected)
{
char** argv;
if (expected >= SIZE_MAX / sizeof (*argv))
die(EFBIG, "too many arguments");
argv = xalloc(sizeof (*argv) * (1+expected));
for (size_t argno = 0; argno < expected; ++argno) {
SCOPED_RESLIST(rl_read_arg);
struct msg_cmdline_argument* m;
struct msg* mhdr = read_msg(0, read_all_adb_encoded);
reslist_pop_nodestroy(rl_read_arg);
const char* argval;
size_t arglen;
if (mhdr->type == MSG_CMDLINE_ARGUMENT) {
m = (struct msg_cmdline_argument*) mhdr;
if (mhdr->size < sizeof (*m))
die(ECOMM,
"bad handshake: MSG_CMDLINE_ARGUMENT size %u < %u",
(unsigned) mhdr->size,
(unsigned) sizeof (*m));
argval = m->value;
arglen = m->msg.size - sizeof (*m);
} else if (mhdr->type == MSG_CMDLINE_DEFAULT_SH ||
mhdr->type == MSG_CMDLINE_DEFAULT_SH_LOGIN)
{
argval = getenv("SHELL");
if (argval == NULL)
argval = DEFAULT_SHELL;
if (mhdr->type == MSG_CMDLINE_DEFAULT_SH_LOGIN)
argval = xaprintf("-%s", argval);
arglen = strlen(argval);
} else {
die(ECOMM,
"bad handshake: unknown init msg s=%u t=%u",
(unsigned) mhdr->size, (unsigned) mhdr->type);
}
argv[argno] = xalloc(arglen + 1);
memcpy(argv[argno], argval, arglen);
argv[argno][arglen] = '\0';
}
argv[expected] = NULL;
return argv;
}
int stty_main(int argc UNUSED_PARAM, char **argv)
{
struct termios mode;
void (*output_func)(const struct termios *, int);
const char *file_name = NULL;
int display_all = 0;
int stty_state;
int k;
INIT_G();
stty_state = STTY_noargs;
output_func = do_display;
/* First pass: only parse/verify command line params */
k = 0;
while (argv[++k]) {
const struct mode_info *mp;
const struct control_info *cp;
const char *arg = argv[k];
const char *argnext = argv[k+1];
int param;
if (arg[0] == '-') {
int i;
mp = find_mode(arg+1);
if (mp) {
if (!(mp->flags & REV))
goto invalid_argument;
stty_state &= ~STTY_noargs;
continue;
}
/* It is an option - parse it */
i = 0;
while (arg[++i]) {
switch (arg[i]) {
case 'a':
stty_state |= STTY_verbose_output;
output_func = do_display;
display_all = 1;
break;
case 'g':
stty_state |= STTY_recoverable_output;
output_func = display_recoverable;
break;
case 'F':
if (file_name)
bb_error_msg_and_die("only one device may be specified");
file_name = &arg[i+1]; /* "-Fdevice" ? */
if (!file_name[0]) { /* nope, "-F device" */
int p = k+1; /* argv[p] is argnext */
file_name = argnext;
if (!file_name)
bb_error_msg_and_die(bb_msg_requires_arg, "-F");
/* remove -F param from arg[vc] */
while (argv[p]) {
argv[p] = argv[p+1];
++p;
}
}
goto end_option;
default:
goto invalid_argument;
}
}
end_option:
continue;
}
mp = find_mode(arg);
if (mp) {
stty_state &= ~STTY_noargs;
continue;
}
cp = find_control(arg);
if (cp) {
if (!argnext)
bb_error_msg_and_die(bb_msg_requires_arg, arg);
/* called for the side effect of xfunc death only */
set_control_char_or_die(cp, argnext, &mode);
stty_state &= ~STTY_noargs;
++k;
continue;
}
param = find_param(arg);
if (param & param_need_arg) {
if (!argnext)
bb_error_msg_and_die(bb_msg_requires_arg, arg);
++k;
}
switch (param) {
#ifdef __linux__
case param_line:
# ifndef TIOCGWINSZ
xatoul_range_sfx(argnext, 1, INT_MAX, stty_suffixes);
break;
# endif /* else fall-through */
#endif
#ifdef TIOCGWINSZ
case param_rows:
case param_cols:
case param_columns:
xatoul_range_sfx(argnext, 1, INT_MAX, stty_suffixes);
break;
case param_size:
#endif
case param_speed:
break;
case param_ispeed:
/* called for the side effect of xfunc death only */
set_speed_or_die(input_speed, argnext, &mode);
break;
case param_ospeed:
/* called for the side effect of xfunc death only */
set_speed_or_die(output_speed, argnext, &mode);
break;
default:
if (recover_mode(arg, &mode) == 1) break;
if (tty_value_to_baud(xatou(arg)) != (speed_t) -1) break;
invalid_argument:
bb_error_msg_and_die("invalid argument '%s'", arg);
}
stty_state &= ~STTY_noargs;
}
/* Specifying both -a and -g is an error */
if ((stty_state & (STTY_verbose_output | STTY_recoverable_output)) ==
(STTY_verbose_output | STTY_recoverable_output)
) {
bb_error_msg_and_die("-a and -g are mutually exclusive");
}
/* Specifying -a or -g with non-options is an error */
if ((stty_state & (STTY_verbose_output | STTY_recoverable_output))
&& !(stty_state & STTY_noargs)
) {
bb_error_msg_and_die("modes may not be set when -a or -g is used");
}
/* Now it is safe to start doing things */
if (file_name) {
G.device_name = file_name;
xmove_fd(xopen_nonblocking(G.device_name), STDIN_FILENO);
ndelay_off(STDIN_FILENO);
}
/* Initialize to all zeroes so there is no risk memcmp will report a
spurious difference in an uninitialized portion of the structure */
memset(&mode, 0, sizeof(mode));
if (tcgetattr(STDIN_FILENO, &mode))
perror_on_device_and_die("%s");
if (stty_state & (STTY_verbose_output | STTY_recoverable_output | STTY_noargs)) {
G.max_col = get_terminal_width(STDOUT_FILENO);
output_func(&mode, display_all);
return EXIT_SUCCESS;
}
/* Second pass: perform actions */
k = 0;
while (argv[++k]) {
const struct mode_info *mp;
const struct control_info *cp;
const char *arg = argv[k];
const char *argnext = argv[k+1];
int param;
if (arg[0] == '-') {
mp = find_mode(arg+1);
if (mp) {
set_mode(mp, 1 /* reversed */, &mode);
stty_state |= STTY_require_set_attr;
}
/* It is an option - already parsed. Skip it */
continue;
}
mp = find_mode(arg);
if (mp) {
set_mode(mp, 0 /* non-reversed */, &mode);
stty_state |= STTY_require_set_attr;
continue;
}
cp = find_control(arg);
if (cp) {
++k;
set_control_char_or_die(cp, argnext, &mode);
stty_state |= STTY_require_set_attr;
continue;
}
param = find_param(arg);
if (param & param_need_arg) {
++k;
}
switch (param) {
#ifdef __linux__
case param_line:
mode.c_line = xatoul_sfx(argnext, stty_suffixes);
stty_state |= STTY_require_set_attr;
break;
#endif
#ifdef TIOCGWINSZ
case param_cols:
case param_columns:
set_window_size(-1, xatoul_sfx(argnext, stty_suffixes));
break;
case param_size:
display_window_size(0);
break;
case param_rows:
set_window_size(xatoul_sfx(argnext, stty_suffixes), -1);
break;
#endif
case param_speed:
display_speed(&mode, 0);
break;
case param_ispeed:
set_speed_or_die(input_speed, argnext, &mode);
stty_state |= (STTY_require_set_attr | STTY_speed_was_set);
break;
case param_ospeed:
set_speed_or_die(output_speed, argnext, &mode);
stty_state |= (STTY_require_set_attr | STTY_speed_was_set);
break;
default:
if (recover_mode(arg, &mode) == 1)
stty_state |= STTY_require_set_attr;
else /* true: if (tty_value_to_baud(xatou(arg)) != (speed_t) -1) */{
set_speed_or_die(both_speeds, arg, &mode);
stty_state |= (STTY_require_set_attr | STTY_speed_was_set);
} /* else - impossible (caught in the first pass):
bb_error_msg_and_die("invalid argument '%s'", arg); */
}
}
if (stty_state & STTY_require_set_attr) {
struct termios new_mode;
if (tcsetattr(STDIN_FILENO, TCSADRAIN, &mode))
perror_on_device_and_die("%s");
/* POSIX (according to Zlotnick's book) tcsetattr returns zero if
it performs *any* of the requested operations. This means it
can report 'success' when it has actually failed to perform
some proper subset of the requested operations. To detect
this partial failure, get the current terminal attributes and
compare them to the requested ones */
/* Initialize to all zeroes so there is no risk memcmp will report a
spurious difference in an uninitialized portion of the structure */
memset(&new_mode, 0, sizeof(new_mode));
if (tcgetattr(STDIN_FILENO, &new_mode))
perror_on_device_and_die("%s");
if (memcmp(&mode, &new_mode, sizeof(mode)) != 0) {
/*
* I think the below chunk is not necessary on Linux.
* If you are deleting it, also delete STTY_speed_was_set bit -
* it is only ever checked here.
*/
#if 0 /* was "if CIBAUD" */
/* SunOS 4.1.3 (at least) has the problem that after this sequence,
tcgetattr (&m1); tcsetattr (&m1); tcgetattr (&m2);
sometimes (m1 != m2). The only difference is in the four bits
of the c_cflag field corresponding to the baud rate. To save
Sun users a little confusion, don't report an error if this
happens. But suppress the error only if we haven't tried to
set the baud rate explicitly -- otherwise we'd never give an
error for a true failure to set the baud rate */
new_mode.c_cflag &= (~CIBAUD);
if ((stty_state & STTY_speed_was_set)
|| memcmp(&mode, &new_mode, sizeof(mode)) != 0)
#endif
perror_on_device_and_die("%s: cannot perform all requested operations");
}
}
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
set_window_size(100, 100);
return run(argc, argv, init, reshape,
draw, 0);
}
static LRESULT CALLBACK
startup_wnd_proc(
HWND hWnd,
UINT uMsg,
WPARAM wParam,
LPARAM lParam)
{
MSG msg;
Sint32 screenType;
Sint32 drawMode;
Sint32 drawMethod;
Sint32 vsync;
Sint32 psgType;
Sint32 soundBuffer;
switch (uMsg)
{
case WM_CREATE:
EnableWindow(WINMAIN_GetHwnd(), FALSE);//メインウィンドウを無効化してモーダルに。
_hFontB = CreateFont( 0, // 高さ。0 = デフォルト
0, // 幅。0なら高さに合った幅
0, // 角度
0, // ベースラインとの角度
FW_NORMAL, // 太さ
FALSE, // イタリック
FALSE, // アンダーライン
FALSE, // 打ち消し線
0, // 日本語を取り扱うときはSHIFTJIS_CHARSETにする。
0, // 出力精度
0, // クリッピング精度
0, // 出力品質
0, // ピッチとファミリー
"" // 書体名
); //英語のデフォルトフォントに設定
_FontWidth = get_font_width(hWnd);
_FontHeight = get_font_height(hWnd);
set_window_size(hWnd);
break;
case WM_PAINT:
update_window(hWnd);
break;
case WM_COMMAND:
switch(LOWORD(wParam))
{
case BUTTON_CDROM:
_CDorHu = 1; //戻り値を設定
PostMessage(hWnd, WM_CLOSE, 0, 0);
break;
case BUTTON_CUE:
_CDorHu = 2; //戻り値を設定
PostMessage(hWnd, WM_CLOSE, 0, 0);
break;
case BUTTON_HUCARD:
_CDorHu = 3; //戻り値を設定
PostMessage(hWnd, WM_CLOSE, 0, 0);
break;
case BUTTON_REPLAY:
_CDorHu = 4; //戻り値を設定
PostMessage(hWnd, WM_CLOSE, 0, 0);
break;
case BUTTON_OPTION:
soundBuffer = 0; //全項目の値が設定されたかどうかの判断にも使用。
OPTION_Init(_hInstance, &screenType, &drawMode, &drawMethod, &vsync, &psgType, &soundBuffer); //Optionウィンドウを表示
//メッセージループ
while (soundBuffer == 0) //ダイアログが結果を返すまでループ
{
GetMessage(&msg ,NULL, 0, 0);
TranslateMessage(&msg);
DispatchMessage(&msg);
}
//Ok(SET)ボタンが押されていた場合、スクリーン設定を変更する。
if (screenType > 0)
{
switch (screenType)
{
case 1: APP_SetStartFullScreen(FALSE); break;
case 2:
APP_SetMagnification(2); //x2倍に設定
APP_SetStartFullScreen(FALSE);
break;
case 3:
APP_SetMagnification(3); //x3倍に設定
APP_SetStartFullScreen(FALSE);
break;
case 4:
APP_SetMagnification(4); //x4倍に設定
APP_SetStartFullScreen(FALSE);
break;
case 5: APP_SetStartFullScreen(TRUE); break;
case 6:
APP_SetFullScreen640(); //640x480に設定
APP_SetStartFullScreen(TRUE);
break;
}
}
//Ok(SET)ボタンが押されていた場合、DrawMode設定を変更する。
if (drawMode > 0)
{
switch (drawMode)
{
case 1: APP_SetScanLineType(1,TRUE); break;
case 2: APP_SetScanLineType(4,TRUE); break;
case 3: APP_SetScanLineType(2,TRUE); break;
case 4: APP_SetScanLineType(0,TRUE); break;
}
}
//Ok(SET)ボタンが押されていた場合、DrawMethod設定を変更する。
if (drawMethod > 0)
{
APP_SetDrawMethod(drawMethod);
}
//Ok(SET)ボタンが押されていた場合、V-Sync設定を変更する。
if (screenType > 0)
{
if (vsync == 2)
APP_SetSyncTo60HzScreen(FALSE);
else //==1
APP_SetSyncTo60HzScreen(TRUE);
}
//Ok(SET)ボタンが押されていた場合、PSGクォリティ設定を変更する。
if (psgType > 0)
{
if (psgType == 3)
APP_SetPsgQuality(1);
else if (psgType == 2)
APP_SetPsgQuality(2);
else //==1
APP_SetPsgQuality(4);
}
//Ok(SET)ボタンが押されていた場合、PSGクォリティ設定を変更する。
if (soundBuffer > 0)
{
switch (soundBuffer)
{
case 1: APP_SetSoundBufferSize(1024); break;
case 2: APP_SetSoundBufferSize(1152); break;
case 3: APP_SetSoundBufferSize(1280); break;
case 4: APP_SetSoundBufferSize(1408); break;
case 5: APP_SetSoundBufferSize(1536); break;
case 7: APP_SetSoundBufferSize(1792); break;
case 8: APP_SetSoundBufferSize(2048); break;
case 9: APP_SetSoundBufferSize(2176); break;
case 10: APP_SetSoundBufferSize(2304); break;
case 11: APP_SetSoundBufferSize(2560); break;
case 12: APP_SetSoundBufferSize(3072); break;
default: //==6
APP_SetSoundBufferSize(1664); break;
}
}
break;
}
break;
case WM_KEYDOWN:
if (wParam == VK_ESCAPE)
PostMessage(hWnd, WM_CLOSE, 0, 0);
if ((wParam == 'C')||(wParam == VK_RETURN)) //「C」キーまたは 「Enter」キー
{
_CDorHu = 1; //戻り値を設定
PostMessage(hWnd, WM_CLOSE, 0, 0);
}
if (wParam == 'P') //「P」キー
{
_CDorHu = 2; //戻り値を設定
PostMessage(hWnd, WM_CLOSE, 0, 0);
}
if ((wParam == 'H')||(wParam == 'O')||(wParam == VK_SPACE)) //「H」キー「O」キーまたは スペースキー
{
_CDorHu = 3; //戻り値を設定
PostMessage(hWnd, WM_CLOSE, 0, 0);
}
if (wParam == 'R') //「R」キー
{
_CDorHu = 4; //戻り値を設定
PostMessage(hWnd, WM_CLOSE, 0, 0);
}
break;
case WM_CLOSE:
STARTUP_Deinit();
return 0;
}
return DefWindowProc(hWnd, uMsg, wParam, lParam);
}
int main(int argc, char **argv)
{
set_window_size(64, 64);
return run(argc, argv, init, reshape,
draw, key_press);
}
int main( int argc, char* args[] )
{
// this is the last time (SDL_Getticks()) that beasts were evaluated
int beastLastEval=0;
// this is how many times per second the beasts should be evaluated
int beastEvalsPerSec = 30;
paused = 0;
//get a random seed.
sgenrand(time(NULL));
//mouse variables and cell types
int x, y, sleepTime = 0, countVar = 0;
//mouse is held variables
int mouseStatusLeft = 0, mouseStatusRight = 0;
// these keep track of the position of the right mouse button when it was clicked down
int mouseRDx;
int mouseRDy;
//make sure the program waits for a quit
int quit = false;
init_mats();
init_graphics();
init_controls();
//Initialize
if( init() == false ) return 1;
//Load the files
if( load_files() == false ) return 2;
//Update the screen
if( SDL_Flip( screen ) == -1 ) return 3;
gen_world();
// these keep track of the WASD keys.
int keyw=0, keya=0, keys=0, keyd=0;
int key; // used as a stand-int for the verbose event.key.keysym.sym
bool keyF3=true;
//these are used to calculating and keeping track of the FPS
int ticksSinceLastFPSUpdate = 0;
int cumulativeFrames = 0;
int currentTicks = 0;
SDL_Rect screenRect;
screenRect.x = screenRect.y = 0;
screenRect.w = SCREEN_WIDTH;
screenRect.h = SCREEN_HEIGHT;
//While the user hasn't quit
while(1){
//While there's an event to handle
while( SDL_PollEvent( &event ) ){
//If the user has Xed out the window
if( event.type == SDL_QUIT || quit == true ){
//Quit the program
clean_up();
return 0;
}
if( event.type == SDL_MOUSEBUTTONDOWN ){ /// mouse down
x = event.motion.x;
y = event.motion.y;
if( event.button.button == SDL_BUTTON_LEFT ){
mouseStatusLeft = 1;
}
else if( event.button.button == SDL_BUTTON_RIGHT ){
mouseStatusRight = 1;
mouseRDx = x;
mouseRDy = y;
}
else if( event.button.button == SDL_BUTTON_WHEELUP )
;//zoom_in(x,y);
else if( event.button.button == SDL_BUTTON_WHEELDOWN )
;//zoom_out(x,y);
}
else if(event.type == SDL_MOUSEBUTTONUP){ /// mouse up
x = event.motion.x;
y = event.motion.y;
if( event.button.button == SDL_BUTTON_LEFT ){
mouseStatusLeft = 0;
}
else if( event.button.button == SDL_BUTTON_RIGHT ){
mouseStatusRight = 0;
}
}
else if( event.type == SDL_MOUSEMOTION ){ /// mouse motion
x = event.motion.x;
y = event.motion.y;
/*
// if the alt key (camera panning key) is down and the coordinates have changed, then let the screen be panned!
if(alt && x != mouse_x_when_pan && y != mouse_y_when_pan){
// this adjusts the x-axis camera (this scales with the CELL_SIZE)
camera_x += (x-mouse_x_when_pan+remainder_panning_motion_x)/CELL_SIZE;
camera_y += (y-mouse_y_when_pan+remainder_panning_motion_y)/CELL_SIZE;
//calculate the remainders of the mouse motion.
// these values represent the motion of the mouse that is not utilized by the discrete nature of the operation on the camera_x and camera_y values.
remainder_panning_motion_x = (x-mouse_x_when_pan+remainder_panning_motion_x) - (int)((x-mouse_x_when_pan+remainder_panning_motion_x)/CELL_SIZE)*CELL_SIZE;
remainder_panning_motion_y = (y-mouse_y_when_pan+remainder_panning_motion_y) - (int)((y-mouse_y_when_pan+remainder_panning_motion_y)/CELL_SIZE)*CELL_SIZE;
// make sure the camera is not out of bounds.
verify_camera();
//reset the user's curcor position to the original position the curcor was in when the user started panning the camera
SDL_WarpMouse(mouse_x_when_pan, mouse_y_when_pan);
}
*/
}
else if(event.type == SDL_VIDEORESIZE){ /// window resize
// don't resize the grid.
//float new_cell_size = CELL_SIZE * event.resize.h/((float)SCREEN_HEIGHT); // adjust the pixel size.
//if(new_cell_size - ((int)new_cell_size) >= 0.5f) CELL_SIZE = new_cell_size + 1;
//else CELL_SIZE = new_cell_size;
screenRect.w = SCREEN_WIDTH = event.resize.w;
screenRect.h = SCREEN_HEIGHT = event.resize.h;
set_window_size(event.resize.w, event.resize.h); // set window to correct dimensions
}
if( event.type == SDL_KEYDOWN ){ ///keyboard event
key = event.key.keysym.sym;
if (key == controlsGame.pan[d_up]) camera_pan(d_up); // pan up
else if(key == controlsGame.pan[d_down]) camera_pan(d_down); // pan down
else if(key == controlsGame.pan[d_left]) camera_pan(d_left); // pan left
else if(key == controlsGame.pan[d_right]) camera_pan(d_right); // pan right
else if(key == controlsGame.debug) keyF3 ^= 1; // toggle the keyF3 state
}
if( event.type == SDL_KEYUP ){ ///keyboard event
// nothing here yet
}
} // end while(event)
//no more events to handle at the moment.
if(mouseStatusLeft==true && beast_find_at_cell(x/CELL_SIZE+cameraX,y/CELL_SIZE+cameraY) == NULL){
// add beast function
struct beastData *myBeast;
myBeast = beast_create(NULL);
if(myBeast != NULL ){
myBeast->x = x/CELL_SIZE + cameraX;
myBeast->y = y/CELL_SIZE + cameraY;
}
}
if(SDL_GetTicks()-beastLastEval > 1000/beastEvalsPerSec){
// evaluate all beasts
beasts_evaluate();
beastLastEval = SDL_GetTicks();
}
// print the grid data
print_grid(screen);
print_beasts(screen);
print_beasts_targets(screen);
// print debugging information
if(keyF3) print_debugging_information(screen);
//updates the screen
SDL_Flip( screen );
SDL_FillRect(screen, &screenRect, 0);
//----------------------------------------------------
// FPS calculation and variable handling
//----------------------------------------------------
currentTicks = SDL_GetTicks();
// it is officially the next second
if(currentTicks >= ticksSinceLastFPSUpdate + 1000){
// calculate the FPS
FPS = cumulativeFrames;//(cumulativeFrames*1000 ) / (currentTicks-ticksSinceLastFPSUpdate);
cumulativeFrames=0; // reset cumulative amount of frames
ticksSinceLastFPSUpdate = currentTicks; // reset the last FPS update to the number of ticks now.
}
cumulativeFrames++;
}// end while(quit == false)
//Free the surface and quit SDL
clean_up();
return 0;
}
int main(int argc, char **argv)
{
bool fullscreen = false;
if (SDL_Init(0) != 0){
ERR("SDL_Init\n");
return 1;
}
SDL_Window* Window = SDL_CreateWindow("SDL Nine", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE );
if (!Window) {
ERR("SDL_CreateWindow\n");
return 1;
}
d3d = SDL_Direct3DCreate9Ex(Window);
if (!d3d) {
ERR("X11_Direct3DCreate9\n");
return 1;
}
{
HWND FakeWnd= (HWND)Window;
D3DDISPLAYMODEEX mode;
D3DPRESENT_PARAMETERS d3dpp;
fillin_present_parameters(Window, SCREEN_WIDTH, SCREEN_HEIGHT, fullscreen, d3dpp, mode);
// create a device class using this information and the info from the d3dpp stuct
HRESULT hr = d3d->CreateDeviceEx(D3DADAPTER_DEFAULT,
D3DDEVTYPE_HAL,
FakeWnd,
D3DCREATE_HARDWARE_VERTEXPROCESSING,
&d3dpp, &mode,
&d3ddev);
if (FAILED(hr)) {
ERR("X11_Direct3DCreate9\n");
return 1;
}
}
init_graphics(); // call the function to initialize the triangle
Uint32 MainWindowID = SDL_GetWindowID(Window);
bool quit = false;
SDL_Event e;
//While application is running
while (!quit)
{
//Handle events on queue
while (SDL_PollEvent(&e) != 0)
{
//User requests quit
if (e.type == SDL_QUIT)
{
quit = true;
}
else if (e.type == SDL_WINDOWEVENT && e.window.windowID == MainWindowID)
{
switch (e.window.event) {
case SDL_WINDOWEVENT_SIZE_CHANGED:
{
int width = e.window.data1;
int height = e.window.data2;
bool ok = set_window_size(Window, width, height, fullscreen);
if (ok)
load_triangle(width, height, v_buffer);
} break;
}
}
else if (e.type == SDL_KEYDOWN && e.window.windowID == MainWindowID && e.key.keysym.sym == SDLK_F11 && e.key.state == SDL_PRESSED)
{
fullscreen = !fullscreen;
bool ok = set_window_size(Window, SCREEN_WIDTH, SCREEN_HEIGHT, fullscreen);
if (ok)
load_triangle(SCREEN_WIDTH, SCREEN_HEIGHT, v_buffer);
}
}
//Render quad
render_frame();
}
// clean up DirectX
{
v_buffer->Release(); // close and release the vertex buffer
d3ddev->Release(); // close and release the 3D device
d3d->Release(); // close and release Direct3D
}
SDL_Quit();
return 0;
}
int main( int argc, char* args[] )
{
//get a random seed.
srand(time(NULL));
//mouse variables and cell types
int x, y, sleepTime = 0, countVar = 0;
//mouse is held variables
int mouseStatusLeft = 0, mouseStatusRight = 0;
//make sure the program waits for a quit
int quit = false;
//Initialize
if( init() == false ) return 1;
//Load the files
if( load_files() == false ) return 2;
//Update the screen
//if( SDL_Flip( screen ) == -1 ) return 3;
//if(SDL_RenderPresent( screen ) == -1 ) return 3;
//initialize the cell stuff. This gets the cell system up and running. This also sets all cells to m_air and all the saturation to m_no_saturaion
init_cell_stuff();
/*
CELL_SIZE = 4;
int i;//
//putting test materials into grid
for(i=0; i<GRID_WIDTH; i++){
if(get_rand(1,4)==1)
grid[i+camera_x][GRID_HEIGHT-1-get_rand(7,15)+camera_y].mat = m_plant_root;
if(get_rand(1,10)==10)
grid[i+camera_x][camera_y+get_rand(20,35)].mat = m_spring;
grid[i+camera_x][camera_y+get_rand(30,34)+30].mat = m_earth;
grid[i+camera_x][camera_y+get_rand(30,34)+30].mat = m_earth;
grid[i+camera_x][camera_y+get_rand(30,34)+30].mat = m_earth;
}
*/
CELL_SIZE = 8;
sleepTime = 0;
//int i;//
//putting test materials into grid
/*
for(i=7 ; i<GRID_WIDTH ; i+=15){
for(j=26 ; j<GRID_HEIGHT ; j+=20){
grid[i][j].mat = m_anti_scurge;
}
}
*/
//--------------------------------------
//for(i=0 ; i<GRID_WIDTH*GRID_HEIGHT / 2 ; i++)
// grid[get_rand(0,GRID_WIDTH-1)][get_rand(0,GRID_HEIGHT-1)].mat = m_plant;
//int keyw=0, keya=0, keys=0, keyd=0;
//unsigned lastPanTime = 0;
bool alt = 0; // this keeps track of the state of the alt key
//these variables store the position of the user's cursor at the moment that the user decided to pan the screen
int mouse_x_when_pan=0;
int mouse_y_when_pan=0;
// these are for keeping track of the motion of the mouse when the user is panning. these keep the panning from being really jumpy.
// without them, there is a truncation error when adjusting the camera_x and camera_y materials and re-setting the mouse coordinates to its original state.
// these keep track of the truncation error and add it to the next operation so that the mouse motion feels fluid.
int remainder_panning_motion_x=0;
int remainder_panning_motion_y=0;
//last minute verification that the initial start up values for the grid size and the camera positions are valid.
verify_grid_and_cell_size();
verify_camera();
//While the user hasn't quit
while(1){
//While there's an event to handle
while( SDL_PollEvent( &event ) ){
//If the user has Xed out the window
if( event.type == SDL_QUIT || quit == true ){
//Quit the program
clean_up();
return 0;
}
if( event.type == SDL_MOUSEBUTTONDOWN ){ /// mouse down
x = event.motion.x;
y = event.motion.y;
if( event.button.button == SDL_BUTTON_LEFT ){
mouseStatusLeft = 1;
}
else if( event.button.button == SDL_BUTTON_RIGHT ){
mouseStatusRight = 1;
}
}
else if(event.type == SDL_MOUSEWHEEL){
if(event.wheel.y > 0)
zoom_in(x,y);
if(event.wheel.y < 0)
zoom_out(x,y);
}
else if(event.type == SDL_MOUSEBUTTONUP){ /// mouse up
x = event.motion.x;
y = event.motion.y;
if( event.button.button == SDL_BUTTON_LEFT ){
mouseStatusLeft = 0;
}
else if( event.button.button == SDL_BUTTON_RIGHT ){
mouseStatusRight = 0;
}
}
else if( event.type == SDL_MOUSEMOTION ){ /// mouse motion
x = event.motion.x;
y = event.motion.y;
// if the alt key (camera panning key) is down and the coordinates have changed, then let the screen be panned!
if(alt && x != mouse_x_when_pan && y != mouse_y_when_pan){
// this adjusts the x-axis camera (this scales with the CELL_SIZE)
camera_x += (x-mouse_x_when_pan+remainder_panning_motion_x)/CELL_SIZE;
camera_y += (y-mouse_y_when_pan+remainder_panning_motion_y)/CELL_SIZE;
//calculate the remainders of the mouse motion.
// these values represent the motion of the mouse that is not utilized by the discrete nature of the operation on the camera_x and camera_y values.
remainder_panning_motion_x = (x-mouse_x_when_pan+remainder_panning_motion_x) - (int)((x-mouse_x_when_pan+remainder_panning_motion_x)/CELL_SIZE)*CELL_SIZE;
remainder_panning_motion_y = (y-mouse_y_when_pan+remainder_panning_motion_y) - (int)((y-mouse_y_when_pan+remainder_panning_motion_y)/CELL_SIZE)*CELL_SIZE;
// make sure the camera is not out of bounds.
verify_camera();
//reset the user's curcor position to the original position the curcor was in when the user started panning the camera
SDL_WarpMouseInWindow(window, mouse_x_when_pan, mouse_y_when_pan);
}
}
else if(event.type == SDL_WINDOWEVENT_RESIZED ){ /// window resize
//float new_cell_size = CELL_SIZE * event.resize.h/((float)SCREEN_HEIGHT); // adjust the pixel size.
float new_cell_size = CELL_SIZE * event.window.data1/((float)SCREEN_HEIGHT); // adjust the pixel size.
if(new_cell_size - ((int)new_cell_size) >= 0.5f) CELL_SIZE = new_cell_size + 1;
else CELL_SIZE = new_cell_size;
//SCREEN_WIDTH = event.resize.w;
//SCREEN_HEIGHT = event.resize.h;
SCREEN_WIDTH = event.window.data1;
SCREEN_HEIGHT = event.window.data2;
verify_grid_and_cell_size(); // make sure the window isn't too big for the cell size
//set_window_size(event.resize.w, event.resize.h);
set_window_size(event.window.data1, event.window.data2);
verify_camera();
}
if( event.type == SDL_KEYDOWN ){ ///keyboard event
switch( event.key.keysym.sym ){
case SDLK_UP: break; //change block type up
case SDLK_DOWN: break; // change block type down
case SDLK_c: reset_cells(); break;//clear the screen
case SDLK_p: print_saturation_data(); break; // prints the cellSat[][] array to stdout. this is for debuggin purposes.
case SDLK_r: randomize_grid(); break; // randomize grid
case SDLK_LEFT: if(paused != 1) {sleepTime /= 2;} break; //speeds up the game
case SDLK_RIGHT: if(paused != 1) {if(sleepTime == 0){sleepTime = 1;} {sleepTime *= 2;} if(sleepTime > 2000) {sleepTime = 2000;}} break; //slows down the game
case SDLK_SPACE: if(paused == 0) {paused = 1;} else if(paused == 1) {paused = 0;} break; //pause the game
case SDLK_ESCAPE: quit = true; // quit with escape
case SDLK_w: gen_world(w_normal,0); break; // generate a world
/*
case SDLK_w: keyw=1; break; // store key state
case SDLK_a: keya=1; break;
case SDLK_s: keys=1; break;
case SDLK_d: keyd=1; break;
*/
case SDLK_LALT:
case SDLK_RALT:
// store the state of the alt key.
alt = 1;
// turn off the cursor
SDL_ShowCursor(SDL_DISABLE);
// store the position of the mouse. this will allow the program to make the cursor stay stationary
mouse_x_when_pan = x;
mouse_y_when_pan = y;
//reset the remainder mouse motion variables for x and y.
remainder_panning_motion_x = 0;
remainder_panning_motion_y = 0;
break;
default: break;
}
}
if( event.type == SDL_KEYUP ){ ///keyboard event
switch( event.key.keysym.sym ){
/*
case SDLK_w: keyw=0; break;//lastPanTime=0; break; // store key state
case SDLK_a: keya=0; break;//lastPanTime=0; break;
case SDLK_s: keys=0; break;//lastPanTime=0; break;
case SDLK_d: keyd=0; break;//lastPanTime=0; break;
*/
case SDLK_LALT:
case SDLK_RALT:
// show the cursor again.
SDL_ShowCursor(SDL_ENABLE);
alt = 0;
break;
default: break;
}
}
} // end while(event)
//no more events to handle at the moment.
/*
//this handles time-controlled panning
if(SDL_GetTicks() - MIN_PAN_INTERVAL > lastPanTime){
if(keyw) pan(D_UP);
if(keya) pan(D_LEFT);
if(keys) pan(D_DOWN);
if(keyd) pan(D_RIGHT);
lastPanTime = SDL_GetTicks();
//#if (DEBUG_GRIDSIM)
// printf("\nlastPanTime = %d\n", lastPanTime);
//#endif
}
*/
//checks if the mouse is held or not
if(mouseStatusLeft == 1 && mouseModifier == 0){
//make sure the mouse isn't inside either of the two GUIs.
if(y >= 50 && x < SCREEN_WIDTH - 200)
setcell(x, y, currentMat);
}
else if(mouseStatusRight == 1 && mouseModifier == 0){
deletecell(x, y, currentMat);
}
//speed of gameplay
countVar++;
if(sleepTime <= 0)
{
sleepTime = 0;
}
//evealuate cells
if(countVar >= sleepTime && paused != 1){
evaluate_grid();
countVar = 0;
}
//updates screen with cells
print_cells();
//displays selection gui
selectionGUI(x, y, mouseStatusLeft);
//displays brushes and misc gui
brushesGUI(x, y, mouseStatusLeft);
// If the user is not panning, then it is fine to show the cursor.
if(!alt){
//displays cursor
cursorDisplay(x, y);
}
//draw_line(screen, 300, 300, x, y, 1, mats[currentMat].color); // test the line drawing function
//updates the screen
//SDL_Flip( screen );
//SDL_RenderPresent( screen );
SDL_UpdateWindowSurface(window);
}// end while(quit == false)
//Free the surface and quit SDL
clean_up();
return 0;
}
int main(int argc, char **argv)
{
FILE *input;
FILE *repeats = 0;
FILE *output;
int start_x, end_x, start_y, end_y;
debug_config(progname);
get_options(argc, argv, progname);
unsigned long start_mem, cand_mem, table_mem;
input = fopen(sequence_filename, "r");
if(!input) fatal("couldn't open %s: %s\n",sequence_filename,strerror(errno));
if(repeat_filename) {
repeats = fopen(repeat_filename, "r");
if(!repeats) fatal("couldn't open %s: %s\n",repeat_filename,strerror(errno));
}
if(output_filename) {
output = fopen(output_filename, "w");
} else {
output = stdout;
}
// Data is in the form:
// >id metadata
// data
// >id metadata
// data
// >>
// ...
set_k(kmer_size);
set_window_size(window_size);
// If we only give one file, do an all vs. all
// on them.
if(!second_sequence_filename) {
num_seqs = load_seqs(input);
start_x = 0;
end_x = num_seqs;
start_y = 0;
end_y = num_seqs;
}
// If we had two files, do not compare ones from
// the same file to each other.
else {
FILE *input2 = fopen(second_sequence_filename, "r");
if(!input2) {
fprintf(stderr, "Could not open file %s for reading.\n", second_sequence_filename);
exit(1);
}
num_seqs = load_seqs_two_files(input, &end_x, input2, &end_y);
start_x = 0;
start_y = end_x;
debug(D_DEBUG,"First file contains %d sequences, stored from (%d,%d].\n", end_x, start_x, end_x);
debug(D_DEBUG,"Second file contains %d sequences, stored from (%d,%d].\n", end_y-end_x, start_y, end_y);
}
fclose(input);
debug(D_DEBUG,"Loaded %d sequences\n",num_seqs);
init_cand_table(num_seqs * 5);
init_mer_table(num_seqs * 5);
if(repeats) {
int repeat_count = init_repeat_mer_table(repeats, 2000000, 0);
fclose(repeats);
debug(D_DEBUG,"Loaded %d repeated mers\n", repeat_count);
}
if(rectangle_size == -1) {
// Do get_mem_avail*0.95 to leave some memory for overhead
rectangle_size = DYNAMIC_RECTANGLE_SIZE(max_mem_kb);
debug(D_DEBUG,"Mem avail: %lu, rectangle size: %d\n",(unsigned long)MEMORY_FOR_MERS(max_mem_kb), rectangle_size);
}
int curr_start_x = start_x;
int curr_start_y = start_y;
candidate_t *output_list = 0;
int num_in_list;
while(curr_start_y < end_y) {
while(curr_start_x < end_x) {
if(start_x == start_y) {
debug(D_DEBUG,"Loading mer table (%d,%d)\n", curr_rect_x, curr_rect_y);
} else {
debug(D_DEBUG,"Loading mer table for [%d,%d) and [%d,%d)\n",curr_start_x, MIN(curr_start_x + rectangle_size, end_x), curr_start_y, MIN(curr_start_y + rectangle_size, end_y));
}
start_mem = get_mem_usage();
load_mer_table_subset(curr_start_x, MIN(curr_start_x + rectangle_size, end_x), curr_start_y, MIN(curr_start_y + rectangle_size, end_y), (curr_start_x == curr_start_y));
table_mem = get_mem_usage();
debug(D_DEBUG,"Finished loading, now generating candidates\n");
debug(D_DEBUG,"Memory used: %lu\n", table_mem - start_mem);
generate_candidates();
cand_mem = get_mem_usage();
debug(D_DEBUG,"Total candidates generated: %llu\n", (long long unsigned int) total_cand);
debug(D_DEBUG,"Candidate memory used: %lu\n", cand_mem - table_mem);
output_list = retrieve_candidates(&num_in_list);
output_candidate_list(output, output_list, num_in_list);
free(output_list);
fflush(output);
debug(D_DEBUG,"Now freeing\n");
free_cand_table();
free_mer_table();
debug(D_DEBUG,"Successfully output and freed!\n");
curr_rect_x++;
curr_start_x += rectangle_size;
}
curr_rect_y++;
curr_start_y += rectangle_size;
curr_rect_x = curr_rect_y;
if(start_y == 0) {
curr_start_x = curr_start_y;
} else {
curr_start_x = start_x;
}
}
fclose(output);
return 0;
}
// internal initialization. performed when run is invoked
void Raspi_App::init()
{
gettimeofday(&m_startTime, NULL);
esInitContext(m_context.get());
esCreateWindow(m_context.get(), name().c_str(),
ES_WINDOW_RGB | ES_WINDOW_ALPHA | ES_WINDOW_DEPTH /*| ES_WINDOW_MULTISAMPLE*/);
// set graphical log stream
Logger::get()->add_outstream(&m_outstream_gl);
// version
LOG_INFO<<"OpenGL: " << glGetString(GL_VERSION);
LOG_INFO<<"GLSL: " << glGetString(GL_SHADING_LANGUAGE_VERSION);
set_window_size(gl::vec2(m_context->width, m_context->height));
LOG_INFO<<"Context: " << gl::window_dimension().x << " x " << gl::window_dimension().y;
// file search paths
if(!args().empty()){ fs::add_search_path(fs::get_directory_part(args().front())); }
// fs::add_search_path("./");
fs::add_search_path("./res");
fs::add_search_path("/usr/local/share/fonts");
get_input_file_descriptors(&m_mouse_fd, &m_keyboard_fd, &m_touch_fd);
m_timer_device_scan = Timer(background_queue().io_service(), [this]()
{
int mouse_fd = m_mouse_fd, keyboard_fd = m_keyboard_fd;
int *mp = nullptr, *kp = nullptr;
bool has_changed = false;
// check for keyboard and mouse being added/removed
auto mouse_handler = find_mouse_handler();
auto kb_handler = find_keyboard_handler();
if((!m_keyboard_fd && !kb_handler.empty()) ||
(m_keyboard_fd && kb_handler.empty()))
{
keyboard_fd = 0;
kp = &keyboard_fd;
has_changed = true;
}
if((!m_mouse_fd && !mouse_handler.empty()) ||
(m_mouse_fd && mouse_handler.empty()))
{
mouse_fd = 0;
mp = &mouse_fd;
has_changed = true;
}
if(!has_changed){ return; }
get_input_file_descriptors(mp, kp, nullptr);
main_queue().submit([this, mouse_fd, keyboard_fd]
{
if(mouse_fd && !m_mouse_fd)
{
LOG_TRACE << "mouse connected";
m_mouse_fd = mouse_fd;
}
else if(!mouse_fd && m_mouse_fd)
{
LOG_TRACE << "mouse disconnected";
close(m_mouse_fd); m_mouse_fd = 0;
}
if(keyboard_fd && !m_keyboard_fd)
{
LOG_TRACE << "keyboard connected";
m_keyboard_fd = keyboard_fd;
}
else if(!keyboard_fd && m_keyboard_fd)
{
LOG_TRACE << "keyboard disconnected";
close(m_keyboard_fd); m_keyboard_fd = 0;
}
});
});
m_timer_device_scan.set_periodic();
m_timer_device_scan.expires_from_now(5.0);
// make sure touchscreen backlight stays on
// TODO: use timer here
// set_lcd_backlight(true);
// center cursor
current_mouse_pos = gl::window_dimension() / 2.f;
// user setup hook
setup();
}
int tty_ioctl(struct inode * inode, struct file * file,
unsigned int cmd, unsigned int arg)
{
struct tty_struct * tty;
struct tty_struct * other_tty;
int pgrp;
int dev;
if (MAJOR(file->f_rdev) != 4) {
printk("tty_ioctl: tty pseudo-major != 4\n");
return -EINVAL;
}
dev = MINOR(file->f_rdev);
tty = TTY_TABLE(dev);
if (!tty)
return -EINVAL;
if (IS_A_PTY(dev))
other_tty = tty_table[PTY_OTHER(dev)];
else
other_tty = NULL;
switch (cmd) {
case TCGETS:
return get_termios(tty,(struct termios *) arg);
case TCSETSF:
flush_input(tty);
/* fallthrough */
case TCSETSW:
wait_until_sent(tty);
/* fallthrough */
case TCSETS:
return set_termios(tty,(struct termios *) arg, dev);
case TCGETA:
return get_termio(tty,(struct termio *) arg);
case TCSETAF:
flush_input(tty);
/* fallthrough */
case TCSETAW:
wait_until_sent(tty); /* fallthrough */
case TCSETA:
return set_termio(tty,(struct termio *) arg, dev);
case TCXONC:
switch (arg) {
case TCOOFF:
tty->stopped = 1;
TTY_WRITE_FLUSH(tty);
return 0;
case TCOON:
tty->stopped = 0;
TTY_WRITE_FLUSH(tty);
return 0;
case TCIOFF:
if (STOP_CHAR(tty))
put_tty_queue(STOP_CHAR(tty),
&tty->write_q);
return 0;
case TCION:
if (START_CHAR(tty))
put_tty_queue(START_CHAR(tty),
&tty->write_q);
return 0;
}
return -EINVAL; /* not implemented */
case TCFLSH:
if (arg==0)
flush_input(tty);
else if (arg==1)
flush_output(tty);
else if (arg==2) {
flush_input(tty);
flush_output(tty);
} else
return -EINVAL;
return 0;
case TIOCEXCL:
return -EINVAL; /* not implemented */
case TIOCNXCL:
return -EINVAL; /* not implemented */
case TIOCSCTTY:
return -EINVAL; /* set controlling term NI */
case TIOCGPGRP:
verify_area((void *) arg,4);
put_fs_long(tty->pgrp,(unsigned long *) arg);
return 0;
case TIOCSPGRP:
if ((current->tty < 0) ||
(current->tty != dev) ||
(tty->session != current->session))
return -ENOTTY;
pgrp=get_fs_long((unsigned long *) arg);
if (pgrp < 0)
return -EINVAL;
if (session_of_pgrp(pgrp) != current->session)
return -EPERM;
tty->pgrp = pgrp;
return 0;
case TIOCOUTQ:
verify_area((void *) arg,4);
put_fs_long(CHARS(&tty->write_q),
(unsigned long *) arg);
return 0;
case TIOCINQ:
verify_area((void *) arg,4);
if (L_CANON(tty) && !tty->secondary.data)
put_fs_long(0, (unsigned long *) arg);
else
put_fs_long(CHARS(&tty->secondary),
(unsigned long *) arg);
return 0;
case TIOCSTI:
return -EINVAL; /* not implemented */
case TIOCGWINSZ:
return get_window_size(tty,(struct winsize *) arg);
case TIOCSWINSZ:
if (IS_A_PTY_MASTER(dev))
set_window_size(other_tty,(struct winsize *) arg);
return set_window_size(tty,(struct winsize *) arg);
case TIOCGSOFTCAR:
return -EINVAL; /* not implemented */
case TIOCSSOFTCAR:
return -EINVAL; /* not implemented */
case TIOCLINUX:
switch (get_fs_byte((char *)arg))
{
case 0:
return do_screendump(arg);
case 1:
return do_get_ps_info(arg);
default:
return -EINVAL;
}
case TIOCCONS:
if (!IS_A_PTY(dev))
return -EINVAL;
if (redirect)
return -EBUSY;
if (!suser())
return -EPERM;
if (IS_A_PTY_MASTER(dev))
redirect = other_tty;
else
redirect = tty;
return 0;
case FIONBIO:
if (arg)
file->f_flags |= O_NONBLOCK;
else
file->f_flags &= ~O_NONBLOCK;
return 0;
case TIOCNOTTY:
if (MINOR(file->f_rdev) != current->tty)
return -EINVAL;
current->tty = -1;
if (current->leader) {
if (tty->pgrp > 0)
kill_pg(tty->pgrp, SIGHUP, 0);
tty->pgrp = -1;
tty->session = 0;
}
return 0;
case TIOCPKT:
{
int on;
if (!IS_A_PTY_MASTER(dev))
return (-EINVAL);
verify_area ((unsigned long *)arg, sizeof (int));
on=get_fs_long ((unsigned long *)arg);
if (on )
tty->packet = 1;
else
tty->packet = 0;
return (0);
}
default:
if (tty->ioctl)
return (tty->ioctl)(tty, file, cmd, arg);
else
return -EINVAL;
}
}
int tty_ioctl(int dev, int cmd, int arg)
{
struct tty_struct * tty;
struct tty_struct * other_tty;
int pgrp;
if (MAJOR(dev) == 5) {
dev = current->tty;
if (dev<0)
return -EINVAL;
} else
dev=MINOR(dev);
tty = tty_table + (dev ? ((dev < 64)? dev-1:dev) : fg_console);
if (IS_A_PTY(dev))
other_tty = tty_table + PTY_OTHER(dev);
else
other_tty = NULL;
if (!(tty->write_q && tty->read_q && tty->secondary && tty->write))
return -EINVAL;
switch (cmd) {
case TCGETS:
return get_termios(tty,(struct termios *) arg);
case TCSETSF:
flush(tty->read_q);
flush(tty->secondary);
if (other_tty)
flush(other_tty->write_q);
/* fallthrough */
case TCSETSW:
wait_until_sent(tty);
/* fallthrough */
case TCSETS:
return set_termios(tty,(struct termios *) arg, dev);
case TCGETA:
return get_termio(tty,(struct termio *) arg);
case TCSETAF:
flush(tty->read_q);
flush(tty->secondary);
if (other_tty)
flush(other_tty->write_q);
/* fallthrough */
case TCSETAW:
wait_until_sent(tty); /* fallthrough */
case TCSETA:
return set_termio(tty,(struct termio *) arg, dev);
case TCSBRK:
if (!arg) {
wait_until_sent(tty);
send_break(tty);
}
return 0;
case TCXONC:
switch (arg) {
case TCOOFF:
tty->stopped = 1;
tty->write(tty);
return 0;
case TCOON:
tty->stopped = 0;
tty->write(tty);
return 0;
case TCIOFF:
if (STOP_CHAR(tty))
PUTCH(STOP_CHAR(tty),tty->write_q);
return 0;
case TCION:
if (START_CHAR(tty))
PUTCH(START_CHAR(tty),tty->write_q);
return 0;
}
return -EINVAL; /* not implemented */
case TCFLSH:
if (arg==0) {
flush(tty->read_q);
flush(tty->secondary);
if (other_tty)
flush(other_tty->write_q);
} else if (arg==1)
flush(tty->write_q);
else if (arg==2) {
flush(tty->read_q);
flush(tty->secondary);
flush(tty->write_q);
if (other_tty)
flush(other_tty->write_q);
} else
return -EINVAL;
return 0;
case TIOCEXCL:
return -EINVAL; /* not implemented */
case TIOCNXCL:
return -EINVAL; /* not implemented */
case TIOCSCTTY:
return -EINVAL; /* set controlling term NI */
case TIOCGPGRP:
verify_area((void *) arg,4);
put_fs_long(tty->pgrp,(unsigned long *) arg);
return 0;
case TIOCSPGRP:
if ((current->tty < 0) ||
(current->tty != dev) ||
(tty->session != current->session))
return -ENOTTY;
pgrp=get_fs_long((unsigned long *) arg);
if (pgrp < 0)
return -EINVAL;
if (session_of_pgrp(pgrp) != current->session)
return -EPERM;
tty->pgrp = pgrp;
return 0;
case TIOCOUTQ:
verify_area((void *) arg,4);
put_fs_long(CHARS(tty->write_q),(unsigned long *) arg);
return 0;
case TIOCINQ:
verify_area((void *) arg,4);
put_fs_long(CHARS(tty->secondary),
(unsigned long *) arg);
return 0;
case TIOCSTI:
return -EINVAL; /* not implemented */
case TIOCGWINSZ:
return get_window_size(tty,(struct winsize *) arg);
case TIOCSWINSZ:
if (other_tty)
set_window_size(other_tty,(struct winsize *) arg);
return set_window_size(tty,(struct winsize *) arg);
case TIOCMGET:
return -EINVAL; /* not implemented */
case TIOCMBIS:
return -EINVAL; /* not implemented */
case TIOCMBIC:
return -EINVAL; /* not implemented */
case TIOCMSET:
return -EINVAL; /* not implemented */
case TIOCGSOFTCAR:
return -EINVAL; /* not implemented */
case TIOCSSOFTCAR:
return -EINVAL; /* not implemented */
case TIOCLINUX:
switch (get_fs_byte((char *)arg))
{
case 0:
return do_screendump(arg);
case 1:
return do_get_ps_info(arg);
default:
return -EINVAL;
}
default:
return -EINVAL;
}
}
