static int key_dialog_handler(UI_DIALOG *dlg, d_event *event, key_dialog *k)
{
int keypress = 0;
int rval = 0;
if (event->type == EVENT_KEY_COMMAND)
keypress = event_key_get(event);
else if (event->type == EVENT_UI_DIALOG_DRAW)
{
ui_dprintf_at( dlg, 10, 100, "%s ", k->text );
return 1;
}
if (keypress > 0)
{
GetKeyDescription( k->text, keypress );
rval = 1;
}
if (GADGET_PRESSED(k->DoneButton))
{
ui_close_dialog(dlg);
rval = 1;
}
return rval;
}
static window_event_result hostage_dialog_handler(UI_DIALOG *dlg,const d_event &event, hostage_dialog *h)
{
switch(event.type)
{
case EVENT_WINDOW_CREATED:
return hostage_dialog_created(dlg, h);
case EVENT_WINDOW_CLOSE:
std::default_delete<hostage_dialog>()(h);
MainWindow = nullptr;
return window_event_result::ignored;
default:
break;
}
int keypress = 0;
if (event.type == EVENT_KEY_COMMAND)
keypress = event_key_get(event);
Assert(MainWindow != NULL);
//------------------------------------------------------------
// Redraw the object in the little 64x64 box
//------------------------------------------------------------
if (GADGET_PRESSED(h->quitButton.get()) || keypress==KEY_ESC)
{
return window_event_result::close;
}
return window_event_result::ignored;
}
int HandleDeathInput(d_event *event)
{
if (event->type == EVENT_KEY_COMMAND)
{
int key = event_key_get(event);
if (Player_exploded && !key_isfunc(key) && key != KEY_PAUSE && key)
Death_sequence_aborted = 1; //Any key but func or modifier aborts
if (key == KEY_ESC)
if (ConsoleObject->flags & OF_EXPLODING)
Death_sequence_aborted = 1;
}
if (Player_exploded && (event->type == EVENT_JOYSTICK_BUTTON_UP || event->type == EVENT_MOUSE_BUTTON_UP))
Death_sequence_aborted = 1;
#ifdef NETWORK
if((Game_mode & GM_NETWORK) && (Netgame.SpawnStyle == SPAWN_STYLE_PREVIEW)) {
if(is_key_rotate_event(event)) {
Death_sequence_aborted = 0;
}
}
#endif
if (Death_sequence_aborted)
{
// Causes problems with joystick throttle -- joy_axis data is cleared, and will only
// be updated when joystick moves (could be long enough for player to notice)
//game_flush_inputs();
return 1;
}
return 0;
}
int automap_key_command(window *wind, d_event *event, automap *am)
{
int c = event_key_get(event);
switch (c)
{
case KEY_PRINT_SCREEN: {
gr_set_current_canvas(NULL);
save_screen_shot(1);
return 1;
}
case KEY_ESC:
if (am->leave_mode==0)
{
window_close(wind);
return 1;
}
return 1;
case KEY_ALTED+KEY_F: // Alt+F shows full map, if cheats enabled
if (cheats.enabled)
{
cheats.fullautomap = !cheats.fullautomap;
automap_build_edge_list(am);
}
return 1;
#ifndef NDEBUG
case KEY_DEBUGGED+KEY_F: {
int i;
for (i=0; i<=Highest_segment_index; i++ )
Automap_visited[i] = 1;
automap_build_edge_list(am);
am->max_segments_away = set_segment_depths(Objects[Players[Player_num].objnum].segnum, Automap_visited);
am->segment_limit = am->max_segments_away;
adjust_segment_limit(am, am->segment_limit);
}
return 1;
#endif
case KEY_F9:
if (am->segment_limit > 1) {
am->segment_limit--;
adjust_segment_limit(am, am->segment_limit);
}
return 1;
case KEY_F10:
if (am->segment_limit < am->max_segments_away) {
am->segment_limit++;
adjust_segment_limit(am, am->segment_limit);
}
return 1;
}
return 0;
}
//Process selected keys until game unpaused
int pause_handler(window *wind, d_event *event, char *msg)
{
int key;
switch (event->type)
{
case EVENT_WINDOW_ACTIVATED:
game_flush_inputs();
break;
case EVENT_KEY_COMMAND:
key = event_key_get(event);
switch (key)
{
case 0:
break;
case KEY_ESC:
window_close(wind);
return 1;
case KEY_F1:
show_help();
return 1;
case KEY_PAUSE:
window_close(wind);
return 1;
default:
break;
}
break;
case EVENT_IDLE:
timer_delay2(50);
break;
case EVENT_WINDOW_DRAW:
show_boxed_message(msg, 1);
break;
case EVENT_WINDOW_CLOSE:
songs_resume();
d_free(msg);
break;
default:
break;
}
return 0;
}
int object_dialog_handler(UI_DIALOG *, d_event *event, object_dialog *o)
{
dxxobject *obj=&Objects[Cur_object_index];
int keypress = 0;
int rval = 0;
if (event->type == EVENT_KEY_COMMAND)
keypress = event_key_get(event);
Assert(MattWindow != NULL);
//------------------------------------------------------------
// Call the ui code..
//------------------------------------------------------------
ui_button_any_drawn = 0;
if (event->type == EVENT_WINDOW_CLOSE)
{
d_free(o);
MattWindow = NULL;
return 0;
}
else if (event->type == EVENT_UI_DIALOG_DRAW)
{
ui_dprintf_at( MattWindow, 10, 132,"&X:" );
ui_dprintf_at( MattWindow, 10, 162,"&Y:" );
ui_dprintf_at( MattWindow, 10, 192,"&Z:" );
}
if ( GADGET_PRESSED(o->quitButton) || (keypress==KEY_ESC))
{
if (o->initialMode[0]->flag) obj->movement_type = MT_NONE;
if (o->initialMode[1]->flag) obj->movement_type = MT_SPINNING;
obj->mtype.spin_rate.x = fl2f(atof(o->xtext->text));
obj->mtype.spin_rate.y = fl2f(atof(o->ytext->text));
obj->mtype.spin_rate.z = fl2f(atof(o->ztext->text));
object_close_window();
return 1;
}
return rval;
}
window_event_result centers_dialog_handler(UI_DIALOG *dlg,const d_event &event, centers_dialog *c)
{
switch(event.type)
{
case EVENT_WINDOW_CREATED:
return centers_dialog_created(dlg, c);
case EVENT_WINDOW_CLOSE:
std::default_delete<centers_dialog>()(c);
MainWindow = NULL;
return window_event_result::ignored;
default:
break;
}
// int robot_flags;
int keypress = 0;
window_event_result rval = window_event_result::ignored;
Assert(MainWindow != NULL);
if (event.type == EVENT_KEY_COMMAND)
keypress = event_key_get(event);
//------------------------------------------------------------
// Call the ui code..
//------------------------------------------------------------
ui_button_any_drawn = 0;
//------------------------------------------------------------
// If we change centers, we need to reset the ui code for all
// of the checkboxes that control the center flags.
//------------------------------------------------------------
if (c->old_seg_num != Cursegp)
{
range_for (auto &i, c->centerFlag)
ui_radio_set_value(i.get(), 0);
Assert(Cursegp->special < MAX_CENTER_TYPES);
ui_radio_set_value(c->centerFlag[Cursegp->special].get(), 1);
// Read materialization center robot bit flags
for (unsigned i = 0, n = N_robot_types; i < n; ++i)
ui_checkbox_check(c->robotMatFlag[i].get(), RobotCenters[Cursegp->matcen_num].robot_flags[i / 32] & (1 << (i % 32)));
}
int automap_key_command(window *wind, d_event *event, automap *am)
{
int c = event_key_get(event);
int marker_num;
char maxdrop;
switch (c)
{
case KEY_PRINT_SCREEN: {
gr_set_current_canvas(NULL);
save_screen_shot(1);
return 1;
}
case KEY_ESC:
if (am->leave_mode==0)
{
window_close(wind);
return 1;
}
return 1;
#ifndef NDEBUG
case KEY_DEBUGGED+KEY_F: {
int i;
for (i=0; i<=Highest_segment_index; i++ )
Automap_visited[i] = 1;
automap_build_edge_list(am);
am->max_segments_away = set_segment_depths(Objects[Players[Player_num].objnum].segnum, Automap_visited);
am->segment_limit = am->max_segments_away;
adjust_segment_limit(am, am->segment_limit);
}
return 1;
#endif
case KEY_F9:
if (am->segment_limit > 1) {
am->segment_limit--;
adjust_segment_limit(am, am->segment_limit);
}
return 1;
case KEY_F10:
if (am->segment_limit < am->max_segments_away) {
am->segment_limit++;
adjust_segment_limit(am, am->segment_limit);
}
return 1;
case KEY_1:
case KEY_2:
case KEY_3:
case KEY_4:
case KEY_5:
case KEY_6:
case KEY_7:
case KEY_8:
case KEY_9:
case KEY_0:
if (Game_mode & GM_MULTI)
maxdrop=2;
else
maxdrop=9;
marker_num = c-KEY_1;
if (marker_num<=maxdrop)
{
if (MarkerObject[marker_num] != -1)
HighlightMarker=marker_num;
}
return 1;
case KEY_D+KEY_CTRLED:
if (HighlightMarker > -1 && MarkerObject[HighlightMarker] != -1) {
gr_set_current_canvas(NULL);
if (nm_messagebox( NULL, 2, TXT_YES, TXT_NO, "Delete Marker?" ) == 0) {
obj_delete(MarkerObject[HighlightMarker]);
MarkerObject[HighlightMarker]=-1;
MarkerMessage[HighlightMarker][0]=0;
HighlightMarker = -1;
}
set_screen_mode(SCREEN_GAME);
}
return 1;
#ifndef RELEASE
case KEY_F11: //KEY_COMMA:
if (MarkerScale>.5)
MarkerScale-=.5;
return 1;
case KEY_F12: //KEY_PERIOD:
if (MarkerScale<30.0)
MarkerScale+=.5;
return 1;
#endif
}
return 0;
}
int ui_listbox_do( UI_DIALOG *dlg, UI_GADGET_LISTBOX * listbox, d_event *event )
{
int mitem, oldfakepos, kf;
int keypress = 0;
int rval = 0;
if (event->type == EVENT_WINDOW_DRAW)
{
ui_draw_listbox( dlg, listbox );
return 0;
}
if (event->type == EVENT_KEY_COMMAND)
keypress = event_key_get(event);
listbox->selected_item = -1;
listbox->moved = 0;
if (listbox->num_items < 1 ) {
listbox->current_item = -1;
listbox->first_item = 0;
listbox->old_current_item = listbox->current_item;
listbox->old_first_item = listbox->first_item;
//ui_draw_listbox( dlg, listbox );
if (dlg->keyboard_focus_gadget == (UI_GADGET *)listbox)
{
dlg->keyboard_focus_gadget = ui_gadget_get_next((UI_GADGET *)listbox);
}
return rval;
}
listbox->old_current_item = listbox->current_item;
listbox->old_first_item = listbox->first_item;
if (GADGET_PRESSED(listbox->scrollbar))
{
listbox->moved = 1;
listbox->first_item = listbox->scrollbar->position;
if (listbox->current_item<listbox->first_item)
listbox->current_item = listbox->first_item;
if (listbox->current_item>(listbox->first_item+listbox->num_items_displayed-1))
listbox->current_item = listbox->first_item + listbox->num_items_displayed-1;
}
if (B1_JUST_RELEASED)
listbox->dragging = 0;
if (B1_JUST_PRESSED && ui_mouse_on_gadget( (UI_GADGET *)listbox ))
{
listbox->dragging = 1;
rval = 1;
}
if ( dlg->keyboard_focus_gadget==(UI_GADGET *)listbox )
{
if (keypress==KEY_ENTER) {
listbox->selected_item = listbox->current_item;
rval = 1;
}
kf = 0;
switch(keypress)
{
case (KEY_UP):
listbox->current_item--;
kf = 1;
break;
case (KEY_DOWN):
listbox->current_item++;
kf = 1;
break;
case (KEY_HOME):
listbox->current_item=0;
kf = 1;
break;
case (KEY_END):
listbox->current_item=listbox->num_items-1;
kf = 1;
break;
case (KEY_PAGEUP):
listbox->current_item -= listbox->num_items_displayed;
kf = 1;
break;
case (KEY_PAGEDOWN):
listbox->current_item += listbox->num_items_displayed;
kf = 1;
break;
}
if (kf==1)
{
listbox->moved = 1;
rval = 1;
if (listbox->current_item<0)
listbox->current_item=0;
if (listbox->current_item>=listbox->num_items)
listbox->current_item = listbox->num_items-1;
if (listbox->current_item<listbox->first_item)
listbox->first_item = listbox->current_item;
if (listbox->current_item>=(listbox->first_item+listbox->num_items_displayed))
listbox->first_item = listbox->current_item-listbox->num_items_displayed+1;
if (listbox->num_items <= listbox->num_items_displayed )
listbox->first_item = 0;
else
{
oldfakepos = listbox->scrollbar->position;
listbox->scrollbar->position = listbox->first_item;
listbox->scrollbar->fake_position = listbox->scrollbar->position-listbox->scrollbar->start;
listbox->scrollbar->fake_position *= listbox->scrollbar->height-listbox->scrollbar->fake_size;
listbox->scrollbar->fake_position /= (listbox->scrollbar->stop-listbox->scrollbar->start);
if (listbox->scrollbar->fake_position<0)
{
listbox->scrollbar->fake_position = 0;
}
if (listbox->scrollbar->fake_position > (listbox->scrollbar->height-listbox->scrollbar->fake_size))
{
listbox->scrollbar->fake_position = (listbox->scrollbar->height-listbox->scrollbar->fake_size);
}
if (oldfakepos != listbox->scrollbar->position )
listbox->scrollbar->status = 1;
}
}
}
if (selected_gadget==(UI_GADGET *)listbox)
{
if (listbox->dragging)
{
int x, y, z;
mouse_get_pos(&x, &y, &z);
if (y < listbox->y1)
mitem = -1;
else
mitem = (y - listbox->y1)/listbox->textheight;
if ((mitem < 0) && (timer_query() > listbox->last_scrolled + 1))
{
listbox->current_item--;
listbox->last_scrolled = timer_query();
listbox->moved = 1;
}
if ((mitem >= listbox->num_items_displayed) &&
(timer_query() > listbox->last_scrolled + 1))
{
listbox->current_item++;
listbox->last_scrolled = timer_query();
listbox->moved = 1;
}
if ((mitem>=0) && (mitem<listbox->num_items_displayed))
{
listbox->current_item = mitem+listbox->first_item;
listbox->moved=1;
}
if (listbox->current_item <0 )
listbox->current_item = 0;
if (listbox->current_item >= listbox->num_items )
listbox->current_item = listbox->num_items-1;
if (listbox->current_item<listbox->first_item)
listbox->first_item = listbox->current_item;
if (listbox->current_item>=(listbox->first_item+listbox->num_items_displayed))
listbox->first_item = listbox->current_item-listbox->num_items_displayed+1;
if (listbox->num_items <= listbox->num_items_displayed )
listbox->first_item = 0;
else
{
oldfakepos = listbox->scrollbar->position;
listbox->scrollbar->position = listbox->first_item;
listbox->scrollbar->fake_position = listbox->scrollbar->position-listbox->scrollbar->start;
listbox->scrollbar->fake_position *= listbox->scrollbar->height-listbox->scrollbar->fake_size;
listbox->scrollbar->fake_position /= (listbox->scrollbar->stop-listbox->scrollbar->start);
if (listbox->scrollbar->fake_position<0)
{
listbox->scrollbar->fake_position = 0;
}
if (listbox->scrollbar->fake_position > (listbox->scrollbar->height-listbox->scrollbar->fake_size))
{
listbox->scrollbar->fake_position = (listbox->scrollbar->height-listbox->scrollbar->fake_size);
}
if (oldfakepos != listbox->scrollbar->position )
listbox->scrollbar->status = 1;
}
}
if (B1_DOUBLE_CLICKED )
{
listbox->selected_item = listbox->current_item;
rval = 1;
}
}
if (listbox->moved || (listbox->selected_item > 0))
{
ui_gadget_send_event(dlg, (listbox->selected_item > 0) ? EVENT_UI_LISTBOX_SELECTED : EVENT_UI_LISTBOX_MOVED, (UI_GADGET *)listbox);
rval = 1;
}
return rval;
}
int robot_dialog_handler(UI_DIALOG *, d_event *event, robot_dialog *r)
{
int i;
fix DeltaTime;
fix64 Temp;
int first_object_index;
int keypress = 0;
int rval = 0;
if (event->type == EVENT_KEY_COMMAND)
keypress = event_key_get(event);
Assert(MainWindow != NULL);
first_object_index = Cur_object_index;
while (!is_legal_type_for_this_window(Cur_object_index)) {
LocalObjectSelectNextinMine();
if (first_object_index == Cur_object_index) {
break;
}
}
//------------------------------------------------------------
// Call the ui code..
//------------------------------------------------------------
ui_button_any_drawn = 0;
//------------------------------------------------------------
// If we change objects, we need to reset the ui code for all
// of the radio buttons that control the ai mode. Also makes
// the current AI mode button be flagged as pressed down.
//------------------------------------------------------------
if (r->old_object != Cur_object_index ) {
for ( i=0; i < NUM_BOXES; i++ )
ui_radio_set_value(r->initialMode[i], 0);
if ( Cur_object_index != object_none ) {
int behavior = Objects[Cur_object_index].ctype.ai_info.behavior;
if ( !((behavior >= MIN_BEHAVIOR) && (behavior <= MAX_BEHAVIOR))) {
Objects[Cur_object_index].ctype.ai_info.behavior = AIB_NORMAL;
behavior = AIB_NORMAL;
}
ui_radio_set_value(r->initialMode[behavior - MIN_BEHAVIOR], 1);
}
}
//------------------------------------------------------------
// If any of the radio buttons that control the mode are set, then
// update the cooresponding AI state.
//------------------------------------------------------------
for ( i=0; i < NUM_BOXES; i++ ) {
if ( GADGET_PRESSED(r->initialMode[i]) )
if (Objects[Cur_object_index].ctype.ai_info.behavior != MIN_BEHAVIOR+i) {
Objects[Cur_object_index].ctype.ai_info.behavior = MIN_BEHAVIOR+i; // Set the ai_state to the cooresponding radio button
call_init_ai_object(&Objects[Cur_object_index], MIN_BEHAVIOR+i);
rval = 1;
}
}
//------------------------------------------------------------
// Redraw the object in the little 64x64 box
//------------------------------------------------------------
if (event->type == EVENT_UI_DIALOG_DRAW)
{
// A simple frame time counter for spinning the objects...
Temp = timer_query();
DeltaTime = Temp - r->time;
r->time = Temp;
if (Cur_object_index != object_none ) {
dxxobject *obj = &Objects[Cur_object_index];
gr_set_current_canvas( r->robotViewBox->canvas );
draw_object_picture(obj->id, &r->angles, obj->type );
r->angles.h += fixmul(0x1000, DeltaTime );
} else {
// no object, so just blank out
gr_set_current_canvas( r->robotViewBox->canvas );
gr_clear_canvas( CGREY );
// LocalObjectSelectNextInMine();
}
}
//------------------------------------------------------------
// Redraw the contained object in the other little box
//------------------------------------------------------------
if (event->type == EVENT_UI_DIALOG_DRAW)
{
if ((Cur_object_index != object_none ) && (Cur_goody_count > 0)) {
gr_set_current_canvas( r->containsViewBox->canvas );
if ( Cur_goody_id > -1 )
draw_object_picture(Cur_goody_id, &r->goody_angles, Cur_goody_type);
else
gr_clear_canvas( CGREY );
r->goody_angles.h += fixmul(0x1000, DeltaTime );
} else {
// no object, so just blank out
gr_set_current_canvas( r->containsViewBox->canvas );
gr_clear_canvas( CGREY );
// LocalObjectSelectNextInMine();
}
}
//------------------------------------------------------------
// If anything changes in the ui system, redraw all the text that
// identifies this robot.
//------------------------------------------------------------
if (event->type == EVENT_UI_DIALOG_DRAW)
{
int i;
char id_text[STRING_LENGTH+1];
const char *type_text;
if (Cur_object_index != object_none) {
Cur_goody_type = Objects[Cur_object_index].contains_type;
Cur_goody_id = Objects[Cur_object_index].contains_id;
if (Objects[Cur_object_index].contains_count < 0)
Objects[Cur_object_index].contains_count = 0;
Cur_goody_count = Objects[Cur_object_index].contains_count;
}
ui_dprintf_at( MainWindow, GOODY_X, GOODY_Y, " Type:");
ui_dprintf_at( MainWindow, GOODY_X, GOODY_Y+24, " ID:");
ui_dprintf_at( MainWindow, GOODY_X, GOODY_Y+48, "Count:");
for (i=0; i<STRING_LENGTH; i++)
id_text[i] = ' ';
id_text[i] = 0;
switch (Cur_goody_type) {
case OBJ_ROBOT:
type_text = "Robot ";
strncpy(id_text, Robot_names[Cur_goody_id], strlen(Robot_names[Cur_goody_id]));
break;
case OBJ_POWERUP:
type_text = "Powerup";
strncpy(id_text, Powerup_names[Cur_goody_id], strlen(Powerup_names[Cur_goody_id]));
break;
default:
editor_status("Illegal contained object type (%i), changing to powerup.", Cur_goody_type);
Cur_goody_type = OBJ_POWERUP;
Cur_goody_id = 0;
type_text = "Powerup";
strncpy(id_text, Powerup_names[Cur_goody_id], strlen(Powerup_names[Cur_goody_id]));
break;
}
ui_dprintf_at( MainWindow, GOODY_X+108, GOODY_Y, "%s", type_text);
ui_dprintf_at( MainWindow, GOODY_X+108, GOODY_Y+24, "%s", id_text);
ui_dprintf_at( MainWindow, GOODY_X+108, GOODY_Y+48, "%i", Cur_goody_count);
if ( Cur_object_index != object_none ) {
int id = Objects[Cur_object_index].id;
char id_text[12];
int i;
for (i=0; i<STRING_LENGTH; i++)
id_text[i] = ' ';
id_text[i] = 0;
strncpy(id_text, Robot_names[id], strlen(Robot_names[id]));
ui_dprintf_at( MainWindow, 12, 6, "Robot: %3u ", static_cast<unsigned>(Cur_object_index) );
ui_dprintf_at( MainWindow, 12, 22, " Id: %3d", id);
ui_dprintf_at( MainWindow, 12, 38, " Name: %8s", id_text);
} else {
ui_dprintf_at( MainWindow, 12, 6, "Robot: none" );
ui_dprintf_at( MainWindow, 12, 22, " Type: ? " );
ui_dprintf_at( MainWindow, 12, 38, " Name: ________" );
}
}
if (ui_button_any_drawn || (r->old_object != Cur_object_index) )
Update_flags |= UF_WORLD_CHANGED;
if (event->type == EVENT_WINDOW_CLOSE)
{
d_free(r);
MainWindow = NULL;
return 0;
}
if ( GADGET_PRESSED(r->quitButton) || (keypress==KEY_ESC))
{
robot_close_window();
return 1;
}
r->old_object = Cur_object_index;
return rval;
}
// Default event handler for everything except the editor
window_event_result standard_handler(const d_event &event)
{
int key;
if (Quitting)
{
window *wind = window_get_front();
if (!wind)
return window_event_result::ignored; // finished quitting
if (wind == Game_wind)
{
int choice;
Quitting = 0;
choice=nm_messagebox( NULL, 2, TXT_YES, TXT_NO, TXT_ABORT_GAME );
if (choice != 0)
return window_event_result::handled; // aborted quitting
else
{
CGameArg.SysAutoDemo = false;
Quitting = 1;
}
}
// Close front window, let the code flow continue until all windows closed or quit cancelled
if (!window_close(wind))
{
Quitting = 0;
return window_event_result::handled;
}
return window_event_result::deleted; // tell the event system we deleted some window
}
switch (event.type)
{
case EVENT_MOUSE_BUTTON_DOWN:
case EVENT_MOUSE_BUTTON_UP:
// No window selecting
// We stay with the current one until it's closed/hidden or another one is made
// Not the case for the editor
break;
case EVENT_KEY_COMMAND:
key = event_key_get(event);
switch (key)
{
#ifdef macintosh
case KEY_COMMAND + KEY_SHIFTED + KEY_3:
#endif
case KEY_PRINT_SCREEN:
{
gr_set_current_canvas(NULL);
save_screen_shot(0);
return window_event_result::handled;
}
case KEY_ALTED+KEY_ENTER:
case KEY_ALTED+KEY_PADENTER:
if (Game_wind)
if (Game_wind == window_get_front())
return window_event_result::ignored;
gr_toggle_fullscreen();
return window_event_result::handled;
#if defined(__APPLE__) || defined(macintosh)
case KEY_COMMAND+KEY_Q:
// Alt-F4 already taken, too bad
Quitting = 1;
return window_event_result::handled;
#endif
case KEY_SHIFTED + KEY_ESC:
con_showup();
return window_event_result::handled;
}
break;
case EVENT_WINDOW_DRAW:
case EVENT_IDLE:
//see if redbook song needs to be restarted
RBACheckFinishedHook();
return window_event_result::handled;
case EVENT_QUIT:
#if DXX_USE_EDITOR
if (SafetyCheck())
#endif
Quitting = 1;
return window_event_result::handled;
default:
break;
}
return window_event_result::ignored;
}
int trigger_dialog_handler(UI_DIALOG *dlg, d_event *event, trigger_dialog *t)
{
int i;
short Markedwall, trigger_num;
int keypress = 0;
int rval = 0;
Assert(MainWindow != NULL);
if (!Markedsegp) {
close_trigger_window();
return 0;
}
//------------------------------------------------------------
// Call the ui code..
//------------------------------------------------------------
ui_button_any_drawn = 0;
if (event->type == EVENT_KEY_COMMAND)
keypress = event_key_get(event);
//------------------------------------------------------------
// If we change walls, we need to reset the ui code for all
// of the checkboxes that control the wall flags.
//------------------------------------------------------------
Markedwall = Markedsegp->sides[Markedside].wall_num;
if (Markedwall != -1)
trigger_num = Walls[Markedwall].trigger;
else trigger_num = -1;
if (t->old_trigger_num != trigger_num)
{
if (trigger_num != -1)
{
trigger *trig = &Triggers[trigger_num];
ui_checkbox_check(t->triggerFlag[0], trig->flags & TRIGGER_CONTROL_DOORS);
ui_checkbox_check(t->triggerFlag[1], trig->flags & TRIGGER_SHIELD_DAMAGE);
ui_checkbox_check(t->triggerFlag[2], trig->flags & TRIGGER_ENERGY_DRAIN);
ui_checkbox_check(t->triggerFlag[3], trig->flags & TRIGGER_EXIT);
ui_checkbox_check(t->triggerFlag[4], trig->flags & TRIGGER_ONE_SHOT);
ui_checkbox_check(t->triggerFlag[5], trig->flags & TRIGGER_ILLUSION_ON);
ui_checkbox_check(t->triggerFlag[6], trig->flags & TRIGGER_ILLUSION_OFF);
ui_checkbox_check(t->triggerFlag[7], trig->flags & TRIGGER_ON);
ui_checkbox_check(t->triggerFlag[8], trig->flags & TRIGGER_MATCEN);
ui_checkbox_check(t->triggerFlag[9], trig->flags & TRIGGER_SECRET_EXIT);
}
}
//------------------------------------------------------------
// If any of the checkboxes that control the wallflags are set, then
// update the cooresponding wall flag.
//------------------------------------------------------------
if (IS_CHILD(Markedsegp->children[Markedside]))
{
rval = 1;
if (GADGET_PRESSED(t->triggerFlag[0]))
trigger_flag_Markedside(TRIGGER_CONTROL_DOORS, t->triggerFlag[0]->flag);
else if (GADGET_PRESSED(t->triggerFlag[1]))
trigger_flag_Markedside(TRIGGER_SHIELD_DAMAGE, t->triggerFlag[1]->flag);
else if (GADGET_PRESSED(t->triggerFlag[2]))
trigger_flag_Markedside(TRIGGER_ENERGY_DRAIN, t->triggerFlag[2]->flag);
else if (GADGET_PRESSED(t->triggerFlag[3]))
trigger_flag_Markedside(TRIGGER_EXIT, t->triggerFlag[3]->flag);
else if (GADGET_PRESSED(t->triggerFlag[4]))
trigger_flag_Markedside(TRIGGER_ONE_SHOT, t->triggerFlag[4]->flag);
else if (GADGET_PRESSED(t->triggerFlag[5]))
trigger_flag_Markedside(TRIGGER_ILLUSION_ON, t->triggerFlag[5]->flag);
else if (GADGET_PRESSED(t->triggerFlag[6]))
trigger_flag_Markedside(TRIGGER_ILLUSION_OFF, t->triggerFlag[6]->flag);
else if (GADGET_PRESSED(t->triggerFlag[7]))
trigger_flag_Markedside(TRIGGER_ON, t->triggerFlag[7]->flag);
else if (GADGET_PRESSED(t->triggerFlag[8]))
trigger_flag_Markedside(TRIGGER_MATCEN, t->triggerFlag[8]->flag);
else if (GADGET_PRESSED(t->triggerFlag[9]))
trigger_flag_Markedside(TRIGGER_SECRET_EXIT, t->triggerFlag[9]->flag);
else
rval = 0;
} else
for (i = 0; i < NUM_TRIGGER_FLAGS; i++ )
ui_checkbox_check(t->triggerFlag[i], 0);
//------------------------------------------------------------
// Draw the wall in the little 64x64 box
//------------------------------------------------------------
if (event->type == EVENT_UI_DIALOG_DRAW)
{
gr_set_current_canvas( t->wallViewBox->canvas );
if ((Markedsegp->sides[Markedside].wall_num == -1) || (Walls[Markedsegp->sides[Markedside].wall_num].trigger) == -1)
gr_clear_canvas( CBLACK );
else {
if (Markedsegp->sides[Markedside].tmap_num2 > 0) {
gr_ubitmap(0,0, texmerge_get_cached_bitmap( Markedsegp->sides[Markedside].tmap_num, Markedsegp->sides[Markedside].tmap_num2));
} else {
if (Markedsegp->sides[Markedside].tmap_num > 0) {
PIGGY_PAGE_IN(Textures[Markedsegp->sides[Markedside].tmap_num]);
gr_ubitmap(0,0, &GameBitmaps[Textures[Markedsegp->sides[Markedside].tmap_num].index]);
} else
gr_clear_canvas( CGREY );
}
}
}
//------------------------------------------------------------
// If anything changes in the ui system, redraw all the text that
// identifies this robot.
//------------------------------------------------------------
if (event->type == EVENT_UI_DIALOG_DRAW)
{
if ( Markedsegp->sides[Markedside].wall_num > -1 ) {
ui_dprintf_at( MainWindow, 12, 6, "Trigger: %d ", trigger_num);
} else {
ui_dprintf_at( MainWindow, 12, 6, "Trigger: none ");
}
}
if (ui_button_any_drawn || (t->old_trigger_num != trigger_num) )
Update_flags |= UF_WORLD_CHANGED;
if (event->type == EVENT_WINDOW_CLOSE)
{
d_free(t);
MainWindow = NULL;
return 0;
}
if ( GADGET_PRESSED(t->quitButton) || (keypress==KEY_ESC))
{
close_trigger_window();
return 1;
}
t->old_trigger_num = trigger_num;
return rval;
}
int scores_handler(window *wind, d_event *event, scores_menu *menu)
{
int i;
int k;
sbyte fades[64] = { 1,1,1,2,2,3,4,4,5,6,8,9,10,12,13,15,16,17,19,20,22,23,24,26,27,28,28,29,30,30,31,31,31,31,31,30,30,29,28,28,27,26,24,23,22,20,19,17,16,15,13,12,10,9,8,6,5,4,4,3,2,2,1,1 };
int w = FSPACX(290), h = FSPACY(170);
switch (event->type)
{
case EVENT_WINDOW_ACTIVATED:
game_flush_inputs();
break;
case EVENT_KEY_COMMAND:
k = event_key_get(event);
switch( k ) {
case KEY_CTRLED+KEY_R:
if ( menu->citem < 0 ) {
// Reset scores...
if ( nm_messagebox( NULL, 2, TXT_NO, TXT_YES, TXT_RESET_HIGH_SCORES )==1 ) {
PHYSFS_delete(SCORES_FILENAME);
scores_view(&menu->last_game, menu->citem); // create new scores window
window_close(wind); // then remove the old one
}
}
return 1;
case KEY_ENTER:
case KEY_SPACEBAR:
case KEY_ESC:
window_close(wind);
return 1;
}
break;
case EVENT_MOUSE_BUTTON_DOWN:
case EVENT_MOUSE_BUTTON_UP:
if (event_mouse_get_button(event) == MBTN_LEFT || event_mouse_get_button(event) == MBTN_RIGHT)
{
window_close(wind);
return 1;
}
break;
case EVENT_IDLE:
timer_delay2(50);
break;
case EVENT_WINDOW_DRAW:
gr_set_current_canvas(NULL);
nm_draw_background(((SWIDTH-w)/2)-BORDERX,((SHEIGHT-h)/2)-BORDERY,((SWIDTH-w)/2)+w+BORDERX,((SHEIGHT-h)/2)+h+BORDERY);
gr_set_current_canvas(window_get_canvas(wind));
grd_curcanv->cv_font = MEDIUM3_FONT;
gr_string( 0x8000, FSPACY(15), TXT_HIGH_SCORES );
grd_curcanv->cv_font = GAME_FONT;
gr_set_fontcolor( BM_XRGB(31,26,5), -1 );
gr_string( FSPACX( 71), FSPACY(50), TXT_NAME );
gr_string( FSPACX(122), FSPACY(50), TXT_SCORE );
gr_string( FSPACX(167), FSPACY(50), TXT_SKILL );
gr_string( FSPACX(210), FSPACY(50), TXT_LEVELS );
gr_string( FSPACX(253), FSPACY(50), TXT_TIME );
if ( menu->citem < 0 )
gr_string( 0x8000, FSPACY(175), TXT_PRESS_CTRL_R );
gr_set_fontcolor( BM_XRGB(28,28,28), -1 );
gr_printf( 0x8000, FSPACY(31), "%c%s%c - %s", 34, menu->scores.cool_saying, 34, menu->scores.stats[0].name );
for (i=0; i<MAX_HIGH_SCORES; i++ ) {
gr_set_fontcolor( BM_XRGB(28-i*2,28-i*2,28-i*2), -1 );
scores_draw_item( i, &menu->scores.stats[i] );
}
if ( menu->citem > -1 ) {
gr_set_fontcolor( BM_XRGB(7+fades[menu->looper],7+fades[menu->looper],7+fades[menu->looper]), -1 );
if (timer_query() >= menu->t1+F1_0/128)
{
menu->t1 = timer_query();
menu->looper++;
if (menu->looper>63) menu->looper=0;
}
if ( menu->citem == MAX_HIGH_SCORES )
scores_draw_item( MAX_HIGH_SCORES, &menu->last_game );
else
scores_draw_item( menu->citem, &menu->scores.stats[menu->citem] );
}
gr_set_current_canvas(NULL);
break;
case EVENT_WINDOW_CLOSE:
d_free(menu);
break;
default:
break;
}
return 0;
}
static window_event_result do_state_2(const d_event &event)
{
int i;
int keypress = 0;
window_event_result rval = window_event_result::ignored;
if (event.type == EVENT_KEY_COMMAND)
keypress = event_key_get(event);
if (keypress & KEY_ALTED)
{
state2_alt_down = 1;
rval = window_event_result::handled;
}
if ((event.type == EVENT_KEY_RELEASE) && !(event_key_get(event) & KEY_ALTED) && state2_alt_down)
{
state = 0;
menu_hide_all();
rval = window_event_result::handled;
}
switch( keypress )
{
case KEY_ESC:
state = 0;
menu_hide_all();
return window_event_result::handled;
case KEY_LEFT:
case KEY_PAD4:
i = Menu[0].CurrentItem-1;
if (i < 0 ) i = Menu[0].NumItems-1;
menu_move_bar_to( &Menu[0], i );
return window_event_result::handled;
case KEY_RIGHT:
case KEY_PAD6:
i = Menu[0].CurrentItem+1;
if (i >= Menu[0].NumItems ) i = 0;
menu_move_bar_to( &Menu[0], i );
return window_event_result::handled;
case KEY_ENTER:
case KEY_PADENTER:
case KEY_DOWN:
case KEY_PAD2:
state = 3;
Menu[ CMENU ].ShowBar = 1;
Menu[ CMENU ].Active = 1;
Menu[0].Active = 0;
window_set_modal(Menu[0].wind, 0);
menu_show( &Menu[ 0 ] );
menu_show( &Menu[ CMENU ] );
return window_event_result::handled;
default:
i = menu_match_keypress( &Menu[0], keypress );
if (i > -1 )
{
Menu[0].CurrentItem = i;
Menu[0].Active = 0;
window_set_modal(Menu[0].wind, 0);
state = 3;
Menu[ CMENU ].ShowBar = 1;
Menu[ CMENU ].Active = 1;
Menu[0].ShowBar = 1;
menu_show( &Menu[ CMENU ] );
menu_show( &Menu[0] );
return window_event_result::handled;
}
i = menu_check_mouse_item( &Menu[0] );
if ( (i == -1) && B1_JUST_RELEASED )
{
state = 0;
menu_hide_all();
return window_event_result::handled;
}
if (i > -1)
{
Menu[0].CurrentItem = i;
Menu[0].Active = 0;
window_set_modal(Menu[0].wind, 0);
state = 3;
Menu[ CMENU ].ShowBar = 1;
Menu[ CMENU ].Active = 1;
Menu[0].ShowBar = 1;
menu_show( &Menu[ CMENU ] );
menu_show( &Menu[0] );
return window_event_result::handled;
}
}
return rval;
}
// Handler for the main editor dialog
int editor_handler(UI_DIALOG *dlg, d_event *event, void *data)
{
editor_view *new_cv;
int keypress = 0;
int rval = 0;
if (event->type == EVENT_KEY_COMMAND)
keypress = event_key_get(event);
else if (event->type == EVENT_WINDOW_CLOSE)
{
close_editor();
EditorWindow = NULL;
return 0;
}
// Update the windows
if (event->type == EVENT_UI_DIALOG_DRAW)
{
gr_set_curfont(editor_font);
// Draw status box
gr_set_current_canvas( NULL );
gr_setcolor( CGREY );
gr_rect(STATUS_X,STATUS_Y,STATUS_X+STATUS_W-1,STATUS_Y+STATUS_H-1); //0, 582, 799, 599 );
medlisp_update_screen();
calc_frame_time();
texpage_do(event);
objpage_do(event);
ui_pad_draw(EditorWindow, PAD_X, PAD_Y);
print_status_bar(status_line);
TimedAutosave(mine_filename); // shows the time, hence here
set_editor_time_of_day();
return 1;
}
if ((selected_gadget == (UI_GADGET *)GameViewBox && !render_3d_in_big_window) ||
(selected_gadget == (UI_GADGET *)LargeViewBox && render_3d_in_big_window))
switch (event->type)
{
case EVENT_MOUSE_BUTTON_UP:
case EVENT_MOUSE_BUTTON_DOWN:
break;
case EVENT_MOUSE_MOVED:
if (!keyd_pressed[ KEY_LCTRL ] && !keyd_pressed[ KEY_RCTRL ])
break;
case EVENT_JOYSTICK_BUTTON_UP:
case EVENT_JOYSTICK_BUTTON_DOWN:
case EVENT_JOYSTICK_MOVED:
case EVENT_KEY_COMMAND:
case EVENT_KEY_RELEASE:
case EVENT_IDLE:
kconfig_read_controls(event, 1);
if (slew_frame(0))
{ //do movement and check keys
Update_flags |= UF_GAME_VIEW_CHANGED;
if (Gameview_lockstep)
{
Cursegp = &Segments[ConsoleObject->segnum];
med_create_new_segment_from_cursegp();
Update_flags |= UF_ED_STATE_CHANGED;
}
rval = 1;
}
break;
default:
break;
}
//do non-essential stuff in idle event
if (event->type == EVENT_IDLE)
{
check_wall_validity();
Assert(Num_walls>=0);
if (Gameview_lockstep) {
static segment *old_cursegp=NULL;
static int old_curside=-1;
if (old_cursegp!=Cursegp || old_curside!=Curside) {
SetPlayerFromCursegMinusOne();
old_cursegp = Cursegp;
old_curside = Curside;
}
}
if ( event_get_idle_seconds() > COMPRESS_INTERVAL )
{
med_compress_mine();
event_reset_idle_seconds();
}
// Commented out because it occupies about 25% of time in twirling the mine.
// Removes some Asserts....
// med_check_all_vertices();
clear_editor_status(); // if enough time elapsed, clear editor status message
}
gr_set_current_canvas( GameViewBox->canvas );
// Remove keys used for slew
switch(keypress)
{
case KEY_PAD9:
case KEY_PAD7:
case KEY_PADPLUS:
case KEY_PADMINUS:
case KEY_PAD8:
case KEY_PAD2:
case KEY_LBRACKET:
case KEY_RBRACKET:
case KEY_PAD1:
case KEY_PAD3:
case KEY_PAD6:
case KEY_PAD4:
keypress = 0;
}
if ((keypress&0xff)==KEY_LSHIFT) keypress=0;
if ((keypress&0xff)==KEY_RSHIFT) keypress=0;
if ((keypress&0xff)==KEY_LCTRL) keypress=0;
if ((keypress&0xff)==KEY_RCTRL) keypress=0;
// if ((keypress&0xff)==KEY_LALT) keypress=0;
// if ((keypress&0xff)==KEY_RALT) keypress=0;
//=================== DO FUNCTIONS ====================
if ( KeyFunction[ keypress ] != NULL )
{
KeyFunction[keypress]();
keypress = 0;
rval = 1;
}
switch (keypress)
{
case 0:
case KEY_Z:
case KEY_G:
case KEY_LALT:
case KEY_RALT:
case KEY_LCTRL:
case KEY_RCTRL:
case KEY_LSHIFT:
case KEY_RSHIFT:
case KEY_LAPOSTRO:
break;
case KEY_SHIFTED + KEY_L:
ToggleLighting();
rval = 1;
break;
case KEY_F1:
render_3d_in_big_window = !render_3d_in_big_window;
Update_flags |= UF_ALL;
rval = 1;
break;
default:
if (!rval)
{
char kdesc[100];
GetKeyDescription( kdesc, keypress );
editor_status_fmt("Error: %s isn't bound to anything.", kdesc );
}
}
//================================================================
if (ModeFlag)
{
ui_close_dialog(EditorWindow);
return 0;
}
// if (EditorWindow->keyboard_focus_gadget == (UI_GADGET *)GameViewBox) current_view=NULL;
// if (EditorWindow->keyboard_focus_gadget == (UI_GADGET *)GroupViewBox) current_view=NULL;
new_cv = current_view;
#if ORTHO_VIEWS
if (EditorWindow->keyboard_focus_gadget == (UI_GADGET *)LargeViewBox) new_cv=&LargeView;
if (EditorWindow->keyboard_focus_gadget == (UI_GADGET *)TopViewBox) new_cv=&TopView;
if (EditorWindow->keyboard_focus_gadget == (UI_GADGET *)FrontViewBox) new_cv=&FrontView;
if (EditorWindow->keyboard_focus_gadget == (UI_GADGET *)RightViewBox) new_cv=&RightView;
#endif
if (new_cv != current_view ) {
current_view->ev_changed = 1;
new_cv->ev_changed = 1;
current_view = new_cv;
}
// DO TEXTURE STUFF
if (texpage_do(event))
rval = 1;
if (objpage_do(event))
rval = 1;
// Process selection of Cursegp using mouse.
if (GADGET_PRESSED(LargeViewBox) && !render_3d_in_big_window)
{
int xcrd,ycrd;
xcrd = LargeViewBox->b1_drag_x1;
ycrd = LargeViewBox->b1_drag_y1;
find_segments(xcrd,ycrd,LargeViewBox->canvas,&LargeView,Cursegp,Big_depth); // Sets globals N_found_segs, Found_segs
// If shift is down, then add segment to found list
if (keyd_pressed[ KEY_LSHIFT ] || keyd_pressed[ KEY_RSHIFT ])
subtract_found_segments_from_selected_list();
else
add_found_segments_to_selected_list();
Found_seg_index = 0;
if (N_found_segs > 0) {
sort_seg_list(N_found_segs,Found_segs,&ConsoleObject->pos);
Cursegp = &Segments[Found_segs[0]];
med_create_new_segment_from_cursegp();
if (Lock_view_to_cursegp)
set_view_target_from_segment(Cursegp);
}
Update_flags |= UF_ED_STATE_CHANGED | UF_VIEWPOINT_MOVED;
}
if ((event->type == EVENT_UI_USERBOX_DRAGGED) && (ui_event_get_gadget(event) == (UI_GADGET *)GameViewBox))
{
int x, y;
x = GameViewBox->b1_drag_x2;
y = GameViewBox->b1_drag_y2;
gr_set_current_canvas( GameViewBox->canvas );
gr_setcolor( 15 );
gr_rect( x-1, y-1, x+1, y+1 );
}
// Set current segment and side by clicking on a polygon in game window.
// If ctrl pressed, also assign current texture map to that side.
//if (GameViewBox->mouse_onme && (GameViewBox->b1_done_dragging || GameViewBox->b1_clicked)) {
if ((GADGET_PRESSED(GameViewBox) && !render_3d_in_big_window) ||
(GADGET_PRESSED(LargeViewBox) && render_3d_in_big_window))
{
int xcrd,ycrd;
int seg,side,face,poly,tmap;
if (render_3d_in_big_window) {
xcrd = LargeViewBox->b1_drag_x1;
ycrd = LargeViewBox->b1_drag_y1;
}
else {
xcrd = GameViewBox->b1_drag_x1;
ycrd = GameViewBox->b1_drag_y1;
}
//Int3();
if (find_seg_side_face(xcrd,ycrd,&seg,&side,&face,&poly)) {
if (seg<0) { //found an object
Cur_object_index = -seg-1;
editor_status_fmt("Object %d selected.",Cur_object_index);
Update_flags |= UF_ED_STATE_CHANGED;
}
else {
// See if either shift key is down and, if so, assign texture map
if (keyd_pressed[KEY_LSHIFT] || keyd_pressed[KEY_RSHIFT]) {
Cursegp = &Segments[seg];
Curside = side;
AssignTexture();
med_create_new_segment_from_cursegp();
editor_status("Texture assigned");
} else if (keyd_pressed[KEY_G]) {
tmap = Segments[seg].sides[side].tmap_num;
texpage_grab_current(tmap);
editor_status( "Texture grabbed." );
} else if (keyd_pressed[ KEY_LAPOSTRO] ) {
move_object_to_mouse_click();
} else {
Cursegp = &Segments[seg];
Curside = side;
med_create_new_segment_from_cursegp();
editor_status("Curseg and curside selected");
}
}
Update_flags |= UF_ED_STATE_CHANGED;
}
else
editor_status("Click on non-texture ingored");
}
// Allow specification of LargeView using mouse
if (event->type == EVENT_MOUSE_MOVED && (keyd_pressed[ KEY_LCTRL ] || keyd_pressed[ KEY_RCTRL ]))
{
int dx, dy, dz;
event_mouse_get_delta(event, &dx, &dy, &dz);
if ((dx != 0) && (dy != 0))
{
vms_matrix MouseRotMat,tempm;
GetMouseRotation( dx, dy, &MouseRotMat );
vm_matrix_x_matrix(&tempm,&LargeView.ev_matrix,&MouseRotMat);
LargeView.ev_matrix = tempm;
LargeView.ev_changed = 1;
Large_view_index = -1; // say not one of the orthogonal views
rval = 1;
}
}
if (event->type == EVENT_MOUSE_MOVED)
{
int dx, dy, dz;
event_mouse_get_delta(event, &dx, &dy, &dz);
if (dz != 0)
{
current_view->ev_dist += dz*10000;
current_view->ev_changed = 1;
}
}
return rval;
}
static window_event_result do_state_0(const d_event &event)
{
int keypress = 0;
if (event.type == EVENT_KEY_COMMAND)
keypress = event_key_get(event);
Menu[0].Active = 0;
if (Menu[0].wind)
window_set_modal(Menu[0].wind, 0);
Menu[0].ShowBar = 0;
if ( keypress & KEY_ALTED ) {
const auto i = menu_match_keypress( &Menu[0], keypress );
if (i > -1 )
{
Menu[0].CurrentItem = i;
Menu[0].Active = 0;
if (Menu[0].wind)
window_set_modal(Menu[0].wind, 0);
state = 3;
Menu[ CMENU ].ShowBar = 1;
Menu[ CMENU ].Active = 1;
Menu[0].ShowBar = 1;
menu_show( &Menu[ CMENU ] );
menu_show( &Menu[0] );
return window_event_result::handled;
}
}
range_for (auto &i, partial_const_range(Menu, num_menus))
range_for (auto &j, partial_const_range(i.Item, i.NumItems))
{
if ( j.Hotkey == keypress )
{
if (j.user_function)
j.user_function();
return window_event_result::handled;
}
}
if (keypress & KEY_ALTED)
//if ( (keypress & 0xFF) == KEY_LALT )
{
// Make sure the menubar receives events exclusively
state = 1;
Menu[0].Active = 1;
// Put the menubar in front - hope this doesn't mess anything up by leaving it there
// If it does, will need to remember the previous front window and restore it.
// (Personally, I just use either the mouse or 'hotkeys' for menus)
window_select(*Menu[0].wind);
window_set_modal(Menu[0].wind, 1);
menu_show( &Menu[0] );
return window_event_result::handled;
}
const auto i = menu_check_mouse_item( &Menu[0] );
if ( B1_JUST_PRESSED && (i > -1))
{
Menu[0].CurrentItem = i;
state = 3;
Menu[ CMENU ].ShowBar = 1;
Menu[0].ShowBar = 1;
Menu[ CMENU ].Active = 1;
Menu[0].Active = 0;
window_set_modal(Menu[0].wind, 0);
menu_show( &Menu[ CMENU ] );
menu_show( &Menu[0] );
return window_event_result::handled;
}
return window_event_result::ignored;
}
static window_event_result do_state_1(const d_event &event)
{
int i;
int keypress = 0;
window_event_result rval = window_event_result::ignored;
if (event.type == EVENT_KEY_COMMAND)
keypress = event_key_get(event);
if ((event.type == EVENT_KEY_RELEASE) && !(event_key_get(event) & KEY_ALTED))
{
state = 2;
state2_alt_down = 0;
Menu[0].ShowBar = 1;
Menu[0].Active = 1;
menu_show( &Menu[0] );
rval = window_event_result::handled;
}
i = menu_match_keypress( &Menu[0], keypress );
if (i > -1 )
{
Menu[0].CurrentItem = i;
Menu[0].Active = 0;
window_set_modal(Menu[0].wind, 0);
state = 3;
Menu[ CMENU ].ShowBar = 1;
Menu[ CMENU ].Active = 1;
Menu[0].ShowBar = 1;
menu_show( &Menu[ CMENU ] );
menu_show( &Menu[0] );
rval = window_event_result::handled;
}
i = menu_check_mouse_item( &Menu[0] );
if ( (i == -1) && B1_JUST_RELEASED )
{
state = 0;
menu_hide_all();
return window_event_result::handled;
}
if ( B1_JUST_PRESSED && (i > -1))
{
Menu[0].CurrentItem = i;
state = 3;
Menu[ CMENU ].ShowBar = 1;
Menu[ CMENU ].Active = 1;
Menu[0].ShowBar = 1;
Menu[0].Active = 0;
window_set_modal(Menu[0].wind, 0);
menu_show( &Menu[ CMENU ] );
menu_show( &Menu[0] );
return window_event_result::handled;
}
return rval;
}
int do_state_0(d_event *event)
{
int i, j;
int keypress = 0;
if (event->type == EVENT_KEY_COMMAND)
keypress = event_key_get(event);
Menu[0].Active = 0;
if (Menu[0].wind)
window_set_modal(Menu[0].wind, 0);
Menu[0].ShowBar = 0;
if ( keypress & KEY_ALTED ) {
i = menu_match_keypress( &Menu[0], keypress );
if (i > -1 )
{
Menu[0].CurrentItem = i;
Menu[0].Active = 0;
if (Menu[0].wind)
window_set_modal(Menu[0].wind, 0);
state = 3;
Menu[ CMENU ].ShowBar = 1;
Menu[ CMENU ].Active = 1;
Menu[0].ShowBar = 1;
menu_show( &Menu[ CMENU ] );
menu_show( &Menu[0] );
return 1;
}
}
for (i=0; i<num_menus; i++ )
for (j=0; j< Menu[i].NumItems; j++ )
{
if ( Menu[i].Item[j].Hotkey == keypress )
{
if (Menu[i].Item[j].user_function)
Menu[i].Item[j].user_function();
return 1;
}
}
if (keypress & KEY_ALTED)
//if ( (keypress & 0xFF) == KEY_LALT )
{
// Make sure the menubar receives events exclusively
state = 1;
Menu[0].Active = 1;
// Put the menubar in front - hope this doesn't mess anything up by leaving it there
// If it does, will need to remember the previous front window and restore it.
// (Personally, I just use either the mouse or 'hotkeys' for menus)
window_select(Menu[0].wind);
window_set_modal(Menu[0].wind, 1);
menu_show( &Menu[0] );
return 1;
}
i = menu_check_mouse_item( &Menu[0] );
if ( B1_JUST_PRESSED && (i > -1))
{
Menu[0].CurrentItem = i;
state = 3;
Menu[ CMENU ].ShowBar = 1;
Menu[0].ShowBar = 1;
Menu[ CMENU ].Active = 1;
Menu[0].Active = 0;
window_set_modal(Menu[0].wind, 0);
menu_show( &Menu[ CMENU ] );
menu_show( &Menu[0] );
return 1;
}
return 0;
}
int ui_inputbox_do( UI_DIALOG *dlg, UI_GADGET_INPUTBOX * inputbox, d_event *event )
{
unsigned char ascii;
int keypress = 0;
int rval = 0;
if (event->type == EVENT_KEY_COMMAND)
keypress = event_key_get(event);
inputbox->oldposition = inputbox->position;
inputbox->pressed=0;
if (dlg->keyboard_focus_gadget==(UI_GADGET *)inputbox)
{
switch( keypress )
{
case 0:
break;
case (KEY_LEFT):
case (KEY_BACKSP):
if (inputbox->position > 0)
inputbox->position--;
inputbox->text[inputbox->position] = 0;
inputbox->status = 1;
if (inputbox->first_time) inputbox->first_time = 0;
rval = 1;
break;
case (KEY_ENTER):
inputbox->pressed=1;
inputbox->status = 1;
if (inputbox->first_time) inputbox->first_time = 0;
rval = 1;
break;
default:
ascii = key_ascii();
if ((ascii < 255 ) && (inputbox->position < inputbox->length-2))
{
if (inputbox->first_time) {
inputbox->first_time = 0;
inputbox->position = 0;
}
inputbox->text[inputbox->position++] = ascii;
inputbox->text[inputbox->position] = 0;
rval = 1;
}
inputbox->status = 1;
break;
}
} else {
inputbox->first_time = 1;
}
if (inputbox->pressed)
{
ui_gadget_send_event(dlg, EVENT_UI_GADGET_PRESSED, (UI_GADGET *)inputbox);
rval = 1;
}
if (event->type == EVENT_WINDOW_DRAW)
ui_draw_inputbox( dlg, inputbox );
return rval;
}
int kmatrix_handler(window *wind, d_event *event, kmatrix_screen *km)
{
int i = 0, k = 0, choice = 0;
switch (event->type)
{
case EVENT_KEY_COMMAND:
k = event_key_get(event);
switch( k )
{
case KEY_ESC:
if (km->network)
{
StartAbortMenuTime=timer_query();
choice=nm_messagebox1( NULL,multi_endlevel_poll2, NULL, 2, TXT_YES, TXT_NO, TXT_ABORT_GAME );
}
else
choice=nm_messagebox( NULL, 2, TXT_YES, TXT_NO, TXT_ABORT_GAME );
if (choice==0)
{
Players[Player_num].connected=CONNECT_DISCONNECTED;
if (km->network)
multi_send_endlevel_packet();
multi_leave_game();
window_close(wind);
if (Game_wind)
window_close(Game_wind);
return 1;
}
return 1;
default:
break;
}
break;
case EVENT_WINDOW_DRAW:
timer_delay2(50);
if (km->network)
multi_do_protocol_frame(0, 1);
km->playing = 0;
// Check if all connected players are also looking at this screen ...
for (i = 0; i < MAX_PLAYERS; i++)
if (Players[i].connected)
if (Players[i].connected != CONNECT_END_MENU && Players[i].connected != CONNECT_DIED_IN_MINE)
km->playing = 1;
// ... and let the reactor blow sky high!
if (!km->playing)
Countdown_seconds_left = -1;
// If Reactor is finished and end_time not inited, set the time when we will exit this loop
if (km->end_time == -1 && Countdown_seconds_left < 0 && !km->playing)
km->end_time = timer_query() + (KMATRIX_VIEW_SEC * F1_0);
// Check if end_time has been reached and exit loop
if (timer_query() >= km->end_time && km->end_time != -1)
{
if (km->network)
multi_send_endlevel_packet(); // make sure
if (is_D2_OEM)
{
if (Current_level_num==8)
{
Players[Player_num].connected=CONNECT_DISCONNECTED;
if (km->network)
multi_send_endlevel_packet();
multi_leave_game();
window_close(wind);
if (Game_wind)
window_close(Game_wind);
return 0;
}
}
window_close(wind);
break;
}
kmatrix_redraw(km);
if (km->playing)
kmatrix_status_msg(Countdown_seconds_left, 1);
else
kmatrix_status_msg(f2i(timer_query()-km->end_time), 0);
break;
case EVENT_WINDOW_CLOSE:
game_flush_inputs();
newmenu_free_background();
break;
default:
break;
}
return 0;
}
window_event_result ui_checkbox_do( UI_DIALOG *dlg, UI_GADGET_CHECKBOX * checkbox,const d_event &event )
{
checkbox->oldposition = checkbox->position;
checkbox->pressed = 0;
if (event.type == EVENT_MOUSE_BUTTON_DOWN || event.type == EVENT_MOUSE_BUTTON_UP)
{
int OnMe;
OnMe = ui_mouse_on_gadget( checkbox );
if (B1_JUST_PRESSED && OnMe)
{
checkbox->position = 1;
return window_event_result::handled;
}
else if (B1_JUST_RELEASED)
{
if ((checkbox->position==1) && OnMe)
checkbox->pressed = 1;
checkbox->position = 0;
}
}
if (event.type == EVENT_KEY_COMMAND)
{
int key;
key = event_key_get(event);
if ((dlg->keyboard_focus_gadget==checkbox) && ((key==KEY_SPACEBAR) || (key==KEY_ENTER)) )
{
checkbox->position = 2;
return window_event_result::handled;
}
}
else if (event.type == EVENT_KEY_RELEASE)
{
int key;
key = event_key_get(event);
checkbox->position = 0;
if ((dlg->keyboard_focus_gadget==checkbox) && ((key==KEY_SPACEBAR) || (key==KEY_ENTER)) )
checkbox->pressed = 1;
}
if (checkbox->pressed == 1)
{
checkbox->flag ^= 1;
auto rval = ui_gadget_send_event(dlg, EVENT_UI_GADGET_PRESSED, checkbox);
if (rval == window_event_result::ignored)
rval = window_event_result::handled;
return rval;
}
if (event.type == EVENT_WINDOW_DRAW)
ui_draw_checkbox( dlg, checkbox );
return window_event_result::ignored;
}
static int con_handler(window *wind, d_event *event)
{
int key;
static fix64 last_scroll_time = 0;
switch (event->type)
{
case EVENT_WINDOW_ACTIVATED:
break;
case EVENT_WINDOW_DEACTIVATED:
con_size = 0;
con_state = CON_STATE_CLOSED;
break;
case EVENT_KEY_COMMAND:
key = event_key_get(event);
switch (key)
{
case KEY_SHIFTED + KEY_ESC:
switch (con_state)
{
case CON_STATE_OPEN:
case CON_STATE_OPENING:
con_state = CON_STATE_CLOSING;
break;
case CON_STATE_CLOSED:
case CON_STATE_CLOSING:
con_state = CON_STATE_OPENING;
default:
break;
}
break;
case KEY_PAGEUP:
con_scroll_offset+=CON_SCROLL_OFFSET;
if (con_scroll_offset >= CON_LINES_MAX-1)
con_scroll_offset = CON_LINES_MAX-1;
while (con_buffer[CON_LINES_MAX-1-con_scroll_offset].line[0]=='\0')
con_scroll_offset--;
break;
case KEY_PAGEDOWN:
con_scroll_offset-=CON_SCROLL_OFFSET;
if (con_scroll_offset<0)
con_scroll_offset=0;
break;
default:
cxx_handle_misc_con_key(key);
break;
}
return 1;
case EVENT_WINDOW_DRAW:
timer_delay2(50);
if (con_state == CON_STATE_OPENING)
{
if (con_size < CON_LINES_ONSCREEN && timer_query() >= last_scroll_time+(F1_0/30))
{
last_scroll_time = timer_query();
con_size = CON_LINES_ONSCREEN;
}
}
else if (con_state == CON_STATE_CLOSING)
{
if (con_size > 0 && timer_query() >= last_scroll_time+(F1_0/30))
{
last_scroll_time = timer_query();
con_size = 0;
}
}
if (con_size >= CON_LINES_ONSCREEN)
con_state = CON_STATE_OPEN;
else if (con_size <= 0)
con_state = CON_STATE_CLOSED;
if (con_state == CON_STATE_CLOSED && wind)
window_close(wind);
con_draw();
break;
case EVENT_WINDOW_CLOSE:
break;
default:
break;
}
return 0;
}
static window_event_result con_handler(window *wind,const d_event &event, const unused_window_userdata_t *)
{
int key;
static fix64 last_scroll_time = 0;
switch (event.type)
{
case EVENT_WINDOW_ACTIVATED:
key_toggle_repeat(1);
break;
case EVENT_WINDOW_DEACTIVATED:
key_toggle_repeat(0);
con_size = 0;
con_state = CON_STATE_CLOSED;
break;
case EVENT_KEY_COMMAND:
key = event_key_get(event);
switch (key)
{
case KEY_SHIFTED + KEY_ESC:
switch (con_state)
{
case CON_STATE_OPEN:
case CON_STATE_OPENING:
con_state = CON_STATE_CLOSING;
break;
case CON_STATE_CLOSED:
case CON_STATE_CLOSING:
con_state = CON_STATE_OPENING;
default:
break;
}
break;
case KEY_PAGEUP:
con_scroll_offset+=CON_SCROLL_OFFSET;
if (con_scroll_offset >= CON_LINES_MAX-1)
con_scroll_offset = CON_LINES_MAX-1;
while (con_buffer[CON_LINES_MAX-1-con_scroll_offset].line[0]=='\0')
con_scroll_offset--;
break;
case KEY_PAGEDOWN:
con_scroll_offset-=CON_SCROLL_OFFSET;
if (con_scroll_offset<0)
con_scroll_offset=0;
break;
case KEY_CTRLED + KEY_A:
case KEY_HOME: cli_cursor_home(); break;
case KEY_END:
case KEY_CTRLED + KEY_E: cli_cursor_end(); break;
case KEY_CTRLED + KEY_C: cli_clear(); break;
case KEY_LEFT: cli_cursor_left(); break;
case KEY_RIGHT: cli_cursor_right(); break;
case KEY_BACKSP: cli_cursor_backspace(); break;
case KEY_CTRLED + KEY_D:
case KEY_DELETE: cli_cursor_del(); break;
case KEY_UP: cli_history_prev(); break;
case KEY_DOWN: cli_history_next(); break;
case KEY_TAB: cli_autocomplete(); break;
case KEY_ENTER: cli_execute(); break;
case KEY_INSERT:
cli_toggle_overwrite_mode();
break;
default:
int character = key_ascii();
if (character == 255)
break;
cli_add_character(character);
break;
}
return window_event_result::handled;
case EVENT_WINDOW_DRAW:
timer_delay2(50);
if (con_state == CON_STATE_OPENING)
{
if (con_size < CON_LINES_ONSCREEN && timer_query() >= last_scroll_time+(F1_0/30))
{
last_scroll_time = timer_query();
if (++ con_size >= CON_LINES_ONSCREEN)
con_state = CON_STATE_OPEN;
}
}
else if (con_state == CON_STATE_CLOSING)
{
if (con_size > 0 && timer_query() >= last_scroll_time+(F1_0/30))
{
last_scroll_time = timer_query();
if (! -- con_size)
con_state = CON_STATE_CLOSED;
}
}
con_draw();
if (con_state == CON_STATE_CLOSED && wind)
{
return window_event_result::close;
}
break;
case EVENT_WINDOW_CLOSE:
break;
default:
break;
}
return window_event_result::ignored;
}
int wall_dialog_handler(UI_DIALOG *dlg, d_event *event, wall_dialog *wd)
{
int i;
sbyte type;
fix DeltaTime;
fix64 Temp;
int keypress = 0;
int rval = 0;
if (event->type == EVENT_KEY_COMMAND)
keypress = event_key_get(event);
Assert(MainWindow != NULL);
//------------------------------------------------------------
// Call the ui code..
//------------------------------------------------------------
ui_button_any_drawn = 0;
//------------------------------------------------------------
// If we change walls, we need to reset the ui code for all
// of the checkboxes that control the wall flags.
//------------------------------------------------------------
if (wd->old_wall_num != Cursegp->sides[Curside].wall_num)
{
if ( Cursegp->sides[Curside].wall_num != -1)
{
wall *w = &Walls[Cursegp->sides[Curside].wall_num];
ui_checkbox_check(wd->doorFlag[0], w->flags & WALL_DOOR_LOCKED);
ui_checkbox_check(wd->doorFlag[1], w->flags & WALL_DOOR_AUTO);
ui_checkbox_check(wd->doorFlag[2], w->flags & WALL_ILLUSION_OFF);
ui_radio_set_value(wd->keyFlag[0], w->keys & KEY_NONE);
ui_radio_set_value(wd->keyFlag[1], w->keys & KEY_BLUE);
ui_radio_set_value(wd->keyFlag[2], w->keys & KEY_RED);
ui_radio_set_value(wd->keyFlag[3], w->keys & KEY_GOLD);
}
}
//------------------------------------------------------------
// If any of the checkboxes that control the wallflags are set, then
// update the corresponding wall flag.
//------------------------------------------------------------
if (Walls[Cursegp->sides[Curside].wall_num].type == WALL_DOOR) {
if (GADGET_PRESSED(wd->doorFlag[0]))
{
if ( wd->doorFlag[0]->flag == 1 )
Walls[Cursegp->sides[Curside].wall_num].flags |= WALL_DOOR_LOCKED;
else
Walls[Cursegp->sides[Curside].wall_num].flags &= ~WALL_DOOR_LOCKED;
rval = 1;
}
else if (GADGET_PRESSED(wd->doorFlag[1]))
{
if ( wd->doorFlag[1]->flag == 1 )
Walls[Cursegp->sides[Curside].wall_num].flags |= WALL_DOOR_AUTO;
else
Walls[Cursegp->sides[Curside].wall_num].flags &= ~WALL_DOOR_AUTO;
rval = 1;
}
//------------------------------------------------------------
// If any of the radio buttons that control the mode are set, then
// update the corresponding key.
//------------------------------------------------------------
for ( i=0; i < 4; i++ ) {
if (GADGET_PRESSED(wd->keyFlag[i]))
{
Walls[Cursegp->sides[Curside].wall_num].keys = 1<<i; // Set the ai_state to the cooresponding radio button
rval = 1;
}
}
} else {
for (i = 0; i < 2; i++)
ui_checkbox_check(wd->doorFlag[i], 0);
for ( i=0; i < 4; i++ )
ui_radio_set_value(wd->keyFlag[i], 0);
}
if (Walls[Cursegp->sides[Curside].wall_num].type == WALL_ILLUSION) {
if (GADGET_PRESSED(wd->doorFlag[2]))
{
if ( wd->doorFlag[2]->flag == 1 )
Walls[Cursegp->sides[Curside].wall_num].flags |= WALL_ILLUSION_OFF;
else
Walls[Cursegp->sides[Curside].wall_num].flags &= ~WALL_ILLUSION_OFF;
rval = 1;
}
} else
for ( i=2; i < 3; i++ )
if (wd->doorFlag[i]->flag == 1) {
wd->doorFlag[i]->flag = 0; // Tells ui that this button isn't checked
wd->doorFlag[i]->status = 1; // Tells ui to redraw button
}
//------------------------------------------------------------
// Draw the wall in the little 64x64 box
//------------------------------------------------------------
if (event->type == EVENT_UI_DIALOG_DRAW)
{
// A simple frame time counter for animating the walls...
Temp = timer_query();
DeltaTime = Temp - wd->time;
gr_set_current_canvas( wd->wallViewBox->canvas );
if (Cursegp->sides[Curside].wall_num != -1) {
type = Walls[Cursegp->sides[Curside].wall_num].type;
if ((type == WALL_DOOR) || (type == WALL_BLASTABLE)) {
if (DeltaTime > ((F1_0*200)/1000)) {
wd->framenum++;
wd->time = Temp;
}
if (wd->framenum >= WallAnims[Walls[Cursegp->sides[Curside].wall_num].clip_num].num_frames)
wd->framenum=0;
PIGGY_PAGE_IN(Textures[WallAnims[Walls[Cursegp->sides[Curside].wall_num].clip_num].frames[wd->framenum]]);
gr_ubitmap(0,0, &GameBitmaps[Textures[WallAnims[Walls[Cursegp->sides[Curside].wall_num].clip_num].frames[wd->framenum]].index]);
} else {
if (type == WALL_OPEN)
gr_clear_canvas( CBLACK );
else {
if (Cursegp->sides[Curside].tmap_num2 > 0)
gr_ubitmap(0,0, texmerge_get_cached_bitmap( Cursegp->sides[Curside].tmap_num, Cursegp->sides[Curside].tmap_num2));
else {
PIGGY_PAGE_IN(Textures[Cursegp->sides[Curside].tmap_num]);
gr_ubitmap(0,0, &GameBitmaps[Textures[Cursegp->sides[Curside].tmap_num].index]);
}
}
}
} else
gr_clear_canvas( CGREY );
}
//------------------------------------------------------------
// If anything changes in the ui system, redraw all the text that
// identifies this wall.
//------------------------------------------------------------
if (event->type == EVENT_UI_DIALOG_DRAW)
{
if ( Cursegp->sides[Curside].wall_num > -1 ) {
ui_dprintf_at( MainWindow, 12, 6, "Wall: %d ", Cursegp->sides[Curside].wall_num);
switch (Walls[Cursegp->sides[Curside].wall_num].type) {
case WALL_NORMAL:
ui_dprintf_at( MainWindow, 12, 23, " Type: Normal " );
break;
case WALL_BLASTABLE:
ui_dprintf_at( MainWindow, 12, 23, " Type: Blastable" );
break;
case WALL_DOOR:
ui_dprintf_at( MainWindow, 12, 23, " Type: Door " );
ui_dprintf_at( MainWindow, 223, 6, "%s", WallAnims[Walls[Cursegp->sides[Curside].wall_num].clip_num].filename);
break;
case WALL_ILLUSION:
ui_dprintf_at( MainWindow, 12, 23, " Type: Illusion " );
break;
case WALL_OPEN:
ui_dprintf_at( MainWindow, 12, 23, " Type: Open " );
break;
case WALL_CLOSED:
ui_dprintf_at( MainWindow, 12, 23, " Type: Closed " );
break;
default:
ui_dprintf_at( MainWindow, 12, 23, " Type: Unknown " );
break;
}
if (Walls[Cursegp->sides[Curside].wall_num].type != WALL_DOOR)
ui_dprintf_at( MainWindow, 223, 6, " " );
ui_dprintf_at( MainWindow, 12, 40, " Clip: %d ", Walls[Cursegp->sides[Curside].wall_num].clip_num );
ui_dprintf_at( MainWindow, 12, 57, " Trigger: %d ", Walls[Cursegp->sides[Curside].wall_num].trigger );
} else {
ui_dprintf_at( MainWindow, 12, 6, "Wall: none ");
ui_dprintf_at( MainWindow, 12, 23, " Type: none ");
ui_dprintf_at( MainWindow, 12, 40, " Clip: none ");
ui_dprintf_at( MainWindow, 12, 57, " Trigger: none ");
}
}
if (ui_button_any_drawn || (wd->old_wall_num != Cursegp->sides[Curside].wall_num) )
Update_flags |= UF_WORLD_CHANGED;
if (event->type == EVENT_WINDOW_CLOSE)
{
d_free(wd);
MainWindow = NULL;
return 0;
}
if ( GADGET_PRESSED(wd->quitButton) || (keypress==KEY_ESC) )
{
close_wall_window();
return 1;
}
wd->old_wall_num = Cursegp->sides[Curside].wall_num;
return rval;
}
window_event_result ui_icon_do( UI_DIALOG *dlg, UI_GADGET_ICON * icon,const d_event &event )
{
icon->oldposition = icon->position;
icon->pressed = 0;
window_event_result rval = window_event_result::ignored;
if (event.type == EVENT_MOUSE_BUTTON_DOWN || event.type == EVENT_MOUSE_BUTTON_UP)
{
int OnMe;
OnMe = ui_mouse_on_gadget( icon );
if (B1_JUST_PRESSED && OnMe)
{
icon->position = 1;
rval = window_event_result::handled;
}
else if (B1_JUST_RELEASED)
{
if ((icon->position == 1) && OnMe)
icon->pressed = 1;
icon->position = 0;
}
}
if (event.type == EVENT_KEY_COMMAND)
{
int key;
key = event_key_get(event);
if (key == icon->trap_key)
{
icon->position = 1;
rval = window_event_result::handled;
}
}
else if (event.type == EVENT_KEY_RELEASE)
{
int key;
key = event_key_get(event);
icon->position = 0;
if (key == icon->trap_key)
icon->pressed = 1;
}
if (icon->pressed == 1)
{
icon->status = 1;
icon->flag = static_cast<int8_t>(icon->user_function());
rval = ui_gadget_send_event(dlg, EVENT_UI_GADGET_PRESSED, icon);
if (rval == window_event_result::ignored)
rval = window_event_result::handled;
}
if (event.type == EVENT_WINDOW_DRAW)
ui_draw_icon( icon );
return rval;
}
window_event_result ui_userbox_do( UI_DIALOG *dlg, UI_GADGET_USERBOX * userbox,const d_event &event )
{
int OnMe, olddrag;
int x, y, z;
int keypress = 0;
window_event_result rval = window_event_result::ignored;
if (event.type == EVENT_WINDOW_DRAW)
ui_draw_userbox( dlg, userbox );
if (event.type == EVENT_KEY_COMMAND)
keypress = event_key_get(event);
mouse_get_pos(&x, &y, &z);
OnMe = ui_mouse_on_gadget( userbox );
olddrag = userbox->b1_held_down;
userbox->mouse_onme = OnMe;
userbox->mouse_x = x - userbox->x1;
userbox->mouse_y = y - userbox->y1;
userbox->b1_dragging = 0;
userbox->b1_clicked = 0;
if (OnMe)
{
if ( B1_JUST_PRESSED )
{
userbox->b1_held_down = 1;
userbox->b1_drag_x1 = x - userbox->x1;
userbox->b1_drag_y1 = y - userbox->y1;
rval = window_event_result::handled;
}
else if (B1_JUST_RELEASED)
{
if (userbox->b1_held_down)
userbox->b1_clicked = 1;
userbox->b1_held_down = 0;
rval = window_event_result::handled;
}
if ( (event.type == EVENT_MOUSE_MOVED) && userbox->b1_held_down )
{
userbox->b1_dragging = 1;
userbox->b1_drag_x2 = x - userbox->x1;
userbox->b1_drag_y2 = y - userbox->y1;
}
if ( B1_DOUBLE_CLICKED )
{
userbox->b1_double_clicked = 1;
rval = window_event_result::handled;
}
else
userbox->b1_double_clicked = 0;
}
if (B1_JUST_RELEASED)
userbox->b1_held_down = 0;
userbox->b1_done_dragging = 0;
if (olddrag==1 && userbox->b1_held_down==0 )
{
if ((userbox->b1_drag_x1 != userbox->b1_drag_x2) || (userbox->b1_drag_y1 != userbox->b1_drag_y2) )
userbox->b1_done_dragging = 1;
}
if (dlg->keyboard_focus_gadget==userbox)
{
userbox->keypress = keypress;
rval = window_event_result::handled;
}
if (userbox->b1_clicked || userbox->b1_dragging)
{
rval = ui_gadget_send_event(dlg, userbox->b1_clicked ? EVENT_UI_GADGET_PRESSED : EVENT_UI_USERBOX_DRAGGED, userbox);
if (rval == window_event_result::ignored)
rval = window_event_result::handled;
}
return rval;
}
int ui_radio_do( UI_DIALOG *dlg, UI_GADGET_RADIO * radio, d_event *event )
{
UI_GADGET * tmp;
UI_GADGET_RADIO * tmpr;
int rval = 0;
radio->oldposition = radio->position;
radio->pressed = 0;
if (event->type == EVENT_MOUSE_BUTTON_DOWN || event->type == EVENT_MOUSE_BUTTON_UP)
{
int OnMe;
OnMe = ui_mouse_on_gadget( (UI_GADGET *)radio );
if ( B1_JUST_PRESSED && OnMe)
{
radio->position = 1;
rval = 1;
}
else if (B1_JUST_RELEASED)
{
if ((radio->position==1) && OnMe)
radio->pressed = 1;
radio->position = 0;
}
}
if (event->type == EVENT_KEY_COMMAND)
{
int key;
key = event_key_get(event);
if ((dlg->keyboard_focus_gadget==(UI_GADGET *)radio) && ((key==KEY_SPACEBAR) || (key==KEY_ENTER)) )
{
radio->position = 2;
rval = 1;
}
}
else if (event->type == EVENT_KEY_RELEASE)
{
int key;
key = event_key_get(event);
radio->position = 0;
if ((dlg->keyboard_focus_gadget==(UI_GADGET *)radio) && ((key==KEY_SPACEBAR) || (key==KEY_ENTER)) )
radio->pressed = 1;
}
if ((radio->pressed == 1) && (radio->flag==0))
{
tmp = (UI_GADGET *)radio->next;
while (tmp != (UI_GADGET *)radio )
{
if (tmp->kind==4)
{
tmpr = (UI_GADGET_RADIO *)tmp;
if ((tmpr->group == radio->group ) && (tmpr->flag) )
{
tmpr->flag = 0;
tmpr->status = 1;
tmpr->pressed = 0;
}
}
tmp = tmp->next;
}
radio->flag = 1;
ui_gadget_send_event(dlg, EVENT_UI_GADGET_PRESSED, (UI_GADGET *)radio);
rval = 1;
}
if (event->type == EVENT_WINDOW_DRAW)
ui_draw_radio( dlg, radio );
return rval;
}
int ReadControls(d_event *event)
{
int key;
static ubyte exploding_flag=0;
Player_fired_laser_this_frame=-1;
if (Player_exploded) {
if (exploding_flag==0) {
exploding_flag = 1; // When player starts exploding, clear all input devices...
game_flush_inputs();
}
} else {
exploding_flag=0;
}
if (Player_is_dead && !( (Game_mode & GM_MULTI) && (multi_sending_message[Player_num] || multi_defining_message) ))
if (HandleDeathInput(event)) {
if( (Game_mode & GM_MULTI) && (Netgame.SpawnStyle == SPAWN_STYLE_PREVIEW) ) {
// fall through to normal key handler
// Make sure flares/shots go in direction of preview
ConsoleObject->orient = Dead_player_camera->orient;
} else {
return 1;
}
}
if (Newdemo_state == ND_STATE_PLAYBACK)
update_vcr_state();
if (event->type == EVENT_KEY_COMMAND)
{
key = event_key_get(event);
#ifdef NETWORK
if ( (Game_mode & GM_MULTI) && (multi_sending_message[Player_num] || multi_defining_message) )
{
return multi_message_input_sub(key);
}
#endif
#ifndef RELEASE
#ifdef NETWORK
if ((key&KEY_DEBUGGED)&&(Game_mode&GM_MULTI)) {
Network_message_reciever = 100; // Send to everyone...
sprintf( Network_message, "%s %s", TXT_I_AM_A, TXT_CHEATER);
}
#endif
#endif
if (Endlevel_sequence)
{
if (HandleEndlevelKey(key))
return 1;
}
else if (Newdemo_state == ND_STATE_PLAYBACK )
{
if (HandleDemoKey(key))
return 1;
}
else
{
if (FinalCheats(key)) return 1;
if (HandleSystemKey(key)) return 1;
if (HandleGameKey(key)) return 1;
}
#ifndef RELEASE
if (HandleTestKey(key))
return 1;
#endif
if (call_default_handler(event))
return 1;
}
int should_read_controls;
if (!Endlevel_sequence && !Player_is_dead && (Newdemo_state != ND_STATE_PLAYBACK)) {
should_read_controls = 1;
} else {
should_read_controls = 0;
}
#ifdef NETWORK
if((Game_mode & GM_NETWORK) && (Netgame.SpawnStyle == SPAWN_STYLE_PREVIEW) && Player_is_dead && Player_exploded) {
if (!Endlevel_sequence && (Newdemo_state != ND_STATE_PLAYBACK)) {
should_read_controls = 1;
}
}
#endif
if (should_read_controls)
{
kconfig_read_controls(event, 0);
check_rear_view();
// If automap key pressed, enable automap unless you are in network mode, control center destroyed and < 10 seconds left
if ( Controls.automap_count > 0 )
{
Controls.automap_count = 0;
if (!((Game_mode & GM_MULTI) && Control_center_destroyed && (Countdown_seconds_left < 10)))
{
do_automap(0);
return 1;
}
}
do_weapon_n_item_stuff();
}
return 0;
}
static window_event_result menu_handler(window *, const d_event &event, MENU *menu)
{
int i;
int keypress = 0;
if (state != 3)
return window_event_result::ignored;
if (event.type == EVENT_KEY_COMMAND)
keypress = event_key_get(event);
else if (event.type == EVENT_WINDOW_CLOSE) // quitting
{
state = 0;
menu_hide_all();
menu->wind = nullptr;
return window_event_result::ignored;
}
window_event_result rval = window_event_result::ignored;
switch( keypress )
{
case 0:
break;
case KEY_ESC:
state = 0;
menu_hide_all();
rval = window_event_result::handled;
break;
case KEY_DOWN:
case KEY_PAD2:
i = Menu[ CMENU ].CurrentItem;
do {
i++;
if ( i >= Menu[ CMENU ].NumItems )
i = 0;
} while( Menu[CMENU].Item[i].Text[0] == '-');
menu_move_bar_to( &Menu[ CMENU ], i );
rval = window_event_result::handled;
break;
case KEY_UP:
case KEY_PAD8:
i = Menu[ CMENU ].CurrentItem;
do
{
i--;
if ( i < 0 )
i = Menu[ CMENU ].NumItems-1;
} while( Menu[CMENU].Item[i].Text[0] == '-');
menu_move_bar_to( &Menu[ CMENU ], i );
rval = window_event_result::handled;
break;
case KEY_RIGHT:
case KEY_PAD6:
menu_hide( &Menu[ CMENU ] );
i = Menu[0].CurrentItem+1;
if (i >= Menu[0].NumItems ) i = 0;
menu_move_bar_to( &Menu[0], i );
Menu[CMENU].ShowBar = 1;
Menu[CMENU].Active = 1;
menu_show( &Menu[CMENU] );
rval = window_event_result::handled;
break;
case KEY_LEFT:
case KEY_PAD4:
menu_hide( &Menu[ CMENU ] );
i = Menu[0].CurrentItem-1;
if (i < 0 ) i = Menu[0].NumItems-1;
menu_move_bar_to( &Menu[0], i );
Menu[ CMENU ].ShowBar = 1;
Menu[CMENU].Active = 1;
menu_show( &Menu[ CMENU ] );
rval = window_event_result::handled;
break;
case KEY_ENTER:
case KEY_PADENTER:
state = 0;
menu_hide_all();
if (Menu[CMENU].Item[ Menu[CMENU].CurrentItem ].user_function)
Menu[CMENU].Item[ Menu[CMENU].CurrentItem ].user_function();
rval = window_event_result::handled;
break;
default:
i = menu_match_keypress( &Menu[ CMENU ], keypress );
if (i > -1 )
{
menu_move_bar_to( &Menu[ CMENU ], i );
state = 0;
menu_hide_all();
if (Menu[CMENU].Item[ Menu[CMENU].CurrentItem ].user_function)
Menu[CMENU].Item[ Menu[CMENU].CurrentItem ].user_function();
rval = window_event_result::handled;
break;
}
}
if (event.type == EVENT_MOUSE_MOVED || B1_JUST_RELEASED)
{
i = menu_check_mouse_item( &Menu[CMENU] );
if (i > -1 )
{
if ( B1_JUST_RELEASED )
{
menu_move_bar_to( &Menu[ CMENU ], i );
state = 0;
menu_hide_all();
if (Menu[CMENU].Item[ Menu[CMENU].CurrentItem ].user_function)
Menu[CMENU].Item[ Menu[CMENU].CurrentItem ].user_function();
rval = window_event_result::handled;
}
else
{
menu_move_bar_to( &Menu[ CMENU ], i );
rval = window_event_result::handled;
}
} else {
i = menu_check_mouse_item( &Menu[0] );
if (i > -1)
{
if ( Menu[0].CurrentItem != i) {
menu_hide( &Menu[ CMENU ] );
menu_move_bar_to( &Menu[0], i );
Menu[ CMENU ].ShowBar = 1;
Menu[CMENU].Active = 1;
menu_show( &Menu[ CMENU ] );
}
rval = window_event_result::handled;
}
if ( B1_JUST_RELEASED )
{
state = 0;
menu_hide_all();
rval = window_event_result::handled;
}
}
}
if (event.type == EVENT_WINDOW_DRAW)
{
menu_draw(&Menu[CMENU]);
return window_event_result::handled;
}
return rval;
}
static window_event_result hostage_dialog_handler(UI_DIALOG *dlg,const d_event &event, hostage_dialog *h)
{
switch(event.type)
{
case EVENT_WINDOW_CREATED:
return hostage_dialog_created(dlg, h);
case EVENT_WINDOW_CLOSE:
std::default_delete<hostage_dialog>()(h);
MainWindow = nullptr;
return window_event_result::ignored;
default:
break;
}
fix64 Temp;
int keypress = 0;
if (event.type == EVENT_KEY_COMMAND)
keypress = event_key_get(event);
Assert(MainWindow != NULL);
SelectClosestHostage();
//------------------------------------------------------------
// Call the ui code..
//------------------------------------------------------------
ui_button_any_drawn = 0;
//------------------------------------------------------------
// If we change objects, we need to reset the ui code for all
// of the radio buttons that control the ai mode. Also makes
// the current AI mode button be flagged as pressed down.
//------------------------------------------------------------
//------------------------------------------------------------
// If any of the radio buttons that control the mode are set, then
// update the cooresponding AI state.
//------------------------------------------------------------
//------------------------------------------------------------
// Redraw the object in the little 64x64 box
//------------------------------------------------------------
if (event.type == EVENT_UI_DIALOG_DRAW)
{
ui_dprintf_at( MainWindow, 10, 32,"&Message:" );
// A simple frame time counter for spinning the objects...
Temp = timer_query();
h->time = Temp;
if (CurrentHostageIndex > -1 ) {
gr_set_current_canvas( h->hostageViewBox->canvas );
gr_clear_canvas( CGREY );
} else {
// no hostage, so just blank out
gr_set_current_canvas( h->hostageViewBox->canvas );
gr_clear_canvas( CGREY );
}
}
//------------------------------------------------------------
// If anything changes in the ui system, redraw all the text that
// identifies this robot.
//------------------------------------------------------------
if (event.type == EVENT_UI_DIALOG_DRAW)
{
if ( CurrentHostageIndex > -1 ) {
ui_dprintf_at( MainWindow, 10, 15, "Hostage: %d Object: %d", CurrentHostageIndex, Hostages[CurrentHostageIndex].objnum );
//@@ui_dprintf_at( MainWindow, 10, 73, "Type: %d Sound: %d ", Hostages[CurrentHostageIndex].type, Hostages[CurrentHostageIndex].sound_num );
} else {
ui_dprintf_at( MainWindow, 10, 15, "Hostage: none " );
//@@ui_dprintf_at( MainWindow, 10, 73, "Type: Sound: " );
ui_dprintf_at( MainWindow, 10, 73, "Face: " );
}
}
if (ui_button_any_drawn || (LastHostageIndex != CurrentHostageIndex))
Update_flags |= UF_WORLD_CHANGED;
if (GADGET_PRESSED(h->quitButton.get()) || keypress==KEY_ESC)
{
return window_event_result::close;
}
LastHostageIndex = CurrentHostageIndex;
return window_event_result::ignored;
}
