// ---------------------------------------------------------------------
// mission_hotkey_init()
//
// Initialize the hotkey assignment screen system. Called when GS_STATE_HOTKEY_SCREEN
// is entered.
//
void mission_hotkey_init()
{
int i;
hotkey_buttons *b;
// pause all beam weapon sounds
beam_pause_sounds();
// pause all game music
audiostream_pause_all();
reset_hotkeys();
common_set_interface_palette(); // set the interface palette
Ui_window.create(0, 0, gr_screen.max_w, gr_screen.max_h, 0);
Ui_window.set_mask_bmap(Hotkey_mask_fname[gr_screen.res]);
for (i=0; i<NUM_BUTTONS; i++) {
b = &Buttons[gr_screen.res][i];
b->button.create(&Ui_window, "", b->x, b->y, 60, 30, i < 2 ? 1 : 0, 1);
// set up callback for when a mouse first goes over a button
b->button.set_highlight_action(common_play_highlight_sound);
b->button.set_bmaps(b->filename);
b->button.link_hotspot(b->hotspot);
}
// add all xstr text
for(i=0; i<HOTKEY_NUM_TEXT; i++) {
Ui_window.add_XSTR(&Hotkey_text[gr_screen.res][i]);
}
for (i=0; i<LIST_BUTTONS_MAX; i++) {
List_buttons[i].create(&Ui_window, "", 0, 0, 60, 30, (i < 2), 1);
List_buttons[i].hide();
List_buttons[i].disable();
}
// set up hotkeys for buttons so we draw the correct animation frame when a key is pressed
Buttons[gr_screen.res][SCROLL_UP_BUTTON].button.set_hotkey(KEY_PAGEUP);
Buttons[gr_screen.res][SCROLL_DOWN_BUTTON].button.set_hotkey(KEY_PAGEDOWN);
// ensure help overlay is off
help_overlay_set_state(HOTKEY_OVERLAY,0);
// load in relevant bitmaps
Background_bitmap = bm_load(Hotkey_background_fname[gr_screen.res]);
if (Background_bitmap < 0) {
// bitmap didnt load -- this is bad
Int3();
}
Wing_bmp = bm_load("WingDesignator");
if (Wing_bmp < 0) {
// bitmap didnt load -- this is bad
Int3();
}
Scroll_offset = 0;
Selected_line = 1;
hotkey_build_listing();
}
void hotkey_button_pressed(int n)
{
switch (n) {
case SCROLL_UP_BUTTON:
hotkey_scroll_screen_up();
break;
case SCROLL_DOWN_BUTTON:
hotkey_scroll_screen_down();
break;
case ADD_HOTKEY_BUTTON:
add_hotkey(Cur_hotkey);
gamesnd_play_iface(SND_USER_SELECT);
break;
case REMOVE_HOTKEY_BUTTON:
remove_hotkey();
gamesnd_play_iface(SND_USER_SELECT);
break;
case ACCEPT_BUTTON:
save_hotkeys();
// fall through to CANCEL_BUTTON
case CANCEL_BUTTON:
mission_hotkey_exit();
gamesnd_play_iface(SND_USER_SELECT);
break;
case HELP_BUTTON:
launch_context_help();
gamesnd_play_iface(SND_HELP_PRESSED);
break;
case OPTIONS_BUTTON:
gameseq_post_event(GS_EVENT_OPTIONS_MENU);
gamesnd_play_iface(SND_USER_SELECT);
break;
case CLEAR_BUTTON:
clear_hotkeys();
gamesnd_play_iface(SND_USER_SELECT);
break;
case RESET_BUTTON:
reset_hotkeys();
gamesnd_play_iface(SND_USER_SELECT);
break;
}
}
static int32_t init_kb(void)
{
if (!ppb_input_event_interface) {
ppb_input_event_interface =
(PPB_InputEvent *) NaCl_GetInterface(PPB_INPUT_EVENT_INTERFACE);
}
ppb_keyboard_event_interface =
(PPB_KeyboardInputEvent *) NaCl_GetInterface(
PPB_KEYBOARD_INPUT_EVENT_INTERFACE);
if (!ppb_input_event_interface) {
DEBUG_LOG("Could not acquire PPB_InputEvent interface.\n");
return 0;
}
if (!ppb_keyboard_event_interface) {
DEBUG_LOG("Could not acquire PPB_KeyboardInputEvent interface.\n");
return 0;
}
inputdevice_release_all_keys ();
reset_hotkeys ();
return 1;
}
// ---------------------------------------------------------------------
// mission_hotkey_do_frame()
//
// Called once per frame to process user input for the Hotkey Assignment Screen
//
void mission_hotkey_do_frame(float frametime)
{
char buf[256];
int i, k, w, h, y, z, line, hotkeys;
int font_height = gr_get_font_height();
int select_tease_line = -1; // line mouse is down on, but won't be selected until button released
color circle_color;
if ( help_overlay_active(Hotkey_overlay_id) ) {
Buttons[gr_screen.res][HELP_BUTTON].button.reset_status();
Ui_window.set_ignore_gadgets(1);
}
k = Ui_window.process() & ~KEY_DEBUGGED;
if ( (k > 0) || B1_JUST_RELEASED ) {
if ( help_overlay_active(Hotkey_overlay_id) ) {
help_overlay_set_state(Hotkey_overlay_id, gr_screen.res, 0);
Ui_window.set_ignore_gadgets(0);
k = 0;
}
}
if ( !help_overlay_active(Hotkey_overlay_id) ) {
Ui_window.set_ignore_gadgets(0);
}
switch (k) {
case KEY_DOWN: // scroll list down
hotkey_scroll_line_down();
break;
case KEY_UP: // scroll list up
hotkey_scroll_line_up();
break;
case KEY_PAGEDOWN: // scroll list down
hotkey_scroll_screen_down();
break;
case KEY_PAGEUP: // scroll list up
hotkey_scroll_screen_up();
break;
case KEY_CTRLED | KEY_ENTER:
save_hotkeys();
// fall through to next state -- allender changed this behavior since ESC should always cancel, no?
case KEY_ESC:
mission_hotkey_exit();
break;
case KEY_TAB:
case KEY_ENTER:
case KEY_PADENTER:
expand_wing();
break;
case KEY_EQUAL:
case KEY_PADPLUS:
add_hotkey(Cur_hotkey);
break;
case KEY_MINUS:
case KEY_PADMINUS:
remove_hotkey();
break;
case KEY_F2:
gameseq_post_event(GS_EVENT_OPTIONS_MENU);
break;
case KEY_CTRLED | KEY_R:
reset_hotkeys();
break;
case KEY_CTRLED | KEY_C:
clear_hotkeys();
break;
} // end switch
// ?
for (i=0; i<MAX_KEYED_TARGETS; i++) {
if (k == Key_sets[i])
Cur_hotkey = i;
if (k == (Key_sets[i] | KEY_SHIFTED))
add_hotkey(i);
}
// handle pressed buttons
for (i=0; i<NUM_BUTTONS; i++) {
if (Buttons[gr_screen.res][i].button.pressed()) {
hotkey_button_pressed(i);
break; // only need to handle 1 button @ a time
}
}
for (i=0; i<LIST_BUTTONS_MAX; i++) {
// check for tease line
if (List_buttons[i].button_down()) {
select_tease_line = i + Scroll_offset;
}
// check for selected list item
if (List_buttons[i].pressed()) {
Selected_line = i + Scroll_offset;
List_buttons[i].get_mouse_pos(&z, NULL);
z += Hotkey_list_coords[gr_screen.res][0]; // adjust to full screen space
if ((z >= Hotkey_wing_icon_x[gr_screen.res]) && (z < (Hotkey_wing_icon_x[gr_screen.res]) + Hotkey_function_field_width[gr_screen.res])) {
expand_wing();
}
}
if (List_buttons[i].double_clicked()) {
Selected_line = i + Scroll_offset;
hotkeys = -1;
switch (Hotkey_lines[Selected_line].type) {
case HOTKEY_LINE_WING:
hotkeys = get_wing_hotkeys(Hotkey_lines[Selected_line].index);
break;
case HOTKEY_LINE_SHIP:
case HOTKEY_LINE_SUBSHIP:
hotkeys = Hotkey_bits[Hotkey_lines[Selected_line].index];
break;
}
if (hotkeys != -1) {
if (hotkeys & (1 << Cur_hotkey))
remove_hotkey();
else
add_hotkey(Cur_hotkey);
}
}
}
GR_MAYBE_CLEAR_RES(Background_bitmap);
if (Background_bitmap >= 0) {
gr_set_bitmap(Background_bitmap);
gr_bitmap(0, 0, GR_RESIZE_MENU);
} else
gr_clear();
Ui_window.draw();
gr_init_color(&circle_color, 160, 160, 0);
// draw the big "F10" in the little box
font::set_font(font::FONT2);
gr_set_color_fast(&Color_text_normal);
strcpy_s(buf, Scan_code_text[Key_sets[Cur_hotkey]]);
gr_get_string_size(&w, &h, buf);
gr_printf_menu(Hotkey_function_name_coords[gr_screen.res][0] + (Hotkey_function_name_coords[gr_screen.res][2] - w) / 2, Hotkey_function_name_coords[gr_screen.res][1], buf);
font::set_font(font::FONT1);
line = Scroll_offset;
while (hotkey_line_query_visible(line)) {
z = Hotkey_lines[line].index;
y = Hotkey_list_coords[gr_screen.res][1] + Hotkey_lines[line].y - Hotkey_lines[Scroll_offset].y;
hotkeys = 0;
switch (Hotkey_lines[line].type) {
case HOTKEY_LINE_HEADING:
gr_set_color_fast(&Color_text_heading);
gr_get_string_size(&w, &h, Hotkey_lines[line].label);
i = y + h / 2 - 1;
gr_line(Hotkey_list_coords[gr_screen.res][0], i, Hotkey_ship_x[gr_screen.res] - 2, i, GR_RESIZE_MENU);
gr_line(Hotkey_ship_x[gr_screen.res] + w + 1, i, Hotkey_list_coords[gr_screen.res][0] + Hotkey_list_coords[gr_screen.res][2], i, GR_RESIZE_MENU);
break;
case HOTKEY_LINE_WING:
gr_set_bitmap(Wing_bmp);
bm_get_info(Wing_bmp, NULL, &h, NULL);
i = y + font_height / 2 - h / 2 - 1;
gr_bitmap(Hotkey_wing_icon_x[gr_screen.res], i, GR_RESIZE_MENU);
// i = y + font_height / 2 - 1;
// gr_set_color_fast(&circle_color);
// gr_circle(ICON_LIST_X + 4, i, 5, GR_RESIZE_MENU);
// gr_set_color_fast(&Color_bright);
// gr_line(ICON_LIST_X, i, ICON_LIST_X + 2, i, GR_RESIZE_MENU);
// gr_line(ICON_LIST_X + 4, i - 4, ICON_LIST_X + 4, i - 2, GR_RESIZE_MENU);
// gr_line(ICON_LIST_X + 6, i, ICON_LIST_X + 8, i, GR_RESIZE_MENU);
// gr_line(ICON_LIST_X + 4, i + 2, ICON_LIST_X + 4, i + 4, GR_RESIZE_MENU);
hotkeys = get_wing_hotkeys(Hotkey_lines[line].index);
break;
case HOTKEY_LINE_SHIP:
case HOTKEY_LINE_SUBSHIP:
hotkeys = Hotkey_bits[Hotkey_lines[line].index];
break;
default:
Int3();
}
if (Hotkey_lines[line].type != HOTKEY_LINE_HEADING) {
Assert( (line - Scroll_offset) < LIST_BUTTONS_MAX );
List_buttons[line - Scroll_offset].update_dimensions(Hotkey_list_coords[gr_screen.res][0], y, Hotkey_list_coords[gr_screen.res][0] + Hotkey_list_coords[gr_screen.res][2] - Hotkey_list_coords[gr_screen.res][0], font_height);
List_buttons[line - Scroll_offset].enable();
if (hotkeys & (1 << Cur_hotkey)) {
gr_set_color_fast(&Color_text_active);
} else {
if (line == Selected_line)
gr_set_color_fast(&Color_text_selected);
else if (line == select_tease_line)
gr_set_color_fast(&Color_text_subselected);
else
gr_set_color_fast(&Color_text_normal);
}
} else {
Assert( (line - Scroll_offset) < LIST_BUTTONS_MAX );
List_buttons[line - Scroll_offset].disable();
}
// print active hotkeys associated for this line
if (hotkeys) {
for (i=0; i<MAX_KEYED_TARGETS; i++) {
if (hotkeys & (1 << i)) {
gr_printf_menu(Hotkey_list_coords[gr_screen.res][0] + Hotkey_function_field_width[gr_screen.res]*i, y, Scan_code_text[Key_sets[i]]);
}
}
/*
*buf = 0;
for (i=0; i<MAX_KEYED_TARGETS; i++) {
if (hotkeys & (1 << i)) {
strcat_s(buf, Scan_code_text[Key_sets[i]]);
strcat_s(buf, ", ");
}
}
Assert(strlen(buf) > 1);
buf[strlen(buf) - 2] = 0; // lose the ", " on the end
font::force_fit_string(buf, 255, GROUP_LIST_W);
gr_printf_menu(GROUP_LIST_X, y, buf);*/
}
// draw ship/wing name
strcpy_s(buf, Hotkey_lines[line].label);
end_string_at_first_hash_symbol(buf);
if (Hotkey_lines[line].type == HOTKEY_LINE_SUBSHIP) {
// indent
font::force_fit_string(buf, 255, Hotkey_list_coords[gr_screen.res][0] + Hotkey_list_coords[gr_screen.res][2] - (Hotkey_ship_x[gr_screen.res]+20));
gr_printf_menu(Hotkey_ship_x[gr_screen.res]+20, y, buf);
} else {
font::force_fit_string(buf, 255, Hotkey_list_coords[gr_screen.res][0] + Hotkey_list_coords[gr_screen.res][2] - Hotkey_ship_x[gr_screen.res]);
gr_printf_menu(Hotkey_ship_x[gr_screen.res], y, buf);
}
line++;
}
i = line - Scroll_offset;
while (i < LIST_BUTTONS_MAX)
List_buttons[i++].disable();
// blit help overlay if active
help_overlay_maybe_blit(Hotkey_overlay_id, gr_screen.res);
gr_flip();
}
static void graphics_subinit (void)
{
XSetWindowAttributes wattr;
XClassHint classhint;
XWMHints *hints;
unsigned long valuemask;
dgamode = screen_is_picasso ? currprefs.gfx_pfullscreen : currprefs.gfx_afullscreen;
dgamode = dgamode && dgaavail;
wattr.background_pixel = /*black.pixel*/0;
wattr.backing_store = Always;
wattr.backing_planes = bitdepth;
wattr.border_pixmap = None;
wattr.border_pixel = /*black.pixel*/0;
wattr.colormap = cmap;
valuemask = (CWEventMask | CWBackPixel | CWBorderPixel
| CWBackingStore | CWBackingPlanes | CWColormap);
if (dgamode) {
wattr.event_mask = DGA_EVENTMASK;
wattr.override_redirect = 1;
valuemask |= CWOverrideRedirect;
} else
wattr.event_mask = EVENTMASK;
XSync (display, 0);
delete_win = XInternAtom(display, "WM_DELETE_WINDOW", False);
mywin = XCreateWindow (display, rootwin, 0, 0, current_width, current_height,
0, bitdepth, InputOutput, vis, valuemask, &wattr);
XSetWMProtocols (display, mywin, &delete_win, 1);
XSync (display, 0);
XStoreName (display, mywin, PACKAGE_NAME);
XSetIconName (display, mywin, PACKAGE_NAME);
/* set class hint */
classhint.res_name = (char *)"UAE";
classhint.res_class = (char *)"UAEScreen";
XSetClassHint(display, mywin, &classhint);
hints = XAllocWMHints();
/* Set window group leader to self to become an application
* that can be hidden by e.g. WindowMaker.
* Would be more useful if we could find out what the
* (optional) GTK+ window ID is :-/ */
hints->window_group = mywin;
hints->flags = WindowGroupHint;
XSetWMHints(display, mywin, hints);
XMapRaised (display, mywin);
XSync (display, 0);
mygc = XCreateGC (display, mywin, 0, 0);
if (dgamode) {
#ifdef USE_DGA_EXTENSION
enter_dga_mode ();
/*setuid(getuid());*/
picasso_vidinfo.rowbytes = fb_width * picasso_vidinfo.pixbytes;
#endif
} else {
get_image (current_width, current_height, &ami_dinfo);
if (screen_is_picasso) {
get_image (current_width, current_height, &pic_dinfo);
picasso_vidinfo.rowbytes = pic_dinfo.ximg->bytes_per_line;
}
}
picasso_vidinfo.extra_mem = 1;
gfxvidinfo.flush_screen = x11_flush_screen;
gfxvidinfo.lockscr = x11_lock;
gfxvidinfo.unlockscr = x11_unlock;
if (need_dither) {
gfxvidinfo.maxblocklines = 0;
gfxvidinfo.rowbytes = gfxvidinfo.pixbytes * currprefs.gfx_width_win;
gfxvidinfo.linemem = malloc (gfxvidinfo.rowbytes);
gfxvidinfo.flush_line = x11_flush_line_dither;
} else if (! dgamode) {
gfxvidinfo.emergmem = 0;
gfxvidinfo.linemem = 0;
gfxvidinfo.bufmem = (uae_u8 *)ami_dinfo.image_mem;
gfxvidinfo.rowbytes = ami_dinfo.ximg->bytes_per_line;
if (currprefs.x11_use_low_bandwidth) {
write_log ("Doing low-bandwidth output.\n");
gfxvidinfo.maxblocklines = 0;
gfxvidinfo.rowbytes = ami_dinfo.ximg->bytes_per_line;
gfxvidinfo.linemem = malloc (gfxvidinfo.rowbytes);
if (shmavail && currprefs.x11_use_mitshm) {
switch (gfxvidinfo.pixbytes) {
case 4 : gfxvidinfo.flush_line = x11_flush_line_lbw_32bit_mitshm; break;
case 2 : gfxvidinfo.flush_line = x11_flush_line_lbw_16bit_mitshm; break;
default : gfxvidinfo.flush_line = x11_flush_line_lbw_8bit_mitshm; break;
}
} else {
switch (gfxvidinfo.pixbytes) {
case 4 : gfxvidinfo.flush_line = x11_flush_line_lbw_32bit; break;
case 2 : gfxvidinfo.flush_line = x11_flush_line_lbw_16bit; break;
default : gfxvidinfo.flush_line = x11_flush_line_lbw_8bit; break;
}
}
} else {
gfxvidinfo.maxblocklines = MAXBLOCKLINES_MAX;
if (shmavail && currprefs.x11_use_mitshm)
gfxvidinfo.flush_block = x11_flush_block_mitshm;
else
gfxvidinfo.flush_block = x11_flush_block;
}
}
if (visualInfo.VI_CLASS != TrueColor && ! screen_is_picasso) {
int i;
for (i = 0; i < 256; i++)
XStoreColor (display, cmap, parsed_xcolors + i);
}
#ifdef USE_DGA_EXTENSION
if (dgamode) {
dga_colormap_installed = 0;
XF86DGAInstallColormap (display, screen, cmap2);
XF86DGAInstallColormap (display, screen, cmap);
}
#endif
if (! dgamode) {
if (!currprefs.hide_cursor)
XDefineCursor (display, mywin, xhairCursor);
else
XDefineCursor (display, mywin, blankCursor);
cursorOn = 1;
}
mousehack = !dgamode;
if (screen_is_picasso) {
picasso_has_invalid_lines = 0;
picasso_invalid_start = picasso_vidinfo.height + 1;
picasso_invalid_stop = -1;
memset (picasso_invalid_lines, 0, sizeof picasso_invalid_lines);
} else
reset_drawing ();
inwindow = 0;
inputdevice_release_all_keys ();
reset_hotkeys ();
}
static int viewport_setup(void) {
intptr_t width, height, format, rowbytes, pixbytes;
intptr_t rb = 0, gb = 0, bb = 0, ab = 0;
intptr_t rs = 0, gs = 0, bs = 0, as = 0;
printf("creating bitmap\n");
bitmap = glgfx_bitmap_create(glgfx_bitmap_attr_width, bm_width,
glgfx_bitmap_attr_height, bm_height,
glgfx_bitmap_attr_format, bm_format,
glgfx_tag_end);
if (bitmap == NULL) {
return 0;
}
printf("created bitmap %d %d format %08lx\n", bm_width, bm_height, bm_format);
uint32_t* buffer;
if ((buffer = glgfx_bitmap_lock(bitmap, false, true, glgfx_tag_end)) != NULL) {
int x, y;
for (y = 0; y < bm_height; y += 1) {
for (x = 0; x < bm_width; x += 1) {
buffer[x+y*bm_width] = glgfx_pixel_create_a8b8g8r8(y*255/bm_height, 0, x*255/bm_width, 128);
}
}
if (glgfx_bitmap_unlock(bitmap, glgfx_tag_end)) {
printf("updated bitmap\n");
}
}
glgfx_bitmap_getattr(bitmap, glgfx_bitmap_attr_width, &width);
glgfx_bitmap_getattr(bitmap, glgfx_bitmap_attr_height, &height);
glgfx_bitmap_getattr(bitmap, glgfx_bitmap_attr_format, &format);
glgfx_bitmap_getattr(bitmap, glgfx_bitmap_attr_bytesperrow, &rowbytes);
glgfx_pixel_getattr(format, glgfx_pixel_attr_bytesperpixel, &pixbytes);
glgfx_pixel_getattr(format, glgfx_pixel_attr_redbits, &rb);
glgfx_pixel_getattr(format, glgfx_pixel_attr_greenbits, &gb);
glgfx_pixel_getattr(format, glgfx_pixel_attr_bluebits, &bb);
glgfx_pixel_getattr(format, glgfx_pixel_attr_alphabits, &ab);
glgfx_pixel_getattr(format, glgfx_pixel_attr_redshift, &rs);
glgfx_pixel_getattr(format, glgfx_pixel_attr_greenshift, &gs);
glgfx_pixel_getattr(format, glgfx_pixel_attr_blueshift, &bs);
glgfx_pixel_getattr(format, glgfx_pixel_attr_alphashift, &as);
alloc_colors64k(rb, gb, bb, rs, gs, bs, ab, as, ((1 << ab) - 1), 0 /* byte swap? */ );
// Set up callback functions
gfxvidinfo.flush_line = _flush_line;
gfxvidinfo.flush_block = _flush_block;
gfxvidinfo.flush_screen = _flush_screen;
gfxvidinfo.flush_clear_screen = _flush_clear_screen;
gfxvidinfo.lockscr = _lockscr;
gfxvidinfo.unlockscr = _unlockscr;
#ifdef PICASSO96
if (!screen_is_picasso) {
#endif
gfxvidinfo.width = width;
gfxvidinfo.height = height;
gfxvidinfo.pixbytes = pixbytes;
gfxvidinfo.rowbytes = rowbytes;
gfxvidinfo.bufmem = NULL;
gfxvidinfo.emergmem = malloc(rowbytes);
gfxvidinfo.maxblocklines = height;
// gfxvidinfo.maxblocklines = 0;
gfxvidinfo.linemem = NULL;
reset_drawing ();
#ifdef PICASSO96
}
else {
picasso_has_invalid_lines = 0;
picasso_invalid_start = height + 1;
picasso_invalid_stop = -1;
picasso_vidinfo.width = width;
picasso_vidinfo.height = height;
picasso_vidinfo.depth = rb + gb + bb + ab;
picasso_vidinfo.pixbytes = pixbytes;
picasso_vidinfo.rowbytes = rowbytes;
picasso_vidinfo.extra_mem = 1;
p96_buffer = malloc(width*height*pixbytes);
p96_bytes_per_row = width*pixbytes;
memset (picasso_invalid_lines, 0, sizeof picasso_invalid_lines);
}
#endif
if (fullscreen) {
rasinfo = glgfx_viewport_addbitmap(viewport, bitmap,
glgfx_rasinfo_attr_x, 0,
glgfx_rasinfo_attr_y, 0,
glgfx_rasinfo_attr_width, real_width,
glgfx_rasinfo_attr_height, real_height,
glgfx_tag_end);
}
else {
rasinfo = glgfx_viewport_addbitmap(viewport, bitmap,
glgfx_rasinfo_attr_x, (real_width - bm_width) / 2,
glgfx_rasinfo_attr_y, (real_height - bm_height) / 2,
glgfx_rasinfo_attr_width, width,
glgfx_rasinfo_attr_height, height,
glgfx_tag_end);
}
if (rasinfo == NULL) {
return 0;
}
inputdevice_release_all_keys();
reset_hotkeys();
printf("viewport_setup -> 1\n");
return 1;
}
