controlsconfig.cpp

/*
 * Copyright (C) Volition, Inc. 1999.  All rights reserved.
 *
 * All source code herein is the property of Volition, Inc. You may not sell 
 * or otherwise commercially exploit the source or things you created based on the 
 * source.
 *
*/ 




#include "camera/photomode.h"
#include "cfile/cfile.h"
#include "cmdline/cmdline.h"
#include "controlconfig/controlsconfig.h"
#include "controlconfig/presets.h"
#include "debugconsole/console.h"
#include "../freespace2/freespace.h"
#include "gamehelp/contexthelp.h"
#include "gamesequence/gamesequence.h"
#include "gamesnd/gamesnd.h"
#include "globalincs/alphacolors.h"
#include "globalincs/undosys.h"
#include "graphics/font.h"
#include "hud/hudsquadmsg.h"
#include "io/joy.h"
#include "io/key.h"
#include "io/timer.h"
#include "missionui/missionscreencommon.h"
#include "network/multi_pmsg.h"
#include "network/multiutil.h"
#include "scripting/scripting.h"
#include "scripting/global_hooks.h"
#include "playerman/player.h"
#include "pilotfile/pilotfile.h"
#include "popup/popup.h"
#include "ui/ui.h"
#include "ui/uidefs.h"


#ifndef NDEBUG
#include "hud/hud.h"
#endif



#define NUM_BUTTONS				19
#define NUM_TABS				4

// coordinate indicies
#define CONTROL_X_COORD 0
#define CONTROL_Y_COORD 1
#define CONTROL_W_COORD 2
#define CONTROL_H_COORD 3

const char* Conflict_background_bitmap_fname[GR_NUM_RESOLUTIONS] = {
	"ControlConfig",		// GR_640
	"2_ControlConfig"		// GR_1024
};

const char* Conflict_background_bitmap_mask_fname[GR_NUM_RESOLUTIONS] = {
	"ControlConfig-m",		// GR_640
	"2_ControlConfig-m"		// GR_1024
};

// control list area
int Control_list_coords[GR_NUM_RESOLUTIONS][4] = {
	{
		20, 58, 596, 259	// GR_640
	},
	{
		32, 94, 956, 424	// GR_1024
	}
};

// width of the control name section of the list
int Control_list_ctrl_w[GR_NUM_RESOLUTIONS] = {
	350,	// GR_640
	600		// GR_1024
};

// x start position of the primary binding area column
int Control_list_first_x[GR_NUM_RESOLUTIONS] = {
	350,	// GR_640
	640		// GR_1024 (712)
};

// width of the both binding area columns
int Control_list_first_w[GR_NUM_RESOLUTIONS] = {
	116,	// GR_640 (198)
	150		// GR_1024 (230)
};

// x start position of the secondary binding area column
int Control_list_second_x[GR_NUM_RESOLUTIONS] = {
	480,	// GR_640
	806,	// GR_1024
};

// display the "more..." text under the control list
int Control_more_coords[GR_NUM_RESOLUTIONS][2] = {
	{
		320, 326			// GR_640
	},
	{
		500, 542			// GR_1024
	}
};

// area to display "conflicts with..." text
int Conflict_wnd_coords[GR_NUM_RESOLUTIONS][4] = {
	{
		32, 313, 250, 32	// GR_640
	},
	{
		48, 508, 354, 46	// GR_1024
	}
};

// conflict warning anim coords
int Conflict_warning_coords[GR_NUM_RESOLUTIONS][2] = {
	{
		320, 420			// GR_640
	},
	{
		512, 669			// GR_1024
	}
};

// for flashing the conflict text
#define CONFLICT_FLASH_TIME	250
UI_TIMESTAMP Conflict_stamp;
int Conflict_bright = 0;

#define LIST_BUTTONS_MAX	42

static int Num_cc_lines;	// Number of Cc_lines to display on the current page. Is, at worse, CCFG_MAX + NUM_JOY_AXIS_ACTIONS

SCP_vector<cc_line> Cc_lines;

// Backups for use when user closes the config menu without saving
SCP_vector<CCI> Control_config_backup;

// The current preset that the user is working on and will likely want to save to
static SCP_string Current_preset_name;

// Undo system
Undo_system Undo_controls;

// all this stuff is localized/externalized
#define NUM_INVERT_TEXT			2	
char *Axis_text[NUM_AXIS_TEXT];
char *Mouse_button_text[NUM_MOUSE_TEXT];
char *Invert_text[NUM_INVERT_TEXT];

int Control_check_count = 0;

static int Tab;  // which tab we are currently in
static int Binding_mode = 0;  // are we waiting for a key to bind it?
static UI_TIMESTAMP Bind_time = UI_TIMESTAMP::invalid();
static int Search_mode = 0;  // are we waiting for a key to bind it?
static int Last_key = -1;
static int Selected_line = 0;  // line that is currently selected for binding
static selItem Selected_item = selItem::None;
static int Scroll_offset;
static CC_bind Axis_override;
static int Background_bitmap;
static int Conflicts_tabs[NUM_TABS];
static UI_BUTTON List_buttons[LIST_BUTTONS_MAX];  // buttons for each line of text in list
static UI_WINDOW Ui_window;
static unsigned int Defaults_cycle_pos = 0; // the controls preset that was last selected
static UI_TIMESTAMP bound_timestamp;
static char bound_string[40];

int Control_config_overlay_id;

SCP_vector<conflict> Conflicts;


#define TARGET_TAB				0
#define SHIP_TAB				1
#define WEAPON_TAB				2
#define COMPUTER_TAB			3
#define SCROLL_UP_BUTTON		4
#define SCROLL_DOWN_BUTTON		5
#define ALT_TOGGLE				6
#define SHIFT_TOGGLE			7
#define INVERT_AXIS				8
#define CANCEL_BUTTON			9
#define UNDO_BUTTON				10
#define RESET_BUTTON			11
#define SEARCH_MODE				12
#define BIND_BUTTON				13
#define HELP_BUTTON				14
#define ACCEPT_BUTTON			15
#define CLEAR_OTHER_BUTTON		16
#define CLEAR_ALL_BUTTON		17
#define CLEAR_BUTTON			18

ui_button_info CC_Buttons[GR_NUM_RESOLUTIONS][NUM_BUTTONS] = {
	{ // GR_640
		ui_button_info("CCB_00",	32,	348,	17,	384,	0),	// target tab
		ui_button_info("CCB_01",	101,	348,	103,	384,	1),	// ship tab
		ui_button_info("CCB_02",	173,	352,	154,	384,	2),	// weapon tab
		ui_button_info("CCB_03",	242,	347,	244,	384,	3),	// computer/misc tab
		ui_button_info("CCB_04",	614,	73,	-1,	-1,	4),	// scroll up
		ui_button_info("CCB_05",	614,	296,	-1,	-1,	5),	// scroll down
		ui_button_info("CCB_06",	17,	452,	12,	440,	6),	// alt toggle
		ui_button_info("CCB_07",	56,	452,	50,	440,	7),	// shift toggle
		ui_button_info("CCB_09",	162,	452,	155,	440,	9),	// invert
		ui_button_info("CCB_10",	404,	1,		397,	45,	10),	// cancel
		ui_button_info("CCB_11",	582,	347,	586,	386,	11),	// undo
		ui_button_info("CCB_12",	576,	1,		578,	45,	12),	// default
		ui_button_info("CCB_13",	457,	4,		453,	45,	13),	// search
		ui_button_info("CCB_14",	516,	4,		519,	45,	14),	// bind
		ui_button_info("CCB_15",	540,	428,	500,	440,	15),	// help
		ui_button_info("CCB_16",	574,	432,	571,	412,	16),	// accept
		ui_button_info("CCB_18",	420,	346,	417,	386,	18),	// clear other 
		ui_button_info("CCB_19",	476,	346,	474,	386,	19),	// clear all
		ui_button_info("CCB_20",	524,	346,	529,	386,	20),	// clear button
	},
	{ // GR_1024
		ui_button_info("2_CCB_00",	51,	557,	27,	615,	0),	// target tab
		ui_button_info("2_CCB_01",	162,	557,	166,	615,	1),	// ship tab
		ui_button_info("2_CCB_02",	277,	563,	246,	615,	2),	// weapon tab
		ui_button_info("2_CCB_03",	388,	555,	391,	615,	3),	// computer/misc tab
		ui_button_info("2_CCB_04",	982,	117,	-1,	-1,	4),	// scroll up
		ui_button_info("2_CCB_05",	982,	474,	-1,	-1,	5),	// scroll down
		ui_button_info("2_CCB_06",	28,	723,	24,	704,	6),	// alt toggle
		ui_button_info("2_CCB_07",	89,	723,	80,	704,	7),	// shift toggle
		ui_button_info("2_CCB_09",	260,	723,	249,	704,	9),	// invert
		ui_button_info("2_CCB_10",	646,	2,		635,	71,	10),	// cancel
		ui_button_info("2_CCB_11",	932,	555,	938,	619,	11),	// undo
		ui_button_info("2_CCB_12",	921,	1,		923,	71,	12),	// default
		ui_button_info("2_CCB_13",	732,	6,		726,	71,	13),	// search
		ui_button_info("2_CCB_14",	825,	6,		831,	71,	14),	// bind
		ui_button_info("2_CCB_15",	864,	685,	800,	704,	15),	// help
		ui_button_info("2_CCB_16",	919,	692,	914,	660,	16),	// accept
		ui_button_info("2_CCB_18",	672,	553,	668,	619,	18),	// clear other 
		ui_button_info("2_CCB_19",	761,	553,	749,	619,	19),	// clear all
		ui_button_info("2_CCB_20",	838,	553,	846,	619,	20),	// clear button
	}
};

// strings
#define CC_NUM_TEXT		20
UI_XSTR CC_text[GR_NUM_RESOLUTIONS][CC_NUM_TEXT] = {
	{ // GR_640
		{ "Targeting",		1340,		17,	384,	UI_XSTR_COLOR_GREEN, -1, &CC_Buttons[0][TARGET_TAB].button },
		{ "Ship",			1341,		103,	384,	UI_XSTR_COLOR_GREEN, -1, &CC_Buttons[0][SHIP_TAB].button },
		{ "Weapons",		1065,		154,	384,	UI_XSTR_COLOR_GREEN, -1, &CC_Buttons[0][WEAPON_TAB].button },
		{ "Misc",			1411,		244,	384,	UI_XSTR_COLOR_GREEN, -1, &CC_Buttons[0][COMPUTER_TAB].button },		
		{ "Alt",				1510,		12,	440,	UI_XSTR_COLOR_GREEN, -1, &CC_Buttons[0][ALT_TOGGLE].button },
		{ "Shift",			1511,		50,	440,	UI_XSTR_COLOR_GREEN, -1, &CC_Buttons[0][SHIFT_TOGGLE].button },
		{ "Invert",			1342,		155,	440,	UI_XSTR_COLOR_GREEN, -1, &CC_Buttons[0][INVERT_AXIS].button },
		{ "Cancel",			641,		401,	45,	UI_XSTR_COLOR_PINK, -1, &CC_Buttons[0][CANCEL_BUTTON].button },
		{ "Undo",			1343,		586,	386,	UI_XSTR_COLOR_GREEN, -1, &CC_Buttons[0][UNDO_BUTTON].button },
		{ "Next Preset",	1661,		553,	45,	UI_XSTR_COLOR_GREEN, -1, &CC_Buttons[0][RESET_BUTTON].button },
		{ "Search",			1345,		458,	45,	UI_XSTR_COLOR_GREEN, -1, &CC_Buttons[0][SEARCH_MODE].button },
		{ "Bind",			1346,		517,	45,	UI_XSTR_COLOR_PINK, -1, &CC_Buttons[0][BIND_BUTTON].button },
		{ "Help",			928,		500,	440,	UI_XSTR_COLOR_GREEN, -1, &CC_Buttons[0][HELP_BUTTON].button },
		{ "Accept",			1035,		571,	412,	UI_XSTR_COLOR_PINK, -1, &CC_Buttons[0][ACCEPT_BUTTON].button },
		{ "Clear",			1347,		417,	386,	UI_XSTR_COLOR_GREEN, -1, &CC_Buttons[0][CLEAR_OTHER_BUTTON].button },
		{ "Conflict",		1348,		406,	396,	UI_XSTR_COLOR_GREEN, -1, &CC_Buttons[0][CLEAR_OTHER_BUTTON].button },
		{ "Clear",			1413,		474,	386,	UI_XSTR_COLOR_GREEN, -1, &CC_Buttons[0][CLEAR_ALL_BUTTON].button },
		{ "All",				1349,		483,	396,	UI_XSTR_COLOR_GREEN, -1, &CC_Buttons[0][CLEAR_ALL_BUTTON].button },
		{ "Clear",			1414,		529,	388,	UI_XSTR_COLOR_PINK, -1, &CC_Buttons[0][CLEAR_BUTTON].button },
		{ "Selected",		1350,		517,	396,	UI_XSTR_COLOR_PINK, -1, &CC_Buttons[0][CLEAR_BUTTON].button },
	},
	{ // GR_1024
		{ "Targeting",		1340,		47,	615,	UI_XSTR_COLOR_GREEN, -1, &CC_Buttons[1][TARGET_TAB].button },
		{ "Ship",			1341,		176,	615,	UI_XSTR_COLOR_GREEN, -1, &CC_Buttons[1][SHIP_TAB].button },
		{ "Weapons",		1065,		266,	615,	UI_XSTR_COLOR_GREEN, -1, &CC_Buttons[1][WEAPON_TAB].button },
		{ "Misc",			1411,		401,	615,	UI_XSTR_COLOR_GREEN, -1, &CC_Buttons[1][COMPUTER_TAB].button },		
		{ "Alt",				1510,		29,	704,	UI_XSTR_COLOR_GREEN, -1, &CC_Buttons[1][ALT_TOGGLE].button },
		{ "Shift",			1511,		85,	704,	UI_XSTR_COLOR_GREEN, -1, &CC_Buttons[1][SHIFT_TOGGLE].button },
		{ "Invert",			1342,		254,	704,	UI_XSTR_COLOR_GREEN, -1, &CC_Buttons[1][INVERT_AXIS].button },
		{ "Cancel",			641,		655,	71,	UI_XSTR_COLOR_PINK, -1, &CC_Buttons[1][CANCEL_BUTTON].button },
		{ "Undo",			1343,		938,	619,	UI_XSTR_COLOR_GREEN, -1, &CC_Buttons[1][UNDO_BUTTON].button },
		{ "Next Preset",	1661,		913,	71,	UI_XSTR_COLOR_GREEN, -1, &CC_Buttons[1][RESET_BUTTON].button },
		{ "Search",			1345,		746,	71,	UI_XSTR_COLOR_GREEN, -1, &CC_Buttons[1][SEARCH_MODE].button },
		{ "Bind",			1346,		846,	71,	UI_XSTR_COLOR_PINK, -1, &CC_Buttons[1][BIND_BUTTON].button },
		{ "Help",			928,		800,	704,	UI_XSTR_COLOR_GREEN, -1, &CC_Buttons[1][HELP_BUTTON].button },
		{ "Accept",			1035,		914,	660,	UI_XSTR_COLOR_PINK, -1, &CC_Buttons[1][ACCEPT_BUTTON].button },
		{ "Clear",			1347,		683,	619,	UI_XSTR_COLOR_GREEN, -1, &CC_Buttons[1][CLEAR_OTHER_BUTTON].button },
		{ "Conflict",		1348,		666,	634,	UI_XSTR_COLOR_GREEN, -1, &CC_Buttons[1][CLEAR_OTHER_BUTTON].button },
		{ "Clear",			1413,		759,	619,	UI_XSTR_COLOR_GREEN, -1, &CC_Buttons[1][CLEAR_ALL_BUTTON].button },
		{ "All",				1349,		772,	634,	UI_XSTR_COLOR_GREEN, -1, &CC_Buttons[1][CLEAR_ALL_BUTTON].button },
		{ "Clear",			1414,		871,	619,	UI_XSTR_COLOR_PINK, -1, &CC_Buttons[1][CLEAR_BUTTON].button },
		{ "Selected",		1350,		852,	634,	UI_XSTR_COLOR_PINK, -1, &CC_Buttons[1][CLEAR_BUTTON].button },
	}
};


// same indices as Scan_code_text[].  Indicates if a scancode is allowed to be bound.
int Config_allowed[] = {
	0, 0, 1, 1, 1, 1, 1, 1,
	1, 1, 1, 1, 1, 1, 1, 1,
	1, 1, 1, 1, 1, 1, 1, 1,
	1, 1, 1, 1, 1, 1, 1, 1,

	1, 1, 1, 1, 1, 1, 1, 1,
	1, 0, 1, 1, 1, 1, 1, 1,
	1, 1, 1, 1, 1, 1, 1, 1,
	1, 1, 1, 0, 0, 0, 0, 0,

	0, 0, 0, 0, 0, 0, 1, 1,
	1, 1, 1, 1, 1, 1, 1, 1,
	1, 1, 1, 1, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,

	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,

	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 1, 1, 0, 0,

	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 1, 0, 0,
	1, 0, 0, 0, 0, 0, 0, 0,

	0, 0, 0, 0, 0, 0, 0, 1,
	1, 1, 0, 1, 0, 1, 0, 1,
	1, 1, 1, 1, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,

	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
};

#ifndef NDEBUG
int Show_controls_info = 0;

DCF_BOOL(show_controls_info, Show_controls_info);

DCF(cc_adjust, "UI tool Used to adjust positioning and size of the controls config widgets") {
	bool done = false;

	if (dc_optional_string_either("help", "--help")) {
		dc_printf("Available sub commands: \n");
		dc_printf("  list - configures control_list_coords\n");
		dc_printf("  col - configures the horizontal position and widths of control_list columns\n");
		dc_printf("\n Each sub command has their own arguments, pass 'help' to them for further details.");
		return;
	}

	if (dc_optional_string("list")) {
		// listbox
		if (dc_optional_string_either("help", "--help")) {
			dc_printf("Configures control_list_coords\n");
			dc_printf(" Available arguments: -x -y -w -h");
			return;
		}

		if (dc_optional_string("-x")) {
			dc_stuff_int(&Control_list_coords[gr_screen.res][CONTROL_X_COORD]);
			done = true;
		}
		if (dc_optional_string("-y")) {
			dc_stuff_int(&Control_list_coords[gr_screen.res][CONTROL_Y_COORD]);
			done = true;
		}
		if (dc_optional_string("-w")) {
			dc_stuff_int(&Control_list_coords[gr_screen.res][CONTROL_W_COORD]);
			done = true;
		}
		if (dc_optional_string("-h")) {
			dc_stuff_int(&Control_list_coords[gr_screen.res][CONTROL_H_COORD]);
			done = true;
		}

	} else if (dc_optional_string("col")) {
		if (dc_optional_string_either("help", "--help")) {
			dc_printf("Configures the column positioning and sizes for Control_list\n");
			dc_printf("  Avilable arguments: -x1 -w1 -x2");
			return;
		}

		if (dc_optional_string("-x1")) {
			dc_stuff_int(&Control_list_first_x[gr_screen.res]);
			done = true;
		}
		if (dc_optional_string("-w1")) {
			dc_stuff_int(&Control_list_first_w[gr_screen.res]);
			done = true;
		}
		if (dc_optional_string("-x2")) {
			dc_stuff_int(&Control_list_second_x[gr_screen.res]);
			done = true;
		}
	}

	if (!done) {
		dc_printf("Nothing done. Enter 'help' or '--help' for available arguments.");
	}
}
#endif

/**
 * Values for all axes of all joysticks at the start of bind mode.  Namely used to detect an axis that moved far enough
 * from this "origin"
 */
static int Axes_origin[CID_JOY_MAX][JOY_NUM_AXES];

// Rotate selItem forwards
selItem operator++(selItem& item, int) {
	Assert(item != selItem::selItem_END);
	using type = typename std::underlying_type<selItem>::type;

	item = static_cast<selItem>(static_cast<type>(item) + 1);

	if (item == selItem::selItem_END) {
		// Set to first item
		item = static_cast<selItem>(static_cast<type>(selItem::selItem_REND) + 1);;
	}

	return item;
}

// Rotate selItem backwards
selItem operator--(selItem& item, int) {
	Assert(item != selItem::selItem_REND);
	using type = typename std::underlying_type<selItem>::type;

	item = static_cast<selItem>( static_cast<type>(item) - 1 );
	
	if (item == selItem::selItem_REND) {
		// Set to last item
		item = static_cast<selItem>(static_cast<type>(selItem::selItem_END) - 1);;
	}

	return item;
}

static int joy_get_unscaled_reading(int raw)
{
	const int rng = JOY_AXIS_MAX - JOY_AXIS_MIN;
	raw -= JOY_AXIS_MIN;  // adjust for linear range starting at 0

	// cap at limits
	if (raw < 0)
		raw = 0;
	if (raw > rng)
		raw = rng;

	return (int) ((std::uint64_t) raw * (std::uint64_t) F1_0 / (std::uint64_t) rng);  // convert to 0 - F1_0 range, 64bit ints used to avoid uint overflow
}

int joy_get_scaled_reading(int raw)
{
	int x, d, dead_zone, rng;
	float percent, sensitivity_percent, non_sensitivity_percent;

	raw -= JOY_AXIS_CENTER;

	if (Cmdline_deadzone >= 0) {
		dead_zone = (JOY_AXIS_MAX - JOY_AXIS_MIN) * Cmdline_deadzone / 200; 
		//Making this div by 200 is what allows us to have the granularity of 0 to 100 in the cmdline. 
		//This allows a larger deadzone than the original maximum, all the way to the stick's full range.
	} else {
		dead_zone = (JOY_AXIS_MAX - JOY_AXIS_MIN) * Joy_dead_zone_size / 100;
	}

	if (raw < -dead_zone) {
		rng = JOY_AXIS_CENTER - JOY_AXIS_MIN - dead_zone;
		d = -raw - dead_zone;
	} else if (raw > dead_zone) {
		rng = JOY_AXIS_MAX - JOY_AXIS_CENTER - dead_zone;
		d = raw - dead_zone;
	} else
		return 0;

	if (d > rng)
		d = rng;

	Assert(Joy_sensitivity >= 0 && Joy_sensitivity <= 9);

	// compute percentages as a range between 0 and 1
	sensitivity_percent = (float) Joy_sensitivity / 9.0f;
	non_sensitivity_percent = (float) (9 - Joy_sensitivity) / 9.0f;

	// find percent of max axis is at
	percent = (float) d / (float) rng;

	// work sensitivity on axis value
	percent = (percent * sensitivity_percent + percent * percent * percent * percent * percent * non_sensitivity_percent);

	x = (int) ((float) F1_0 * percent);

	//nprintf(("AI", "d=%6i, sens=%3i, percent=%6.3f, val=%6i, ratio=%6.3f\n", d, Joy_sensitivity, percent, (raw<0) ? -x : x, (float) d/x));

	if (raw < 0)
		return -x;

	return x;
}

/**
 * Initializes a reference point on all axes of all joysticks so that control_config_detect_axis can detect an axis
 * that was deflected far enough
 */
void control_config_detect_axis_reset()
{
	for (short j = CID_JOY0; j < CID_JOY_MAX; ++j) {
		joystick_read_raw_axis(j, JOY_NUM_AXES, Axes_origin[j]);
	}
}

/**
 * Detects if a joystick axis was moved
 */
CC_bind control_config_detect_axis()
{
	int dx, dy, dz;
	int delta = 16384;
	int axes_values[CID_JOY_MAX][JOY_NUM_AXES];
	short j;			// cid of the joy that moved
	short axis = -1;	// index of the detected axis
	const int deadzone = 7;	// Minor deadzone for mouse axis detection

	// Find an axis among any of the joysticks that has deflected far enough
	for (j = CID_JOY0; j < CID_JOY_MAX; ++j) {
		if (!joy_present(j)) {
			// Joy not present, skip
			continue;
		}

		joystick_read_raw_axis(j, JOY_NUM_AXES, axes_values[j]);
		for (short i = 0; i < JOY_NUM_AXES; i++) {
			dx = abs(axes_values[j][i] - Axes_origin[j][i]);

			if (dx > delta) {
				axis = i;
				delta = dx;
				goto found_axis;
			}
		}
	}
	found_axis:;

	if (j == CID_JOY_MAX) {
		// Nothing found amongst the joysticks. Check the mouse.
		mouse_get_delta( &dx, &dy, &dz );

		if (Use_mouse_to_fly) {
			// Treat mouse as Joy0
			j = CID_JOY0;

			if ((dx > deadzone) || (dx < -deadzone)) {
				axis = JOY_X_AXIS;

			} else if ((dy > deadzone) || (dy < -deadzone)) {
				axis = JOY_Y_AXIS;

			} else if ((dz > deadzone) || (dz < -deadzone)) {
				axis = JOY_Z_AXIS;

			} else {
				// Nothing detected
				j = CID_NONE;
			}

		} else {
			// Treat mouse as mouse
			j = CID_MOUSE;

			if ((dx > deadzone) || (dx < -deadzone)) {
				axis = MOUSE_X_AXIS;

			} else if ((dy > deadzone) || (dy < -deadzone)) {
				axis = MOUSE_Y_AXIS;

			} else if ((dz > deadzone) || (dz < -deadzone)) {
				axis = MOUSE_Z_AXIS;

			} else {
				// Nothing detected
				j = CID_NONE;
			}
		}
	}
	
	return CC_bind(static_cast<CID>(j), axis, CCF_AXIS);;
}

/**
 * @brief Checks all controls for conflicts.  This should be called after any change to any bindings.
 */
void control_config_conflict_check()
{
	int i, j;
	const int CCFG_SIZE = static_cast<int>(Control_config.size());
	
	for (i=0; i < CCFG_SIZE; i++) {
		Conflicts[i].first = Conflicts[i].second = -1;
	}

	for (i=0; i<NUM_TABS; i++) {
		Conflicts_tabs[i] = 0;
	}

	for (i = 0; i < (CCFG_SIZE - 1); i++) {
		auto &item_i = Control_config[i];
		if (item_i.empty()) {
			// skip
			continue;
		}

		for (j = i + 1; j < CCFG_SIZE; j++) {
			auto &item_j = Control_config[j];
			if (item_j.empty()) {
				// skip
				continue;
			}

			// Skip conflict check between items in different conflict groups
			if ((item_i.conflict_groups & item_j.conflict_groups) == 0) {
				continue;
			}

			if (item_i.disabled && (item_i.has_first_conflict(item_j) || item_i.has_second_conflict(item_j))) {
				// item_i conflicts with item_j and is disabled.  Silently clear item_i
				item_i.clear();
			}

			if (item_j.disabled && (item_j.has_first_conflict(item_i) || item_j.has_second_conflict(item_i))) {
				// item_j conflicts with item_i and is disabled.  Silently clear item_j
				item_j.clear();
			}

			// Clearly a headache
			// This mess is needed so that only the conflicting bind is highlighted instead of both of them
			if (item_i.has_first_conflict(item_j)) {
				// item_i's first binding has conflict
				Conflicts[i].first = j;
				Conflicts_tabs[ item_i.tab ] = 1;
			}

			if (item_i.has_second_conflict(item_j)) {
				// item_i's second binding has conflict
				Conflicts[i].second = j;
				Conflicts_tabs[ item_i.tab ] = 1;
			}

			if (item_j.has_first_conflict(item_i)) {
				// item_j's first binding has conflict
				Conflicts[j].first = i;
				Conflicts_tabs[item_j.tab] = 1;
			}

			if (item_j.has_second_conflict(item_i)) {
				// item_j's second binding has conflict
				Conflicts[j].second = i;
				Conflicts_tabs[ item_j.tab ] = 1;
			}
		}
	}
}

// do list setup required prior to rendering and checking for the controls listing.  Called when list changes
void control_config_list_prepare()
{
	int y;	// Offset, in pixels, the Cc_line has from the top
	int z;	// index into Control_config[]
	int font_height = gr_get_font_height();

	Num_cc_lines = y = z = 0;

	// Populate the digital controls
	for (const auto &item : Control_config) {
		if (item.tab == Tab && !item.disabled) {
			if (item.indexXSTR > 1) {
				Cc_lines[Num_cc_lines].label = XSTR(item.text.c_str(), item.indexXSTR, true);
			} else if (item.indexXSTR == 1) {
				Cc_lines[Num_cc_lines].label = XSTR(item.text.c_str(), CONTROL_CONFIG_XSTR + z, true);
			} else {
				Cc_lines[Num_cc_lines].label = item.text.c_str();
			}

			Cc_lines[Num_cc_lines].cc_index = z;
			Cc_lines[Num_cc_lines++].y = y;
			y += font_height + 2;
		} // Else, Ignore and hide items

		z++;	// z is the index position in Control_config[]
	}
}

int cc_line_query_visible(int n)
{
	int y;

	if ((n < 0) || (n >= Num_cc_lines)) {
		return 0;
	}
	
	y = Cc_lines[n].y - Cc_lines[Scroll_offset].y;
	if ((y < 0) || (y + gr_get_font_height() > Control_list_coords[gr_screen.res][CONTROL_H_COORD])){
		return 0;
	}

	return 1;
}

/**
 * @brief Wrapper for CC_bind::take(), binds a given control
 */
void control_config_bind(int i, const CC_bind &new_bind, selItem order, bool API_Access = false)
{
	int sel = -1;
	switch (order) {
		// Bind states. Saving covered by below
		case selItem::Primary:
			sel = 0;
			break;

		case selItem::Secondary:
			sel = 1;
			break;

		case selItem::None:
			sel = -1;
			break;

		// Error
		default:
			UNREACHABLE("Unknown order (%i) passed to control_config_bind_btn.", static_cast<int>(order));
	}

	// Save both bindings, because ::take() can clear the other binding if it is equal.
	Undo_stack stack;
	stack.save(Control_config[i].first);
	stack.save(Control_config[i].second);
	Undo_controls.save_stack(std::move(stack));

	CCB old(Control_config[i]);

	Control_config[i].take(new_bind, sel);

	if (old == Control_config[i]) {
		// Binding didn't take
		Undo_controls.undo();
		if (!API_Access) {
			gamesnd_play_iface(InterfaceSounds::GENERAL_FAIL);
		}
	}
}


/**
 * @brief Unbinds the selected control
 */
bool control_config_remove_binding(int ctrl, selItem item, bool API_Access)
{
	bool success = true;

	switch (item) {
	case selItem::None:
		// Clear both
		if (!(Control_config[ctrl].empty())) {
			Undo_stack stack;

			stack.save(Control_config[ctrl].first);
			stack.save(Control_config[ctrl].second);
			Undo_controls.save_stack(std::move(stack));

			Control_config[ctrl].first.clear();
			Control_config[ctrl].second.clear();

		} else {
			success = false;
		}
		break;

	case selItem::Primary:
		// Clear only primary
		if (!Control_config[ctrl].first.empty()) {
			Undo_controls.save(Control_config[ctrl].first);
			Control_config[ctrl].first.clear();

		} else {
			success = false;
		}
		break;

	case selItem::Secondary:
		// Clear only Secondary
		if (!Control_config[ctrl].second.empty()) {
			Undo_controls.save(Control_config[ctrl].second);
			Control_config[ctrl].second.clear();

		} else {
			success = false;
		}
		break;

	default:
		// Coder forgot to add a case!
		UNREACHABLE("Unhandled selItem case: %i", static_cast<int>(item));
	}

	if (success)
		control_config_conflict_check();

	if (!API_Access) {
		if (success) {
			control_config_list_prepare();
			gamesnd_play_iface(InterfaceSounds::USER_SELECT);
			Selected_item = selItem::None;
		} else {
			gamesnd_play_iface(InterfaceSounds::GENERAL_FAIL);
		}
	}

	if (success) {
		return true;
	} else {
		return false;
	}
}

/**
 * @brief Clears all conflicting control bindings, except the selected control
 */
bool control_config_clear_other(int ctrl, bool API_Access)
{
	const auto& selected = Control_config[ctrl];

	// Fail if selected item is empty
	if (selected.empty()) {
		if (!API_Access)
			gamesnd_play_iface(InterfaceSounds::GENERAL_FAIL);
		return false;
	}

	// Back up the old bindings
	Undo_stack stack;

	int total = 0;
	for (int i = total = 0; i < (int)Control_config.size(); ++i) {
		if (i == ctrl) {
			// skip
			continue;
		}

		auto &other = Control_config[i];

		if (other.has_first_conflict(selected)) {
			stack.save(other.first);
			other.first.clear();
			total++;
		}

		if (other.has_second_conflict(selected)) {
			stack.save(other.second);
			other.second.clear();
			total++;
		}
	}

	// Fail if no conflicts
	if (total == 0) {
		if (!API_Access)
			gamesnd_play_iface(InterfaceSounds::GENERAL_FAIL);
		return false;
	}

	Undo_controls.save_stack(std::move(stack));
	control_config_conflict_check();

	if (!API_Access) {
		control_config_list_prepare();
		gamesnd_play_iface(InterfaceSounds::USER_SELECT);
	}

	return true;
}

/**
 * @brief Unbinds ALL controls
 * TODO: unbind axes and reset inversion
 */
bool control_config_clear_all(bool API_Access)
{
	int total = 0;

	// Back up items for undo and then clear the item
	Undo_stack stack;
	for (auto &item : Control_config) {
		if (!item.empty()) {
			stack.save(item.first);
			stack.save(item.second);

			item.clear();
			total++;
		}
	}

	// Fail if nothing was cleared
	if (total == 0) {
		if (!API_Access)
			gamesnd_play_iface(InterfaceSounds::GENERAL_FAIL);
		return false;
	}

	Undo_controls.save_stack(std::move(stack));
	control_config_conflict_check();

	if (!API_Access) {
		control_config_list_prepare();
		gamesnd_play_iface(InterfaceSounds::RESET_PRESSED);
	}
	return true;
}

/**
 * @brief Reverts all bindings to their preset. If already default, cycle to the next presets if cycle is true.
 */
bool control_config_do_reset(bool cycle, bool API_Access)
{
	int total = 0;
	Undo_stack stack;
	auto &default_bindings = Control_config_presets[Defaults_cycle_pos].bindings;

	// first, determine how many bindings need to be changed
	for (size_t e = 0; e < Control_config.size(); ++e) {
		const auto& item = Control_config[e];
		const auto& default_item = default_bindings[e];

		if (item.disabled) {
			// skip
			continue;
		}

		if ((item.first != default_item.first) ||
		    (item.second != default_item.second)) {
			total++;
		}
	}

	if ((total == 0) && (Control_config_presets.size() <= 1)) {
		// Nothing to reset, no other presets besides default
		if (!API_Access)
			gamesnd_play_iface(InterfaceSounds::GENERAL_FAIL);
		return false;
	}

	if (total == 0) {

		if (cycle) {
			// Select next preset
			stack.save(Defaults_cycle_pos);

			Defaults_cycle_pos++;
			if (Defaults_cycle_pos >= Control_config_presets.size()) {
				Defaults_cycle_pos = 0;
			}
		} else {
			if (!API_Access)
				gamesnd_play_iface(InterfaceSounds::GENERAL_FAIL);
			return false;
		}
	}

	// Save all item bindings for undo
	for (auto &item : Control_config) {
		stack.save(item.first);
		stack.save(item.second);
	}
	Undo_controls.save_stack(std::move(stack));

	control_config_use_preset(Control_config_presets[Defaults_cycle_pos]);

	control_config_conflict_check();

	if (!API_Access) {
		control_config_list_prepare();
		gamesnd_play_iface(InterfaceSounds::RESET_PRESSED);
	}
	return true;
}

void control_config_use_preset(CC_preset &preset)
{
	
	// Reset all
	const auto &bindings = preset.bindings;
	const size_t size = MIN(bindings.size(), Control_config.size());
	Assert(size >= CCFG_MAX);
	for (size_t i = 0; i < size; ++i) {
		// Don't use std::copy here, since the preset may contain more bindings than Control_config
		Control_config[i].first = bindings[i].first;