void
kbd_hit(char key) {
set_active();
switch (key) {
case 'd':
dump_screen(0);
break;
case 'w':
case 'W':
save_image();
break;
case 'q':
case 'Q':
case 'x':
case 'X': /* exit the program */
end_display();
exit(0);
case 'v':
show_video_settings = !show_video_settings;
refresh_screen = 1;
break;
case 'h':
set_hue(get_hue() - 1);
refresh_screen = 1;
break;
case 'H':
set_hue(get_hue() + 1);
refresh_screen = 1;
break;
case 's':
set_saturation(get_saturation() - 1);
refresh_screen = 1;
break;
case 'S':
set_saturation(get_saturation() + 1);
refresh_screen = 1;
break;
case 'b':
set_brightness(get_brightness() - 1);
refresh_screen = 1;
break;
case 'B':
set_brightness(get_brightness() + 1);
refresh_screen = 1;
break;
case 'c':
set_contrast(get_contrast() - 1);
refresh_screen = 1;
break;
case 'C':
set_contrast(get_contrast() + 1);
refresh_screen = 1;
break;
}
}
static int dump_screens(FILE* out, screen_t** s, int nbs)
{
int i;
if (nbs == 0)
return 0;
for(i=0; i < nbs; i++)
if (dump_screen(out, s[i]) < 0)
return -1;
return 0;
}
void
kbd_hit(char key) {
char buf[100];
switch (key) {
case 'a':
abort();
case 'd':
dump_screen(0);
break;
case 'q':
case 'Q':
case 'x':
case 'X': /* exit the program */
end_display();
exit(0);
}
}
/** Screenshot of the HTML map. */
int
dump_screenshot(void)
{
char screenshot[BUFSZ];
char *filename = get_dump_filename();
Sprintf(screenshot, "%s_screenshot_%ld_t%ld.html", filename, (long)u.ubirthday, moves);
if (filename) free(filename);
html_dump_fp = fopen(screenshot, "w");
if (!html_dump_fp) {
pline("Can't open %s for output.", screenshot);
pline("Screenshot file not created.");
}
dump_header_html("Screenshot");
dump_screen();
dump_exit();
return 0;
}
const char *
begin_dump(int how)
{
const char *timestamp, *dumpname, *status, *rolename;
time_t t;
struct tm *tmp;
/* back up the window procs */
winprocs_original = windowprocs;
/* Make a timestamp like "2011-11-30 18:45:00". This now uses UTC time, in
accordance with the timebase rules (in particular, we never look at the
system timezone). This also avoids clashes when there are two games an
hour apart and DST changed in between. (It doesn't help when there are
two games in the same second, but that only happens as a result of
extreme startscumming.) */
t = (time_t)(utc_time() / 1000000LL);
tmp = gmtime(&t);
if (tmp)
timestamp = msgstrftime(TIMESTAMP_FORMAT, tmp);
else
timestamp = "unknown time"; /* previously "???" but that's illegal
on many filesystems */
switch (how) {
case ASCENDED:
status = "ascended";
break;
case QUIT:
status = "quit";
break;
case ESCAPED:
status = "escaped";
break;
default:
status = "died";
break;
}
dumpname = msgprintf("%s, %s-%s-%s-%s-%s, %s.txt",
timestamp, u.uplname, urole.filecode, urace.filecode,
genders[u.ufemale].filecode,
aligns[1 - u.ualign.type].filecode, status);
dumpfp = fopen_datafile(dumpname, "w+", DUMPPREFIX);
if (!dumpfp)
return NULL;
#ifdef UNIX
fchmod(fileno(dumpfp), 0644);
#endif
rolename = (u.ufemale && urole.name.f) ? urole.name.f : urole.name.m;
fprintf(dumpfp, "%s, %s %s %s %s\n", u.uplname,
aligns[1 - u.ualign.type].adj, genders[u.ufemale].adj,
urace.adj, rolename);
dump_screen(dumpfp);
dump_status();
return dumpname;
}
int
main(int argc, char **argv)
{
char *font, *type;
int opt;
if (argc == 1)
usage();
init();
info.size = sizeof(info);
if (ioctl(0, CONS_GETINFO, &info) == -1)
err(1, "must be on a virtual console");
while((opt = getopt(argc, argv, "b:Cc:df:g:h:i:l:LM:m:pPr:S:s:t:x")) != -1) {
switch(opt) {
case 'b':
set_border_color(optarg);
break;
case 'C':
clear_history();
break;
case 'c':
set_cursor_type(optarg);
break;
case 'd':
print_scrnmap();
break;
case 'f':
type = optarg;
font = nextarg(argc, argv, &optind, 'f', 0);
if (font == NULL) {
type = NULL;
font = optarg;
}
load_font(type, font);
break;
case 'g':
if (sscanf(optarg, "%dx%d",
&vesa_cols, &vesa_rows) != 2) {
revert();
warnx("incorrect geometry: %s", optarg);
usage();
}
break;
case 'h':
set_history(optarg);
break;
case 'i':
show_info(optarg);
break;
case 'l':
load_scrnmap(optarg);
break;
case 'L':
load_default_scrnmap();
break;
case 'M':
set_mouse_char(optarg);
break;
case 'm':
set_mouse(optarg);
break;
case 'p':
dump_screen(DUMP_RAW);
break;
case 'P':
dump_screen(DUMP_TXT);
break;
case 'r':
get_reverse_colors(argc, argv, &optind);
break;
case 'S':
set_lockswitch(optarg);
break;
case 's':
set_console(optarg);
break;
case 't':
set_screensaver_timeout(optarg);
break;
case 'x':
hex = 1;
break;
default:
usage();
}
}
if (optind < argc && !strcmp(argv[optind], "show")) {
test_frame();
optind++;
}
video_mode(argc, argv, &optind);
get_normal_colors(argc, argv, &optind);
if (colors_changed || video_mode_changed) {
if (!(new_mode_info.vi_flags & V_INFO_GRAPHICS)) {
if ((normal_back_color < 8) && (revers_back_color < 8)) {
set_colors();
} else {
revert();
errx(1, "bg color for text modes must be < 8");
}
} else {
set_colors();
}
}
if ((optind != argc) || (argc == 1))
usage();
return 0;
}
static bool process_event(union event *ev)
{
struct buffered_status *status = store_status();
bool rval = true;
switch(ev->type)
{
case EVENT_BUTTON_DOWN:
{
Uint32 button = map_button(ev->button.pad, ev->button.button);
rval = false;
if((ev->button.pad == 0) && pointing)
{
Uint32 mousebutton;
switch(ev->button.button)
{
case WPAD_BUTTON_A: mousebutton = MOUSE_BUTTON_LEFT; break;
case WPAD_BUTTON_B: mousebutton = MOUSE_BUTTON_RIGHT; break;
default: mousebutton = 0; break;
}
if(mousebutton)
{
status->mouse_button = mousebutton;
status->mouse_repeat = mousebutton;
status->mouse_button_state |= MOUSE_BUTTON(mousebutton);
status->mouse_repeat_state = 1;
status->mouse_drag_state = -1;
status->mouse_time = get_ticks();
button = 256;
rval = true;
}
}
if((button < 256))
{
enum keycode skey = input.joystick_button_map[ev->button.pad][button];
if(skey && (status->keymap[skey] == 0))
{
key_press(status, skey, skey);
rval = true;
}
}
else
{
if((ev->button.pad < 4) && ((ev->button.button == WPAD_BUTTON_HOME) ||
((ext_type[ev->button.pad] == WPAD_EXP_CLASSIC) &&
(ev->button.button == WPAD_CLASSIC_BUTTON_HOME))))
{
status->keymap[IKEY_ESCAPE] = 1;
status->key = IKEY_ESCAPE;
status->keypress_time = get_ticks();
rval = true;
break;
}
}
break;
}
case EVENT_BUTTON_UP:
{
Uint32 button = map_button(ev->button.pad, ev->button.button);
rval = false;
if((ev->button.pad == 0) && status->mouse_button_state)
{
Uint32 mousebutton;
switch(ev->button.button)
{
case WPAD_BUTTON_A: mousebutton = MOUSE_BUTTON_LEFT; break;
case WPAD_BUTTON_B: mousebutton = MOUSE_BUTTON_RIGHT; break;
default: mousebutton = 0; break;
}
if(mousebutton &&
(status->mouse_button_state & MOUSE_BUTTON(mousebutton)))
{
status->mouse_button_state &= ~MOUSE_BUTTON(mousebutton);
status->mouse_repeat = 0;
status->mouse_drag_state = 0;
status->mouse_repeat_state = 0;
button = 256;
rval = true;
}
}
if((button < 256))
{
enum keycode skey = input.joystick_button_map[ev->button.pad][button];
if(skey)
{
key_release(status, skey);
rval = true;
}
}
break;
}
case EVENT_AXIS_MOVE:
{
int digital_value = -1;
int axis = ev->axis.axis;
int last_axis;
enum keycode skey;
if(ev->axis.pad < 4)
{
switch(ext_type[ev->axis.pad])
{
case WPAD_EXP_NUNCHUK: break;
case WPAD_EXP_CLASSIC: axis += 2; break;
case WPAD_EXP_GUITARHERO3: axis += 6; break;
default: axis = 256; break; // Not supposed to happen
}
}
if(axis == 256) break;
last_axis = status->axis[ev->axis.pad][axis];
if(ev->axis.pos > 10000)
digital_value = 1;
else if(ev->axis.pos < -10000)
digital_value = 0;
if(digital_value != -1)
{
skey = input.joystick_axis_map[ev->axis.pad][axis][digital_value];
if(skey)
{
if(status->keymap[skey] == 0)
key_press(status, skey, skey);
if(last_axis == (digital_value ^ 1))
{
skey = input.joystick_axis_map[ev->axis.pad][axis][last_axis];
key_release(status, skey);
}
}
}
else
{
if(last_axis != -1)
{
skey = input.joystick_axis_map[ev->axis.pad][axis][last_axis];
if(skey)
key_release(status, skey);
}
}
status->axis[ev->axis.pad][axis] = digital_value;
break;
}
case EVENT_CHANGE_EXT:
{
ext_type[ev->ext.pad] = ev->ext.ext;
break;
}
case EVENT_POINTER_MOVE:
{
pointing = 1;
status->mouse_moved = true;
status->real_mouse_x = ev->pointer.x;
status->real_mouse_y = ev->pointer.y;
status->mouse_x = ev->pointer.x / 8;
status->mouse_y = ev->pointer.y / 14;
break;
}
case EVENT_POINTER_OUT:
{
pointing = 0;
break;
}
case EVENT_KEY_DOWN:
{
enum keycode ckey = convert_USB_internal(ev->key.key);
if(!ckey)
{
if(ev->key.unicode)
ckey = IKEY_UNICODE;
else
{
rval = false;
break;
}
}
if((ckey == IKEY_RETURN) &&
get_alt_status(keycode_internal) &&
get_ctrl_status(keycode_internal))
{
toggle_fullscreen();
break;
}
if(ckey == IKEY_F12)
{
dump_screen();
break;
}
if(status->key_repeat &&
(status->key_repeat != IKEY_LSHIFT) &&
(status->key_repeat != IKEY_RSHIFT) &&
(status->key_repeat != IKEY_LALT) &&
(status->key_repeat != IKEY_RALT) &&
(status->key_repeat != IKEY_LCTRL) &&
(status->key_repeat != IKEY_RCTRL))
{
// Stack current repeat key if it isn't shift, alt, or ctrl
if(input.repeat_stack_pointer != KEY_REPEAT_STACK_SIZE)
{
input.key_repeat_stack[input.repeat_stack_pointer] =
status->key_repeat;
input.unicode_repeat_stack[input.repeat_stack_pointer] =
status->unicode_repeat;
input.repeat_stack_pointer++;
}
}
key_press(status, ckey, ev->key.unicode);
break;
}
case EVENT_KEY_UP:
{
enum keycode ckey = convert_USB_internal(ev->key.key);
if(!ckey)
{
if(status->keymap[IKEY_UNICODE])
ckey = IKEY_UNICODE;
else
{
rval = false;
break;
}
}
status->keymap[ckey] = 0;
if(status->key_repeat == ckey)
{
status->key_repeat = IKEY_UNKNOWN;
status->unicode_repeat = 0;
}
status->key_release = ckey;
break;
}
case EVENT_KEY_LOCKS:
{
status->numlock_status = !!(ev->locks.locks & MOD_NUMLOCK);
status->caps_status = !!(ev->locks.locks & MOD_CAPSLOCK);
break;
}
case EVENT_MOUSE_MOVE:
{
int mx = status->real_mouse_x + ev->mmove.dx;
int my = status->real_mouse_y + ev->mmove.dy;
if(mx < 0)
mx = 0;
if(my < 0)
my = 0;
if(mx >= 640)
mx = 639;
if(my >= 350)
my = 349;
status->real_mouse_x = mx;
status->real_mouse_y = my;
status->mouse_x = mx / 8;
status->mouse_y = my / 14;
status->mouse_moved = true;
break;
}
case EVENT_MOUSE_BUTTON_DOWN:
{
Uint32 button = 0;
switch (ev->mbutton.button)
{
case USB_MOUSE_BTN_LEFT:
button = MOUSE_BUTTON_LEFT;
break;
case USB_MOUSE_BTN_RIGHT:
button = MOUSE_BUTTON_RIGHT;
break;
case USB_MOUSE_BTN_MIDDLE:
button = MOUSE_BUTTON_MIDDLE;
break;
default:
break;
}
if(!button)
break;
status->mouse_button = button;
status->mouse_repeat = button;
status->mouse_button_state |= MOUSE_BUTTON(button);
status->mouse_repeat_state = 1;
status->mouse_drag_state = -1;
status->mouse_time = get_ticks();
break;
}
case EVENT_MOUSE_BUTTON_UP:
{
Uint32 button = 0;
switch (ev->mbutton.button)
{
case USB_MOUSE_BTN_LEFT:
button = MOUSE_BUTTON_LEFT;
break;
case USB_MOUSE_BTN_RIGHT:
button = MOUSE_BUTTON_RIGHT;
break;
case USB_MOUSE_BTN_MIDDLE:
button = MOUSE_BUTTON_MIDDLE;
break;
default:
break;
}
if(!button)
break;
status->mouse_button_state &= ~MOUSE_BUTTON(button);
status->mouse_repeat = 0;
status->mouse_drag_state = 0;
status->mouse_repeat_state = 0;
break;
}
default:
{
rval = false;
break;
}
}
return rval;
}
static bool process_event(SDL_Event *event)
{
struct buffered_status *status = store_status();
enum keycode ckey;
/* SDL's numlock keyboard modifier handling seems to be broken on X11,
* and it will only get numlock's status right on application init. We
* can trust this value once, and then toggle based on user presses of
* the numlock key.
*
* On Windows, KEYDOWN/KEYUP seem to be sent separately, to indicate
* enabling or disabling of numlock. But on X11, both KEYDOWN/KEYUP are
* sent for each toggle, so this must be handled differently.
*
* What a mess!
*/
if(!numlock_status_initialized)
{
status->numlock_status = !!(SDL_GetModState() & KMOD_NUM);
numlock_status_initialized = true;
}
switch(event->type)
{
case SDL_QUIT:
{
// Stuff an escape
status->key = IKEY_ESCAPE;
status->keymap[IKEY_ESCAPE] = 1;
status->keypress_time = get_ticks();
break;
}
#if SDL_VERSION_ATLEAST(2,0,0)
case SDL_WINDOWEVENT:
{
switch(event->window.event)
{
case SDL_WINDOWEVENT_RESIZED:
{
resize_screen(event->window.data1, event->window.data2);
break;
}
case SDL_WINDOWEVENT_FOCUS_LOST:
{
// Pause while minimized
if(input.unfocus_pause)
{
while(1)
{
SDL_WaitEvent(event);
if(event->type == SDL_WINDOWEVENT &&
event->window.event == SDL_WINDOWEVENT_FOCUS_GAINED)
break;
}
}
break;
}
}
break;
}
#else // !SDL_VERSION_ATLEAST(2,0,0)
case SDL_VIDEORESIZE:
{
resize_screen(event->resize.w, event->resize.h);
break;
}
case SDL_ACTIVEEVENT:
{
if(input.unfocus_pause)
{
// Pause while minimized
if(event->active.state & (SDL_APPACTIVE | SDL_APPINPUTFOCUS))
{
// Wait for SDL_APPACTIVE with gain of 1
do
{
SDL_WaitEvent(event);
} while((event->type != SDL_ACTIVEEVENT) ||
(event->active.state & ~(SDL_APPACTIVE | SDL_APPINPUTFOCUS)));
}
}
break;
}
#endif // !SDL_VERSION_ATLEAST(2,0,0)
case SDL_MOUSEMOTION:
{
SDL_Window *window = SDL_GetWindowFromID(sdl_window_id);
int mx_real = event->motion.x;
int my_real = event->motion.y;
int mx, my, min_x, min_y, max_x, max_y;
get_screen_coords(mx_real, my_real, &mx, &my, &min_x,
&min_y, &max_x, &max_y);
if(mx > 639)
SDL_WarpMouseInWindow(window, max_x, my_real);
if(mx < 0)
SDL_WarpMouseInWindow(window, min_x, my_real);
if(my > 349)
SDL_WarpMouseInWindow(window, mx_real, max_y);
if(my < 0)
SDL_WarpMouseInWindow(window, mx_real, min_y);
status->real_mouse_x = mx;
status->real_mouse_y = my;
status->mouse_x = mx / 8;
status->mouse_y = my / 14;
status->mouse_moved = true;
break;
}
case SDL_MOUSEBUTTONDOWN:
{
status->mouse_button = event->button.button;
status->mouse_repeat = event->button.button;
status->mouse_button_state |= SDL_BUTTON(event->button.button);
status->mouse_repeat_state = 1;
status->mouse_drag_state = -1;
status->mouse_time = SDL_GetTicks();
break;
}
case SDL_MOUSEBUTTONUP:
{
status->mouse_button_state &= ~SDL_BUTTON(event->button.button);
status->mouse_repeat = 0;
status->mouse_drag_state = 0;
status->mouse_repeat_state = 0;
break;
}
#if SDL_VERSION_ATLEAST(2,0,0)
// emulate the X11-style "wheel is a button" that SDL 1.2 used
case SDL_MOUSEWHEEL:
{
SDL_Event fake_event;
fake_event.type = SDL_MOUSEBUTTONDOWN;
fake_event.button.windowID = event->wheel.windowID;
fake_event.button.which = event->wheel.which;
fake_event.button.state = SDL_PRESSED;
fake_event.button.x = 0;
fake_event.button.y = 0;
if(event->wheel.y < 0)
fake_event.button.button = MOUSE_BUTTON_WHEELDOWN;
else
fake_event.button.button = MOUSE_BUTTON_WHEELUP;
SDL_PushEvent(&fake_event);
fake_event.type = SDL_MOUSEBUTTONUP;
fake_event.button.state = SDL_RELEASED;
SDL_PushEvent(&fake_event);
break;
}
#endif // SDL_VERSION_ATLEAST(2,0,0)
case SDL_KEYDOWN:
{
Uint16 unicode = 0;
#if SDL_VERSION_ATLEAST(2,0,0)
// FIXME: SDL 2.0 finally implements proper key repeat.
// We should probably use it instead of our hand-rolled stuff.
if(event->key.repeat)
break;
#endif
ckey = convert_SDL_internal(event->key.keysym.sym);
if(!ckey)
{
#if !SDL_VERSION_ATLEAST(2,0,0)
if(!event->key.keysym.unicode)
break;
#endif
ckey = IKEY_UNICODE;
}
#if SDL_VERSION_ATLEAST(2,0,0)
// SDL 2.0 sends the raw key and translated 'text' as separate events.
// There is no longer a UNICODE mode that sends both at once.
// Because of the way the SDL 1.2 assumption is embedded deeply in
// the MZX event queue processor, emulate the 1.2 behaviour by waiting
// for a TEXTINPUT event after a KEYDOWN.
if(SDL_WaitEventTimeout(event, 1))
{
if(event->type == SDL_TEXTINPUT)
unicode = event->text.text[0] | event->text.text[1] << 8;
else
SDL_PushEvent(event);
}
#else
unicode = event->key.keysym.unicode;
#endif
if((ckey == IKEY_RETURN) &&
get_alt_status(keycode_internal) &&
get_ctrl_status(keycode_internal))
{
toggle_fullscreen();
break;
}
if(ckey == IKEY_CAPSLOCK)
{
status->caps_status = true;
}
if(ckey == IKEY_NUMLOCK)
{
#if !SDL_VERSION_ATLEAST(2,0,0) && defined(__WIN32__)
status->numlock_status = true;
#endif
break;
}
if(ckey == IKEY_F12)
{
dump_screen();
break;
}
// Ignore alt + tab
if((ckey == IKEY_TAB) && get_alt_status(keycode_internal))
{
break;
}
if(status->key_repeat &&
(status->key_repeat != IKEY_LSHIFT) &&
(status->key_repeat != IKEY_RSHIFT) &&
(status->key_repeat != IKEY_LALT) &&
(status->key_repeat != IKEY_RALT) &&
(status->key_repeat != IKEY_LCTRL) &&
(status->key_repeat != IKEY_RCTRL))
{
// Stack current repeat key if it isn't shift, alt, or ctrl
if(input.repeat_stack_pointer != KEY_REPEAT_STACK_SIZE)
{
input.key_repeat_stack[input.repeat_stack_pointer] =
status->key_repeat;
input.unicode_repeat_stack[input.repeat_stack_pointer] =
status->unicode_repeat;
input.repeat_stack_pointer++;
}
}
key_press(status, ckey, unicode);
break;
}
case SDL_KEYUP:
{
#if SDL_VERSION_ATLEAST(2,0,0)
// FIXME: SDL 2.0 finally implements proper key repeat.
// We should probably use it instead of our hand-rolled stuff.
if(event->key.repeat)
break;
#endif
ckey = convert_SDL_internal(event->key.keysym.sym);
if(!ckey)
{
#if !SDL_VERSION_ATLEAST(2,0,0)
if(!status->keymap[IKEY_UNICODE])
break;
#endif
ckey = IKEY_UNICODE;
}
if(ckey == IKEY_NUMLOCK)
{
#if !SDL_VERSION_ATLEAST(2,0,0) && defined(__WIN32__)
status->numlock_status = false;
#else
status->numlock_status = !status->numlock_status;
#endif
break;
}
if(ckey == IKEY_CAPSLOCK)
{
status->caps_status = false;
}
status->keymap[ckey] = 0;
if(status->key_repeat == ckey)
{
status->key_repeat = IKEY_UNKNOWN;
status->unicode_repeat = 0;
}
status->key_release = ckey;
break;
}
case SDL_JOYAXISMOTION:
{
int axis_value = event->jaxis.value;
int digital_value = -1;
int which = event->jaxis.which;
int axis = event->jaxis.axis;
Sint8 last_axis = status->axis[which][axis];
enum keycode stuffed_key;
if(axis_value > 10000)
digital_value = 1;
else
if(axis_value < -10000)
digital_value = 0;
if(digital_value != -1)
{
stuffed_key =
input.joystick_axis_map[which][axis][digital_value];
if(stuffed_key)
{
joystick_key_press(status, stuffed_key, stuffed_key);
if(last_axis == (digital_value ^ 1))
{
joystick_key_release(status,
input.joystick_axis_map[which][axis][last_axis]);
}
}
}
else if(last_axis != -1)
{
joystick_key_release(status,
input.joystick_axis_map[which][axis][last_axis]);
}
status->axis[which][axis] = digital_value;
break;
}
case SDL_JOYBUTTONDOWN:
{
int which = event->jbutton.which;
int button = event->jbutton.button;
enum keycode stuffed_key = input.joystick_button_map[which][button];
if(stuffed_key)
joystick_key_press(status, stuffed_key, stuffed_key);
break;
}
case SDL_JOYBUTTONUP:
{
int which = event->jbutton.which;
int button = event->jbutton.button;
enum keycode stuffed_key = input.joystick_button_map[which][button];
if(stuffed_key)
joystick_key_release(status, stuffed_key);
break;
}
case SDL_JOYHATMOTION:
{
int which = event->jhat.which;
int dir = event->jhat.value;
enum keycode key_up = input.joystick_hat_map[which][0];
enum keycode key_down = input.joystick_hat_map[which][1];
enum keycode key_left = input.joystick_hat_map[which][2];
enum keycode key_right = input.joystick_hat_map[which][3];
//if(dir & SDL_HAT_CENTERED)
{
joystick_key_release(status, key_up);
joystick_key_release(status, key_down);
joystick_key_release(status, key_left);
joystick_key_release(status, key_right);
}
if(dir & SDL_HAT_UP)
{
if (key_up)
joystick_key_press(status, key_up, key_up);
}
if(dir & SDL_HAT_DOWN)
{
if (key_down)
joystick_key_press(status, key_down, key_down);
}
if(dir & SDL_HAT_LEFT)
{
if (key_left)
joystick_key_press(status, key_left, key_left);
}
if(dir & SDL_HAT_RIGHT)
{
if (key_right)
joystick_key_press(status, key_right, key_right);
}
break;
}
default:
return false;
}
return true;
}
static void handle_game_key(const SDL_Event &event)
{
SDL_Keycode key = event.key.keysym.sym;
SDL_Scancode sc = event.key.keysym.scancode;
bool changed_screen_mode = false;
bool changed_prefs = false;
if (!game_is_networked && (event.key.keysym.mod & KMOD_CTRL) && CheatsActive) {
int type_of_cheat = process_keyword_key(key);
if (type_of_cheat != NONE)
handle_keyword(type_of_cheat);
}
if (Console::instance()->input_active()) {
switch(key) {
case SDLK_RETURN:
case SDLK_KP_ENTER:
Console::instance()->enter();
break;
case SDLK_ESCAPE:
Console::instance()->abort();
break;
case SDLK_BACKSPACE:
Console::instance()->backspace();
break;
case SDLK_DELETE:
Console::instance()->del();
break;
case SDLK_UP:
Console::instance()->up_arrow();
break;
case SDLK_DOWN:
Console::instance()->down_arrow();
break;
case SDLK_LEFT:
Console::instance()->left_arrow();
break;
case SDLK_RIGHT:
Console::instance()->right_arrow();
break;
case SDLK_HOME:
Console::instance()->line_home();
break;
case SDLK_END:
Console::instance()->line_end();
break;
case SDLK_a:
if (event.key.keysym.mod & KMOD_CTRL)
Console::instance()->line_home();
break;
case SDLK_b:
if (event.key.keysym.mod & KMOD_CTRL)
Console::instance()->left_arrow();
break;
case SDLK_d:
if (event.key.keysym.mod & KMOD_CTRL)
Console::instance()->del();
break;
case SDLK_e:
if (event.key.keysym.mod & KMOD_CTRL)
Console::instance()->line_end();
break;
case SDLK_f:
if (event.key.keysym.mod & KMOD_CTRL)
Console::instance()->right_arrow();
break;
case SDLK_h:
if (event.key.keysym.mod & KMOD_CTRL)
Console::instance()->backspace();
break;
case SDLK_k:
if (event.key.keysym.mod & KMOD_CTRL)
Console::instance()->forward_clear();
break;
case SDLK_n:
if (event.key.keysym.mod & KMOD_CTRL)
Console::instance()->down_arrow();
break;
case SDLK_p:
if (event.key.keysym.mod & KMOD_CTRL)
Console::instance()->up_arrow();
break;
case SDLK_t:
if (event.key.keysym.mod & KMOD_CTRL)
Console::instance()->transpose();
break;
case SDLK_u:
if (event.key.keysym.mod & KMOD_CTRL)
Console::instance()->clear();
break;
case SDLK_w:
if (event.key.keysym.mod & KMOD_CTRL)
Console::instance()->delete_word();
break;
}
}
else
{
if (sc == SDL_SCANCODE_ESCAPE) // (ZZZ) Quit gesture (now safer)
{
if(!player_controlling_game())
do_menu_item_command(mGame, iQuitGame, false);
else {
if(get_ticks_since_local_player_in_terminal() > 1 * TICKS_PER_SECOND) {
if(!game_is_networked) {
do_menu_item_command(mGame, iQuitGame, false);
}
else {
#if defined(__APPLE__) && defined(__MACH__)
screen_printf("If you wish to quit, press Command-Q");
#else
screen_printf("If you wish to quit, press Alt+Q.");
#endif
}
}
}
}
else if (input_preferences->shell_key_bindings[_key_volume_up].count(sc))
{
changed_prefs = SoundManager::instance()->AdjustVolumeUp(Sound_AdjustVolume());
}
else if (input_preferences->shell_key_bindings[_key_volume_down].count(sc))
{
changed_prefs = SoundManager::instance()->AdjustVolumeDown(Sound_AdjustVolume());
}
else if (input_preferences->shell_key_bindings[_key_switch_view].count(sc))
{
walk_player_list();
render_screen(NONE);
}
else if (input_preferences->shell_key_bindings[_key_zoom_in].count(sc))
{
if (zoom_overhead_map_in())
PlayInterfaceButtonSound(Sound_ButtonSuccess());
else
PlayInterfaceButtonSound(Sound_ButtonFailure());
}
else if (input_preferences->shell_key_bindings[_key_zoom_out].count(sc))
{
if (zoom_overhead_map_out())
PlayInterfaceButtonSound(Sound_ButtonSuccess());
else
PlayInterfaceButtonSound(Sound_ButtonFailure());
}
else if (input_preferences->shell_key_bindings[_key_inventory_left].count(sc))
{
if (player_controlling_game()) {
PlayInterfaceButtonSound(Sound_ButtonSuccess());
scroll_inventory(-1);
} else
decrement_replay_speed();
}
else if (input_preferences->shell_key_bindings[_key_inventory_right].count(sc))
{
if (player_controlling_game()) {
PlayInterfaceButtonSound(Sound_ButtonSuccess());
scroll_inventory(1);
} else
increment_replay_speed();
}
else if (input_preferences->shell_key_bindings[_key_toggle_fps].count(sc))
{
PlayInterfaceButtonSound(Sound_ButtonSuccess());
extern bool displaying_fps;
displaying_fps = !displaying_fps;
}
else if (input_preferences->shell_key_bindings[_key_activate_console].count(sc))
{
if (game_is_networked) {
#if !defined(DISABLE_NETWORKING)
Console::instance()->activate_input(InGameChatCallbacks::SendChatMessage, InGameChatCallbacks::prompt());
#endif
PlayInterfaceButtonSound(Sound_ButtonSuccess());
}
else if (Console::instance()->use_lua_console())
{
PlayInterfaceButtonSound(Sound_ButtonSuccess());
Console::instance()->activate_input(ExecuteLuaString, ">");
}
else
{
PlayInterfaceButtonSound(Sound_ButtonFailure());
}
}
else if (input_preferences->shell_key_bindings[_key_show_scores].count(sc))
{
PlayInterfaceButtonSound(Sound_ButtonSuccess());
{
extern bool ShowScores;
ShowScores = !ShowScores;
}
}
else if (sc == SDL_SCANCODE_F1) // Decrease screen size
{
if (!graphics_preferences->screen_mode.hud)
{
PlayInterfaceButtonSound(Sound_ButtonSuccess());
graphics_preferences->screen_mode.hud = true;
changed_screen_mode = changed_prefs = true;
}
else
{
int mode = alephone::Screen::instance()->FindMode(get_screen_mode()->width, get_screen_mode()->height);
if (mode < alephone::Screen::instance()->GetModes().size() - 1)
{
PlayInterfaceButtonSound(Sound_ButtonSuccess());
graphics_preferences->screen_mode.width = alephone::Screen::instance()->ModeWidth(mode + 1);
graphics_preferences->screen_mode.height = alephone::Screen::instance()->ModeHeight(mode + 1);
graphics_preferences->screen_mode.auto_resolution = false;
graphics_preferences->screen_mode.hud = false;
changed_screen_mode = changed_prefs = true;
} else
PlayInterfaceButtonSound(Sound_ButtonFailure());
}
}
else if (sc == SDL_SCANCODE_F2) // Increase screen size
{
if (graphics_preferences->screen_mode.hud)
{
PlayInterfaceButtonSound(Sound_ButtonSuccess());
graphics_preferences->screen_mode.hud = false;
changed_screen_mode = changed_prefs = true;
}
else
{
int mode = alephone::Screen::instance()->FindMode(get_screen_mode()->width, get_screen_mode()->height);
int automode = get_screen_mode()->fullscreen ? 0 : 1;
if (mode > automode)
{
PlayInterfaceButtonSound(Sound_ButtonSuccess());
graphics_preferences->screen_mode.width = alephone::Screen::instance()->ModeWidth(mode - 1);
graphics_preferences->screen_mode.height = alephone::Screen::instance()->ModeHeight(mode - 1);
if ((mode - 1) == automode)
graphics_preferences->screen_mode.auto_resolution = true;
graphics_preferences->screen_mode.hud = true;
changed_screen_mode = changed_prefs = true;
} else
PlayInterfaceButtonSound(Sound_ButtonFailure());
}
}
else if (sc == SDL_SCANCODE_F3) // Resolution toggle
{
if (!OGL_IsActive()) {
PlayInterfaceButtonSound(Sound_ButtonSuccess());
graphics_preferences->screen_mode.high_resolution = !graphics_preferences->screen_mode.high_resolution;
changed_screen_mode = changed_prefs = true;
} else
PlayInterfaceButtonSound(Sound_ButtonFailure());
}
else if (sc == SDL_SCANCODE_F4) // Reset OpenGL textures
{
#ifdef HAVE_OPENGL
if (OGL_IsActive()) {
// Play the button sound in advance to get the full effect of the sound
PlayInterfaceButtonSound(Sound_OGL_Reset());
OGL_ResetTextures();
} else
#endif
PlayInterfaceButtonSound(Sound_ButtonInoperative());
}
else if (sc == SDL_SCANCODE_F5) // Make the chase cam switch sides
{
if (ChaseCam_IsActive())
PlayInterfaceButtonSound(Sound_ButtonSuccess());
else
PlayInterfaceButtonSound(Sound_ButtonInoperative());
ChaseCam_SwitchSides();
}
else if (sc == SDL_SCANCODE_F6) // Toggle the chase cam
{
PlayInterfaceButtonSound(Sound_ButtonSuccess());
ChaseCam_SetActive(!ChaseCam_IsActive());
}
else if (sc == SDL_SCANCODE_F7) // Toggle tunnel vision
{
PlayInterfaceButtonSound(Sound_ButtonSuccess());
SetTunnelVision(!GetTunnelVision());
}
else if (sc == SDL_SCANCODE_F8) // Toggle the crosshairs
{
PlayInterfaceButtonSound(Sound_ButtonSuccess());
player_preferences->crosshairs_active = !player_preferences->crosshairs_active;
Crosshairs_SetActive(player_preferences->crosshairs_active);
changed_prefs = true;
}
else if (sc == SDL_SCANCODE_F9) // Screen dump
{
dump_screen();
}
else if (sc == SDL_SCANCODE_F10) // Toggle the position display
{
PlayInterfaceButtonSound(Sound_ButtonSuccess());
{
extern bool ShowPosition;
ShowPosition = !ShowPosition;
}
}
else if (sc == SDL_SCANCODE_F11) // Decrease gamma level
{
if (graphics_preferences->screen_mode.gamma_level) {
PlayInterfaceButtonSound(Sound_ButtonSuccess());
graphics_preferences->screen_mode.gamma_level--;
change_gamma_level(graphics_preferences->screen_mode.gamma_level);
changed_prefs = true;
} else
PlayInterfaceButtonSound(Sound_ButtonFailure());
}
else if (sc == SDL_SCANCODE_F12) // Increase gamma level
{
if (graphics_preferences->screen_mode.gamma_level < NUMBER_OF_GAMMA_LEVELS - 1) {
PlayInterfaceButtonSound(Sound_ButtonSuccess());
graphics_preferences->screen_mode.gamma_level++;
change_gamma_level(graphics_preferences->screen_mode.gamma_level);
changed_prefs = true;
} else
PlayInterfaceButtonSound(Sound_ButtonFailure());
}
else
{
if (get_game_controller() == _demo)
set_game_state(_close_game);
}
}
if (changed_screen_mode) {
screen_mode_data temp_screen_mode = graphics_preferences->screen_mode;
temp_screen_mode.fullscreen = get_screen_mode()->fullscreen;
change_screen_mode(&temp_screen_mode, true);
render_screen(0);
}
if (changed_prefs)
write_preferences();
}
static void process_game_key(const SDL_Event &event)
{
switch (get_game_state()) {
case _game_in_progress:
#if defined(__APPLE__) && defined(__MACH__)
if ((event.key.keysym.mod & KMOD_GUI))
#else
if ((event.key.keysym.mod & KMOD_ALT) || (event.key.keysym.mod & KMOD_GUI))
#endif
{
int item = -1;
switch (event.key.keysym.sym) {
case SDLK_p:
item = iPause;
break;
case SDLK_s:
item = iSave;
break;
case SDLK_r:
item = iRevert;
break;
// ZZZ: Alt+F4 is also a quit gesture in Windows
#ifdef __WIN32__
case SDLK_F4:
#endif
case SDLK_q:
item = iQuitGame;
break;
case SDLK_RETURN:
item = 0;
toggle_fullscreen();
break;
default:
break;
}
if (item > 0)
do_menu_item_command(mGame, item, event_has_cheat_modifiers(event));
else if (item != 0)
handle_game_key(event);
} else
handle_game_key(event);
break;
case _display_intro_screens:
case _display_chapter_heading:
case _display_prologue:
case _display_epilogue:
case _display_credits:
case _display_quit_screens:
if (interface_fade_finished())
force_game_state_change();
else
stop_interface_fade();
break;
case _display_intro_screens_for_demo:
stop_interface_fade();
display_main_menu();
break;
case _quit_game:
case _close_game:
case _revert_game:
case _switch_demo:
case _change_level:
case _begin_display_of_epilogue:
case _displaying_network_game_dialogs:
break;
case _display_main_menu:
{
if (!interface_fade_finished())
stop_interface_fade();
int item = -1;
switch (event.key.keysym.sym) {
case SDLK_n:
item = iNewGame;
break;
case SDLK_o:
item = iLoadGame;
break;
case SDLK_g:
item = iGatherGame;
break;
case SDLK_j:
item = iJoinGame;
break;
case SDLK_p:
item = iPreferences;
break;
case SDLK_r:
item = iReplaySavedFilm;
break;
case SDLK_c:
item = iCredits;
break;
// ZZZ: Alt+F4 is also a quit gesture in Windows
#ifdef __WIN32__
case SDLK_F4:
#endif
case SDLK_q:
item = iQuit;
break;
case SDLK_F9:
dump_screen();
break;
case SDLK_RETURN:
#if defined(__APPLE__) && defined(__MACH__)
if ((event.key.keysym.mod & KMOD_GUI))
#else
if ((event.key.keysym.mod & KMOD_GUI) || (event.key.keysym.mod & KMOD_ALT))
#endif
{
toggle_fullscreen();
}
break;
case SDLK_a:
item = iAbout;
break;
default:
break;
}
if (item > 0) {
draw_menu_button_for_command(item);
do_menu_item_command(mInterface, item, event_has_cheat_modifiers(event));
}
break;
}
}
}
int
main(int argc, char **argv)
{
char *font, *type, *termmode;
const char *opts;
int dumpmod, dumpopt, opt;
vt4_mode = is_vt4();
init();
dumpmod = 0;
dumpopt = DUMP_FBF;
termmode = NULL;
if (vt4_mode)
opts = "b:Cc:fg:h:Hi:M:m:pPr:S:s:T:t:x";
else
opts = "b:Cc:deE:fg:h:Hi:l:LM:m:pPr:S:s:T:t:x";
while ((opt = getopt(argc, argv, opts)) != -1)
switch(opt) {
case 'b':
set_border_color(optarg);
break;
case 'C':
clear_history();
break;
case 'c':
set_cursor_type(optarg);
break;
case 'd':
if (vt4_mode)
break;
print_scrnmap();
break;
case 'E':
if (vt4_mode)
break;
set_terminal_emulator(optarg);
break;
case 'e':
if (vt4_mode)
break;
get_terminal_emulators();
break;
case 'f':
optarg = nextarg(argc, argv, &optind, 'f', 0);
if (optarg != NULL) {
font = nextarg(argc, argv, &optind, 'f', 0);
if (font == NULL) {
type = NULL;
font = optarg;
} else
type = optarg;
load_font(type, font);
} else {
if (!vt4_mode)
usage(); /* Switch syscons to ROM? */
load_default_vt4font();
}
break;
case 'g':
if (sscanf(optarg, "%dx%d",
&vesa_cols, &vesa_rows) != 2) {
revert();
warnx("incorrect geometry: %s", optarg);
usage();
}
break;
case 'h':
set_history(optarg);
break;
case 'H':
dumpopt = DUMP_ALL;
break;
case 'i':
show_info(optarg);
break;
case 'l':
if (vt4_mode)
break;
load_scrnmap(optarg);
break;
case 'L':
if (vt4_mode)
break;
load_default_scrnmap();
break;
case 'M':
set_mouse_char(optarg);
break;
case 'm':
set_mouse(optarg);
break;
case 'p':
dumpmod = DUMP_FMT_RAW;
break;
case 'P':
dumpmod = DUMP_FMT_TXT;
break;
case 'r':
set_reverse_colors(argc, argv, &optind);
break;
case 'S':
set_lockswitch(optarg);
break;
case 's':
set_console(optarg);
break;
case 'T':
if (strcmp(optarg, "xterm") != 0 &&
strcmp(optarg, "cons25") != 0)
usage();
termmode = optarg;
break;
case 't':
set_screensaver_timeout(optarg);
break;
case 'x':
hex = 1;
break;
default:
usage();
}
if (dumpmod != 0)
dump_screen(dumpmod, dumpopt);
video_mode(argc, argv, &optind);
set_normal_colors(argc, argv, &optind);
if (optind < argc && !strcmp(argv[optind], "show")) {
test_frame();
optind++;
}
if (termmode != NULL)
set_terminal_mode(termmode);
if ((optind != argc) || (argc == 1))
usage();
return (0);
}
int
main(int argc, char **argv)
{
char *font, *type, *termmode;
const char *opts;
int dumpmod, dumpopt, opt;
int reterr;
vt4_mode = is_vt4();
init();
info.size = sizeof(info);
if (ioctl(0, CONS_GETINFO, &info) == -1)
err(1, "must be on a virtual console");
dumpmod = 0;
dumpopt = DUMP_FBF;
termmode = NULL;
if (vt4_mode)
opts = "b:Cc:f:g:h:Hi:M:m:pPr:S:s:T:t:x";
else
opts = "b:Cc:df:g:h:Hi:l:LM:m:pPr:S:s:T:t:x";
while ((opt = getopt(argc, argv, opts)) != -1)
switch(opt) {
case 'b':
set_border_color(optarg);
break;
case 'C':
clear_history();
break;
case 'c':
set_cursor_type(optarg);
break;
case 'd':
if (vt4_mode)
break;
print_scrnmap();
break;
case 'f':
type = optarg;
font = nextarg(argc, argv, &optind, 'f', 0);
if (font == NULL) {
type = NULL;
font = optarg;
}
load_font(type, font);
break;
case 'g':
if (sscanf(optarg, "%dx%d",
&vesa_cols, &vesa_rows) != 2) {
revert();
warnx("incorrect geometry: %s", optarg);
usage();
}
break;
case 'h':
set_history(optarg);
break;
case 'H':
dumpopt = DUMP_ALL;
break;
case 'i':
show_info(optarg);
break;
case 'l':
if (vt4_mode)
break;
load_scrnmap(optarg);
break;
case 'L':
if (vt4_mode)
break;
load_default_scrnmap();
break;
case 'M':
set_mouse_char(optarg);
break;
case 'm':
set_mouse(optarg);
break;
case 'p':
dumpmod = DUMP_FMT_RAW;
break;
case 'P':
dumpmod = DUMP_FMT_TXT;
break;
case 'r':
get_reverse_colors(argc, argv, &optind);
break;
case 'S':
set_lockswitch(optarg);
break;
case 's':
set_console(optarg);
break;
case 'T':
if (strcmp(optarg, "xterm") != 0 &&
strcmp(optarg, "cons25") != 0)
usage();
termmode = optarg;
break;
case 't':
set_screensaver_timeout(optarg);
break;
case 'x':
hex = 1;
break;
default:
usage();
}
if (dumpmod != 0)
dump_screen(dumpmod, dumpopt);
reterr = video_mode(argc, argv, &optind);
get_normal_colors(argc, argv, &optind);
if (optind < argc && !strcmp(argv[optind], "show")) {
test_frame();
optind++;
}
video_mode(argc, argv, &optind);
if (termmode != NULL)
set_terminal_mode(termmode);
get_normal_colors(argc, argv, &optind);
if (colors_changed || video_mode_changed) {
if (!(new_mode_info.vi_flags & V_INFO_GRAPHICS)) {
if ((normal_back_color < 8) && (revers_back_color < 8)) {
set_colors();
} else {
revert();
errx(1, "bg color for text modes must be < 8");
}
} else {
set_colors();
}
}
if ((optind != argc) || (argc == 1))
usage();
return reterr;
}
main(int argc, char *argv[])
/* MAIN
Purpose : 1 Get privilege mask
2 Setup SMG environment unless no VT or DFU$NOSMG is set
3 Get and Parse command (syntax only)
4 Dispatch to correct subroutine
Inputs : Command line (if specified through foreign command)
Outputs : returns last status code to DCL in case
of single command processing. In interactive mode
always returns SS$_NORMAL.
*/
{
const rms_eof=98938,smg$_eof=1213442;
struct
{
short status, count;
int extra ;
} iosb;
static char command_line[255], *e;
unsigned int out_len,ret_len,prvmask;
void reset_ctrl(), clean_ctrlc(),
prev_screen(), next_screen(), dump_screen(), toggle_width() ;
int smg_flag, x, y, i, ttype;
int cursor_on = SMG$M_CURSOR_ON;
$DESCRIPTOR(input_line , command_line);
$DESCRIPTOR(prompt,"DFU> ");
$DESCRIPTOR(terminal,"SYS$COMMAND");
$DESCRIPTOR(top_txt,"< DFU V2.2 (Freeware) >");
$DESCRIPTOR(status_txt,"Statistics");
$DESCRIPTOR(do_key,"DO");
$DESCRIPTOR(pf2,"PF2");
$DESCRIPTOR(pf4,"PF4");
$DESCRIPTOR(prev,"PREV_SCREEN");
$DESCRIPTOR(next,"NEXT_SCREEN");
$DESCRIPTOR(select,"SELECT");
$DESCRIPTOR(help,"HELP");
/* First find out how we got called ( by RUN, or a foreign command */
ret_len = 0;
#if 0
status = lib$get_foreign(&input_line,0,&ret_len,0);
#else
status = 1;
#if 0
strcpy(command_line,argv[1]);
#endif
#endif
out_len = ret_len;
smg$enable = TRUE;
key_tab = 0;
disp2_id = 0;
cip = 0;
setvbuf(stdout, NULL, _IONBF, 0); // need this to see i/o at all
#if 0
smg$enable = FALSE;
vms_mm = check_vms_mm();
#else
/* Now create the SMG environment */
colls=80;
rows=24;
SMG$CREATE_PASTEBOARD(&paste_id, 0, &rows,
&colls,&SMG$M_KEEP_CONTENTS,&ttype,0);
if ((e = (char *) getenv("DFU$NOSMG")) && *e) smg$enable = FALSE;
else
{
if (ttype != SMG$K_VTTERMTABLE) smg$enable = FALSE;
if (ttype != SMG$K_VTTERMTABLE) SMG$DELETE_PASTEBOARD(&paste_id,&i0);
}
SMG$CREATE_VIRTUAL_KEYBOARD(&keyb_id,0,0,0,0);
if (smg$enable)
/* Setup key table */
{
SMG$ERASE_PASTEBOARD(&paste_id, 0, 0, 0, 0, 0, 0);
SMG$CREATE_KEY_TABLE(&key_tab);
colls -=2;
orig_colls = colls;
smg_flag = SMG$M_KEY_NOECHO + SMG$M_KEY_TERMINATE;
SMG$ADD_KEY_DEF(&key_tab,&do_key,0, &smg_flag, &do_key,0);
SMG$ADD_KEY_DEF(&key_tab,&pf4,0, &smg_flag,&pf4,0);
SMG$ADD_KEY_DEF(&key_tab,&prev,0, &smg_flag, &prev,0);
SMG$ADD_KEY_DEF(&key_tab,&next,0, &smg_flag, &next,0);
SMG$ADD_KEY_DEF(&key_tab,&pf2,0, &smg_flag, &help,0);
SMG$ADD_KEY_DEF(&key_tab,&help,0, &smg_flag, &help,0);
SMG$ADD_KEY_DEF(&key_tab,&select,0, &smg_flag, &select,0);
SMG$CREATE_VIRTUAL_DISPLAY(&i500, &colls , &disp1_id, &SMG$M_BORDER,
0, 0);
x = 508 - rows;
y = rows - 7;
SMG$CREATE_VIEWPORT(&disp1_id,&x,&i1,&y,&colls);
SMG$CREATE_VIRTUAL_DISPLAY(&i2, &colls, &status_id, 0 , 0, 0);
SMG$CREATE_VIRTUAL_DISPLAY(&i2, &colls, &disp2_id, 0 , 0, 0);
SMG$SET_BROADCAST_TRAPPING(&paste_id,brdcst_ast,0);
SMG$LABEL_BORDER(&disp1_id, &top_txt, 0, 0,&SMG$M_BOLD, 0, 0);
SMG$LABEL_BORDER(&status_id, &status_txt, 0, 0,&SMG$M_BOLD, 0, 0);
SMG$PASTE_VIRTUAL_DISPLAY(&disp1_id, &paste_id, &i2,&i2,0);
x = rows - 4;
SMG$PASTE_VIRTUAL_DISPLAY(&status_id, &paste_id, &x,&i2,0);
x = rows - 1;
SMG$PASTE_VIRTUAL_DISPLAY(&disp2_id, &paste_id, &x,&i2,0);
x = 508 - rows;
SMG$SET_CURSOR_ABS(&disp1_id,&x,&i1);
SMG$SET_CURSOR_ABS(&disp2_id,&i1,&i1);
SMG$BEGIN_PASTEBOARD_UPDATE(&paste_id);
}
#endif
sprintf(outbuf,"\n Disk and File Utilities for OpenVMS DFU V2.2");
put_disp();
sprintf(outbuf," Freeware version");
put_disp();
sprintf(outbuf," Copyright © 1995 Digital Equipment Corporation\n");
put_disp();
if (smg$enable)
{
/* Enter additional info */
sprintf(outbuf," DFU functions are : \n");
put_disp();
sprintf(outbuf," DEFRAGMENT : Defragment files");
put_disp();
sprintf(outbuf," DELETE : Delete files by File-ID; delete directory (trees)");
put_disp();
sprintf(outbuf," DIRECTORY : Manipulate directories");
put_disp();
sprintf(outbuf," REPORT : Generate a complete disk report");
put_disp();
sprintf(outbuf," SEARCH : Fast file search");
put_disp();
sprintf(outbuf," SET : Modify file attributes");
put_disp();
sprintf(outbuf," UNDELETE : Recover deleted files");
put_disp();
sprintf(outbuf," VERIFY : Check and repair disk structure");
put_disp();
SMG$END_PASTEBOARD_UPDATE(&paste_id);
}
prvmask = 0;
status = dfu_check_access(&prvmask); /*Get the privilege mask */
/* Setup terminal channel for control purposes; get the terminal chars */
status = SYS$ASSIGN(&terminal, &tchan, 0,0);
status = SYS$QIOW(0,tchan, IO$_SENSEMODE,0,0,0,&orgttchar,12,0,0,0,0);
for (i = 0; i < 3; i++) ttchar[i] = orgttchar[i];
ttchar[2] &= ~TT2$M_EDITING; /* Clear line edit bit */
clean_ctrlc(); /* Enable CTRL/W if needed */
if (ret_len==0)
{
if (smg$enable)
status = SMG$READ_COMPOSED_LINE(&keyb_id,&key_tab,&input_line,&prompt,
&out_len,&disp2_id,0,0,0,0,0);
else
status = SMG$READ_COMPOSED_LINE(&keyb_id,0,&input_line,&prompt,
&out_len,0,0,0,0,0,0);
}
memcpy (command_line, input_line.dsc$a_pointer, input_line.dsc$w_length);
cip = 1;
/* Main loop starts here. Get a command and pasre it*/
for (;;)
{
/* loop forever until EXIT is entered */
if(status==smg$_eof) status = exit_command(prvmask);
if ((status&1) != 1) goto endfor;
if (out_len == 0) goto endfor;
/* First catch special screen commands */
if (smg$enable)
{
status = strncmp(command_line, "PREV_SCREEN", 11);
if (status == 0)
{
prev_screen();
goto endfor;
}
status = strncmp(command_line, "DO",2);
if (status == 0)
{
status = spawn_command(prvmask);
goto endfor;
}
status = strncmp(command_line, "PF4",3);
if (status == 0)
{
dump_screen();
goto endfor;
}
status = strncmp(command_line, "NEXT_SCREEN", 11);
if (status == 0)
{
next_screen();
goto endfor;
}
status = strncmp(command_line, "SELECT", 6);
if (status == 0)
{
toggle_width();
goto endfor;
}
SMG$ERASE_DISPLAY(&disp1_id, 0, 0, 0, 0);
SMG$ERASE_DISPLAY(&status_id, 0, 0, 0, 0);
SMG$CHANGE_VIEWPORT(&disp1_id,&x,&i1,&y,&colls);
SMG$SET_CURSOR_ABS(&disp1_id,&x,&i1);
}
/* Catch the CLI errors do avoid disrupting the SMG screen... */
#if 0
VAXC$ESTABLISH(prim_hand);
#endif
status = CLI$DCL_PARSE(&input_line,&dfu_tables,0 /* not yet lib$get_input*/,0,&prompt); // check added & before dfu_tables
#if 0
VAXC$ESTABLISH(NULL);
#endif
if (status == CLI$_NOCOMD) singlemsg(0,status);
if ((status & 1 ) != 1) goto endfor;
else
/* Now dispatch if no errors */
{
reset_ctrl();
CLI$DISPATCH(prvmask);
clean_ctrlc();
cip = 0;
status = brdcst_ast();
if (smg$enable) SMG$SET_CURSOR_MODE(&paste_id, &cursor_on);
}
endfor:
if (ret_len !=0)
{
/* Single command processing , so exit here */
status += 0x10000000; /* Do not echo the error on DCL level */
if (smg$enable)
{
if (colls != orig_colls) toggle_width();
SMG$SET_CURSOR_ABS(&disp2_id,&i2,&i1);
}
exit(status);
}
/* Get next line */
cip = 0;
#if 1
if (smg$enable)
{
SMG$ERASE_LINE(&disp2_id, &i1, &i1);
SMG$SET_CURSOR_ABS(&disp2_id,&i1,&i1);
status = SMG$READ_COMPOSED_LINE(&keyb_id,&key_tab,&input_line,
&prompt,&out_len,&disp2_id,0,0,0,0,0); /*Get next command */
cip = 1;
}
else
status = SMG$READ_COMPOSED_LINE(&keyb_id,0,&input_line,
&prompt,&out_len,0,0,0,0,0,0); /*Get next command */
#else
printf("%s",prompt.dsc$a_pointer);
out_len = read(0,command_line,254);
out_len--;
command_line[out_len]=0;
if (strncmp(command_line,"exit",4)==0)
return 0;
#endif
}
} /* END of MAIN */
void ic_event_handler(input_callbacks* ic, CallbackEvent event)
{
int stage = 0;
static bool enable_screen = true;
if (ic != &mInputCallbacks) {
LOGE("Callback mismatched! abort here.");
return;
}
switch(event) {
case EVENT_REGISTERED:
LOGD("input service has registered.");
break;
case EVENT_UNREGISTERED:
LOGD("EVENT_UNREGISTERED");
break;
case EVENT_VOLUMN_UP_PRESSED:
LOGD("volumn up hit.");
if (capture_mode_enable) {
LOGD("capture mode enabled, do dump screen");
dump_screen();
break;
} else if (!event_handle_in_progress) {
event_handle_in_progress = 1;
//job here
mFGO->StartJob(0);
event_handle_in_progress = 0;
}
break;
case EVENT_VOLUMN_DOWN_PRESSED:
LOGD("volumn down hit.");
if (capture_mode_enable) {
LOGD("capture mode enabled, do dump screen.");
dump_screen();
} else if (!event_handle_in_progress) {
event_handle_in_progress = 1;
// job here
mFGO->StartJob(0);
event_handle_in_progress = 0;
}
break;
case EVENT_VOLUMN_UP_LONG_PRESSED:
LOGD("volumn up long pressed, changing hero triggerred.");
//capture_mode_enable = !capture_mode_enable;
break;
case EVENT_VOLUMN_DOWN_LONG_PRESSED:
LOGD("volumn down long pressed, trigger dump screen.");
//capture_mode_enable = !capture_mode_enable;
break;
case EVENT_VOLUMN_DOWN_LONG_LONG_PRESSED:
LOGD("volumn down long long pressed, clean data.");
std::system("mkdir -p /sdcard/fgo/ryan/files");
std::system("mkdir -p /sdcard/fgo/ryan/shared_prefs");
std::system("mv -f /data/data/com.aniplex.fategrandorder/files/*.dat /sdcard/fgo/ryan/files/");
std::system("mv -f /data/data/com.aniplex.fategrandorder/shared_prefs/* /sdcard/fgo/ryan/shared_prefs/");
std::system("am start -a \"android.intent.action.VIEW\" -t \"audio/ogg\" -d \"file:///storage/sdcard0/Ringtones/hangouts_incoming_call.ogg\"");
break;
case EVENT_POWER_KEY_PRESSED:
LOGD("power key hit.");
mFGO->StopJob(0);
mFGO->StopJob(1);
mInputService->ConfigTouchScreen(true);
break;
default:
LOGW("Unknown event %d", event);
break;
}
}
void
process_keystrokes (int key)
{
#if defined (commentout) /* KBR 10/14/2002 - Cleanup MSVC warning */
int retval;
#endif
switch (key)
{
case 0: printf("dead!"); return;
case ' ': /* Space */
case 10: /* Linefeed/Return */
case 13: /* Enter */
case 127: /* Backspace */
if (key == 127) {
cs_mouse_handler (LC_MOUSE_RIGHTBUTTON | LC_MOUSE_PRESS,
0, 0);
cs_mouse_handler (LC_MOUSE_RIGHTBUTTON | LC_MOUSE_RELEASE,
0, 0);
} else {
cs_mouse_handler (LC_MOUSE_LEFTBUTTON | LC_MOUSE_PRESS,
0, 0);
cs_mouse_handler (LC_MOUSE_LEFTBUTTON | LC_MOUSE_RELEASE,
0, 0);
}
if (help_flag) {
draw_help_page ("return-2");
}
if (prefs_flag) {
close_prefs_screen ();
refresh_main_screen ();
}
break;
#if defined (SVGALIB)
case 91:
{
int w = vga_getkey ();
switch (w)
{
case ('A'):
cs_mouse_handler (0, 0, -kmouse_val);
break;
case ('B'):
cs_mouse_handler (0, 0, kmouse_val);
break;
case ('C'):
cs_mouse_handler (0, kmouse_val, 0);
break;
case ('D'):
cs_mouse_handler (0, -kmouse_val, 0);
break;
}
}
break;
#endif
#if defined (WIN32) || defined (LC_X11)
case 1:
/* Scroll left */
if (x_key_shifted) {
adjust_main_origin (main_screen_originx - RIGHT_MOUSE_MOVE_VAL,
main_screen_originy,
TRUE);
} else {
adjust_main_origin (main_screen_originx - 1,
main_screen_originy,
TRUE);
}
break;
case 2:
/* Scroll down */
if (x_key_shifted) {
adjust_main_origin (main_screen_originx,
main_screen_originy + RIGHT_MOUSE_MOVE_VAL,
TRUE);
} else {
adjust_main_origin (main_screen_originx,
main_screen_originy + 1,
TRUE);
}
break;
case 3:
/* Scroll up */
if (x_key_shifted) {
adjust_main_origin (main_screen_originx,
main_screen_originy - RIGHT_MOUSE_MOVE_VAL,
TRUE);
} else {
adjust_main_origin (main_screen_originx,
main_screen_originy - 1,
TRUE);
}
break;
case 4:
/* Scroll right */
if (x_key_shifted) {
adjust_main_origin (main_screen_originx + RIGHT_MOUSE_MOVE_VAL,
main_screen_originy,
TRUE);
} else {
adjust_main_origin (main_screen_originx + 1,
main_screen_originy,
TRUE);
}
break;
#endif
case 'P':
case 'p':
select_pause ();
break;
#ifdef DEBUG_KEYS
case 'e':
if (cheat () != 0)
people_pool += 100;
break;
case 'd':
if (cheat () != 0)
dump_screen ();
break;
case 'D':
/* dump_tcore (); */
break;
case 't':
if (cheat () != 0)
tech_level += 1000;
break;
case 'T':
if (cheat () != 0)
tech_level += 10000;
break;
case 'm':
if (cheat () != 0)
adjust_money(1000000);
break;
#endif
case 'f':
do_random_fire (-1, -1, 1);
break;
case 'L':
case 'l':
load_flag = 1;
break;
case 'H':
case 'h':
activate_help ("index.hlp");
break;
/* Escape Key */
#ifdef LC_X11
case 27:
#else
case 5:
#endif
if (help_flag) {
/* exit help */
draw_help_page("return-2");
} else if (prefs_flag) {
close_prefs_screen();
refresh_main_screen ();
} else {
activate_help ("menu.hlp");
}
break;
case 'S':
case 's':
save_flag = 1;
break;
case 'v':
case 'V':
/* Toggle overlay */
rotate_main_screen();
break;
case 'o':
case 'O':
prefs_flag = 1;
break;
case 'r':
window_results();
break;
case 'q':
case 'Q':
quit_flag = 1;
break;
} /* end switch on keystroke */
}
/*
* This function reallocates memory if changing the number of Buf offsets.
* The code is based on Reallocate().
*/
static void
ReallocateBufOffsets(ScrnBuf * sbuf,
Char ** sbufaddr,
unsigned nrow,
unsigned ncol,
size_t new_max_offsets)
{
unsigned i;
int j, k;
ScrnBuf base;
Char *oldbuf, *tmp;
size_t entries, length;
/*
* As there are 2 buffers (allbuf, altbuf), we cannot change num_ptrs in
* this function. However MAX_PTRS and BUF_PTRS depend on num_ptrs so
* change it now and restore the value when done.
*/
int old_max_ptrs = MAX_PTRS;
assert(nrow != 0);
assert(ncol != 0);
assert(new_max_offsets != 0);
dump_screen("before", *sbuf, *sbufaddr, nrow, ncol);
term->num_ptrs = new_max_offsets;
entries = MAX_PTRS * nrow;
length = BUF_PTRS * nrow * ncol;
oldbuf = *sbufaddr;
*sbuf = TypeRealloc(ScrnPtr, entries, *sbuf);
if (*sbuf == 0)
SysError(ERROR_RESIZE);
base = *sbuf;
if ((tmp = TypeCallocN(Char, length)) == 0)
SysError(ERROR_SREALLOC);
*sbufaddr = tmp;
for (i = k = 0; i < nrow; i++) {
k += BUF_HEAD;
for (j = BUF_HEAD; j < old_max_ptrs; j++) {
memcpy(tmp, base[k++], ncol);
tmp += ncol;
}
tmp += ncol * (new_max_offsets - old_max_ptrs);
}
/*
* update the pointers in sbuf
*/
for (i = k = 0, tmp = *sbufaddr; i < nrow; i++) {
for (j = 0; j < BUF_HEAD; j++)
base[k++] = 0;
for (j = BUF_HEAD; j < MAX_PTRS; j++) {
base[k++] = tmp;
tmp += ncol;
}
}
/* Now free the old buffer and restore num_ptrs */
free(oldbuf);
dump_screen("after", *sbuf, *sbufaddr, nrow, ncol);
term->num_ptrs = old_max_ptrs;
}
