quakeforge/libs/input/in_imt.c

/*
	in_imt.c

	Input Mapping Table management

	Copyright (C) 2001 Zephaniah E. Hull <warp@babylon.d2dc.net>
	Copyright (C) 2021 Bill Currie <bill@taniwha.org>

	Author: Bill Currie <bill@taniwha.org>
	Date: 2021/10/30

	This program is free software; you can redistribute it and/or
	modify it under the terms of the GNU General Public License
	as published by the Free Software Foundation; either version 2
	of the License, or (at your option) any later version.

	This program is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

	See the GNU General Public License for more details.

	You should have received a copy of the GNU General Public License
	along with this program; if not, write to:

		Free Software Foundation, Inc.
		59 Temple Place - Suite 330
		Boston, MA  02111-1307, USA

*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif

#ifdef HAVE_STRING_H
# include <string.h>
#endif
#ifdef HAVE_STRINGS_H
# include <strings.h>
#endif

#include "QF/cmd.h"
#include "QF/cmem.h"
#include "QF/cvar.h"
#include "QF/hash.h"
#include "QF/input.h"
#include "QF/mathlib.h"
#include "QF/plist.h"
#include "QF/sys.h"
#include "QF/va.h"

#include "QF/input/imt.h"

#include "QF/input/binding.h"
#include "QF/input/imt.h"

#include "qfalloca.h"

/** Describe a region of imt bindings (axis or button)

	Each device may have a block of axis bindings and a block of button
	bindings (some devices will have only the one block).

	Bindings are allocated to a device in contiguous blocks.
*/
typedef struct imt_block_s {
	int         base;               ///< index of first binding
	int         count;              ///< number of bindings
} imt_block_t;

typedef struct DARRAY_TYPE (in_context_t) in_contextset_t;
typedef struct DARRAY_TYPE (imt_block_t) imt_blockset_t;
/** Binding blocks are allocated across all imts
*/
static imt_blockset_t axis_blocks = DARRAY_STATIC_INIT (8);
static imt_blockset_t button_blocks = DARRAY_STATIC_INIT (8);

static in_contextset_t in_contexts = DARRAY_STATIC_INIT (8);
static size_t   imt_current_context;

static memsuper_t *binding_mem;
static hashtab_t *recipe_tab;

static in_recipe_t *
alloc_recipe (void)
{
	return cmemalloc (binding_mem, sizeof (in_recipe_t));
}

static void
free_recipe (in_recipe_t *recipe)
{
	if (!recipe) {
		return;
	}
	cmemfree (binding_mem, recipe);
}

static void
recipe_free (void *recipe, void *data)
{
	free_recipe (recipe);
}

static uintptr_t
recipe_get_hash (const void *recipe, void *data)
{
	return Hash_Buffer (recipe, sizeof (in_recipe_t));
}

static int
recipe_compare (const void *a, const void *b, void *data)
{
	return !memcmp (a, b, sizeof (in_recipe_t));
}

static in_axisbinding_t *
alloc_axis_binding (void)
{
	return cmemalloc (binding_mem, sizeof (in_axisbinding_t));
}

static void
free_axis_binding (in_axisbinding_t *binding)
{
	if (!binding) {
		return;
	}
	cmemfree (binding_mem, binding);
}

static in_buttonbinding_t *
alloc_button_binding (void)
{
	return cmemalloc (binding_mem, sizeof (in_buttonbinding_t));
}

static void
free_button_binding (in_buttonbinding_t *binding)
{
	if (!binding) {
		return;
	}
	switch (binding->type) {
		case inb_button:
			break;
		case inb_command:
			free (binding->command);
			break;
	}
	cmemfree (binding_mem, binding);
}

static imt_block_t *
imt_get_block (imt_blockset_t *blockset)
{
    return DARRAY_OPEN_AT (blockset, blockset->size, 1);
}

static int
imt_get_next_base (imt_blockset_t *blockset)
{
    if (!blockset->size) {
        return 0;
    }
    imt_block_t *b = &blockset->a[blockset->size - 1];
    return b->base + b->count;
}

static int
imt_get_axis_block (int count)
{
    int         base = imt_get_next_base (&axis_blocks);

    for (size_t i = 0; i < in_contexts.size; i++) {
        for (imt_t *imt = in_contexts.a[i].imts; imt; imt = imt->next) {
            in_axisbinding_t **binding;
            binding = DARRAY_OPEN_AT (&imt->axis_bindings, base, count);
            memset (binding, 0, count * sizeof (binding));
        }
    }
    return base;
}

static int
imt_get_button_block (int count)
{
    int         base = imt_get_next_base (&button_blocks);

    for (size_t i = 0; i < in_contexts.size; i++) {
        for (imt_t *imt = in_contexts.a[i].imts; imt; imt = imt->next) {
            in_buttonbinding_t **binding;
            binding = DARRAY_OPEN_AT (&imt->button_bindings, base, count);
            memset (binding, 0, count * sizeof (binding));
        }
    }
    return base;
}

static void
imt_reset_blocks (void)
{
	DARRAY_RESIZE (&axis_blocks, 0);
	DARRAY_RESIZE (&button_blocks, 0);
    for (size_t i = 0; i < in_contexts.size; i++) {
        for (imt_t *imt = in_contexts.a[i].imts; imt; imt = imt->next) {
			DARRAY_RESIZE (&imt->axis_bindings, 0);
			DARRAY_RESIZE (&imt->button_bindings, 0);
        }
    }
}

int
IMT_GetAxisBlock (int num_axes)
{
	int         base = imt_get_axis_block (num_axes);
	imt_block_t *block = imt_get_block (&axis_blocks);
	block->base = base;
	block->count = num_axes;
	return base;
}

int
IMT_GetButtonBlock (int num_buttons)
{
	int         base = imt_get_button_block (num_buttons);
	imt_block_t *block = imt_get_block (&button_blocks);
	block->base = base;
	block->count = num_buttons;
	return base;
}

int
IMT_CreateContext (const char *name)
{
	in_context_t *ctx = DARRAY_OPEN_AT (&in_contexts, in_contexts.size, 1);
	memset (ctx, 0, sizeof (*ctx));
	ctx->imt_tail = &ctx->imts;
	ctx->switcher_tail = &ctx->switchers;
	ctx->name = name;
	return ctx - in_contexts.a;
}

static in_context_t * __attribute__ ((pure))
imt_find_context (const char *name)
{
	if (name) {
		for (size_t i = 0; i < in_contexts.size; i++) {
			if (strcmp (name, in_contexts.a[i].name) == 0) {
				return &in_contexts.a[i];
			}
		}
	}
	return 0;
}

static void
imt_switcher_update (imt_switcher_t *switcher)
{
	int         state = 0;

	for (int i = 0; i < switcher->num_inputs; i++) {
		imt_input_t *input = &switcher->inputs[i];
		int          val = 0;
		switch (input->type) {
			case imti_button:
				val = !!(input->button->state & inb_down);
				break;
			case imti_cvar:
				//FIXME check cvar type
				val = !!*(int *) input->cvar->value.value;
				break;
		}
		state |= val << i;
	}
	switcher->context->active_imt = switcher->imts[state];
}

static void
imt_switcher_button_update (void *_switcher, const in_button_t *button)
{
	imt_switcher_update (_switcher);
}

static void
imt_switcher_cvar_update (void *_switcher, const cvar_t *cvar)
{
	imt_switcher_update (_switcher);
}

int
IMT_GetContext (void)
{
	return imt_current_context;
}

void
IMT_SetContext (int ctx)
{
	if ((size_t) ctx >= in_contexts.size) {
		Sys_Error ("IMT_SetContext: invalid context %d", ctx);
	}
	imt_current_context = ctx;
	for (imt_switcher_t *switcher = in_contexts.a[ctx].switchers; switcher;
		 switcher = switcher->next) {
		imt_switcher_update (switcher);
	}
	imt_t      *imt = in_contexts.a[imt_current_context].active_imt;
	Sys_MaskPrintf (SYS_input, "Switched to %s context, imt %s\n",
					in_contexts.a[imt_current_context].name,
					imt ? imt->name : 0);
}

void
IMT_SetContextCbuf (int ctx, cbuf_t *cbuf)
{
	if ((size_t) ctx >= in_contexts.size) {
		Sys_Error ("IMT_SetContextCbuf: invalid context %d", ctx);
	}
	in_contexts.a[ctx].cbuf = cbuf;
}

static imt_t * __attribute__ ((pure))
imt_find_imt (in_context_t *ctx, const char *name)
{
	for (imt_t *imt = ctx->imts; imt; imt = imt->next) {
		if (strcasecmp (imt->name, name) == 0) {
			return imt;
		}
	}
	return 0;
}

imt_t *
IMT_FindIMT (const char *name)
{
    for (size_t i = 0; i < in_contexts.size; i++) {
		in_context_t *ctx = &in_contexts.a[i];
		imt_t      *imt = imt_find_imt (ctx, name);
		if (imt) {
			return imt;
		}
	}
	return 0;
}

static imt_switcher_t * __attribute__((pure))
imt_find_switcher (in_context_t *ctx, const char *name)
{
	for (imt_switcher_t *switcher = ctx->switchers; switcher;
		 switcher = switcher->next) {
		if (strcasecmp (switcher->name, name) == 0) {
			return switcher;
		}
	}
	return 0;
}

imt_switcher_t *
IMT_FindSwitcher (const char *name)
{
    for (size_t i = 0; i < in_contexts.size; i++) {
		in_context_t *ctx = &in_contexts.a[i];
		imt_switcher_t *switcher = imt_find_switcher (ctx, name);
		if (switcher) {
			return switcher;
		}
	}
	return 0;
}

int
IMT_CreateIMT (int context, const char *imt_name, const char *chain_imt_name)
{
	in_context_t *ctx = &in_contexts.a[context];
	imt_t      *imt;
	imt_t      *chain_imt = 0;

	if ((size_t) context >= in_contexts.size) {
		Sys_Printf ("invalid imt context %d\n", context);
		return 0;
	}

	if (IMT_FindIMT (imt_name)) {
		Sys_Printf ("imt %s already exists\n", imt_name);
		return 0;
	}
	if (chain_imt_name) {
		chain_imt = IMT_FindIMT (chain_imt_name);
		if (!chain_imt) {
			Sys_Printf ("chain imt %s does not exist\n", chain_imt_name);
			return 0;
		}
		chain_imt = imt_find_imt (ctx, chain_imt_name);
		if (!chain_imt) {
			Sys_Printf ("chain imt %s not in target context\n",
						chain_imt_name);
			return 0;
		}
	}
	imt = malloc (sizeof (imt_t));
	if (!ctx->imts) {
		ctx->default_imt = imt;
		ctx->active_imt = imt;
	}
	*ctx->imt_tail = imt;
	ctx->imt_tail = &imt->next;

	imt->next = 0;
	imt->chain = chain_imt;
	imt->name = strdup (imt_name);
	imt->written = 0;
	DARRAY_INIT (&imt->axis_bindings, 8);
	DARRAY_INIT (&imt->button_bindings, 8);
	int         num_axes = imt_get_next_base (&axis_blocks);
	int         num_buttons = imt_get_next_base (&button_blocks);
	DARRAY_RESIZE (&imt->axis_bindings, num_axes);
	DARRAY_RESIZE (&imt->button_bindings, num_buttons);
	if (num_axes) {
		memset (imt->axis_bindings.a, 0,
				num_axes * sizeof (in_axisbinding_t *));
	}
	if (num_buttons) {
		memset (imt->button_bindings.a, 0,
				num_buttons * sizeof (in_buttonbinding_t *));
	}
	return 1;
}

int
IMT_CreateSwitcher (const char *switcher_name, int context, imt_t *default_imt,
					int num_inputs, const char **input_names)
{
	if (IMT_FindSwitcher (switcher_name)) {
		Sys_Printf ("imt switcher %s already exists\n", switcher_name);
		return 0;
	}

	if ((size_t) context >= in_contexts.size) {
		Sys_Printf ("invalid imt context %d\n", context);
		return 0;
	}
	in_context_t *ctx = &in_contexts.a[context];

	if (!imt_find_imt (ctx, default_imt->name)) {
		Sys_Printf ("default imt %s not in context %s\n",
					default_imt->name, ctx->name);
		return 0;
	}

	int         input_error = 0;
	if (num_inputs > 16) {
		Sys_Printf ("too many inputs %d\n", num_inputs);
		return 0;
	}
	for (int i = 0; i < num_inputs; i++) {
		const char *input_name = input_names[i];
		if (!input_name) {
			input_error = 1;
			continue;
		}
		if (input_name[0] == '+') {
			if (!IN_FindButton (input_name + 1)) {
				Sys_Printf ("invalid button %s\n", input_name);
				input_error = 1;
			}
		} else {
			if (!Cvar_FindVar (input_name)) {
				Sys_Printf ("invalid cvar %s\n", input_name);
				input_error = 1;
			}
		}
	}
	if (input_error) {
		return 0;
	}
	int         num_states = 1 << num_inputs;
	size_t      size = sizeof (imt_switcher_t)
						+ num_inputs * sizeof (imt_input_t)
						+ num_states * sizeof (imt_t *);
	imt_switcher_t *switcher = malloc (size);
	*ctx->switcher_tail = switcher;
	ctx->switcher_tail = &switcher->next;

	switcher->next = 0;
	switcher->name = strdup (switcher_name);
	switcher->num_inputs = num_inputs;
	switcher->inputs = (imt_input_t *) (switcher + 1);
	switcher->imts = (imt_t **) (switcher->inputs + num_inputs);
	switcher->context = ctx;
	for (int i = 0; i < num_inputs; i++) {
		imt_input_t *input = &switcher->inputs[i];
		const char *input_name = input_names[i];
		if (input_name[0] == '+') {
			input->type = imti_button;
			input->button = IN_FindButton (input_name + 1);
			IN_ButtonAddListener (input->button, imt_switcher_button_update,
								  switcher);
		} else {
			input->type = imti_cvar;
			//FIXME check cvar type
			input->cvar = Cvar_FindVar (input_name);
			Cvar_AddListener (input->cvar, imt_switcher_cvar_update, switcher);
		}
	}
	for (int i = 0; i < num_states; i++) {
		switcher->imts[i] = default_imt;
	}
	return 1;
}

void
IMT_BindAxis (imt_t *imt, int axis_num, in_axis_t *axis,
			  const in_recipe_t *recipe)
{
	if ((size_t) axis_num >= imt->axis_bindings.size)
		return;

	in_axisbinding_t **bind = &imt->axis_bindings.a[axis_num];
	free_axis_binding ((*bind));
	(*bind) = 0;
	if (axis && recipe) {
		in_axisbinding_t *a = alloc_axis_binding ();
		(*bind) = a;
		if (!(a->recipe = Hash_FindElement (recipe_tab, recipe))) {
			*(a->recipe = alloc_recipe ()) = *recipe;
			Hash_AddElement (recipe_tab, a->recipe);
		}
		a->axis = axis;
	}
}

void
IMT_BindButton (imt_t *imt, int button, const char *binding)
{
	if ((size_t) button >= imt->button_bindings.size)
		return;

	in_buttonbinding_t **bind = &imt->button_bindings.a[button];
	free_button_binding ((*bind));
	(*bind) = 0;
	if (binding) {
		in_buttonbinding_t *b = alloc_button_binding ();
		(*bind) = b;
		in_button_t *button;
		if (binding[0] == '+' && (button = IN_FindButton (binding + 1))) {
			b->type = inb_button;
			b->button = button;
		} else {
			b->type = inb_command;
			b->command = strdup(binding);
		}
	}
}

bool
IMT_ProcessAxis (int axis, int value)
{
	imt_t      *imt = in_contexts.a[imt_current_context].active_imt;

	while (imt) {
		in_axisbinding_t *a = imt->axis_bindings.a[axis];
		if (a) {
			in_recipe_t *recipe = a->recipe;
			int         relative = recipe->min == recipe->max;
			int         deadzone = recipe->deadzone;
			int         minval = recipe->min + recipe->minzone;
			int         maxval = recipe->max - recipe->maxzone;
			float       output;
			if (relative) {
				int         input = value;
				if (deadzone > 0) {
					if (input > deadzone) {
						input -= deadzone;
					} else if (input < -deadzone) {
						input += deadzone;
					} else {
						input = 0;
					}
				}
				output = input * recipe->scale;
				if (recipe->curve != 1) {
					output = powf (output, recipe->curve);
				}
				a->axis->rel_input += output;
			} else {
				int         input = bound (minval, value, maxval);
				int         range = maxval - minval;
				int         zero = minval;
				if (recipe->deadzone >= 0) {
					// balanced axis: -1..1
					int         center = (recipe->min + recipe->max + 1) / 2;
					minval += deadzone;
					maxval -= deadzone;
					input -= center;
					if (input < -deadzone) {
						input += deadzone;
					} else if (input > deadzone) {
						input -= deadzone;
					} else {
						input = 0;
					}
					if (center - minval > maxval - center) {
						range = center - minval;
					} else {
						range = maxval - center;
					}
					zero = 0;
				}
				output = (float)(input - zero) / (range);
				if (recipe->curve != 1) {
					output = powf (output, recipe->curve);
				}
				output *= recipe->scale;
				a->axis->abs_input = output;
			}
			return true;
		}
		imt = imt->chain;
	}
	return false;
}

static void
process_binding (int button, int state, const char *cmd)
{
	cbuf_t     *cbuf = in_contexts.a[imt_current_context].cbuf;

	if (!cbuf) {
		return;
	}

	if (cmd[0] == '+') {
		if (state) {
			Cbuf_AddText (cbuf, va (0, "%s %d\n", cmd, button));
		} else {
			Cbuf_AddText (cbuf, va (0, "-%s %d\n", cmd + 1, button));
		}
	} else {
		if (state) {
			Cbuf_AddText (cbuf, va (0, "%s\n", cmd));
		}
	}
}

bool
IMT_ProcessButton (int button, int state)
{
	imt_t      *imt = in_contexts.a[imt_current_context].active_imt;

	while (imt) {
		in_buttonbinding_t *b = imt->button_bindings.a[button];
		if (b) {
			// ensure IN_ButtonAction never sees button id 0
			button += 1;
			switch (b->type) {
				case inb_button:
					IN_ButtonAction (b->button, button, state);
					break;
				case inb_command:
					//FIXME avoid repeat
					process_binding (button, state, b->command);
					break;
			}
			return true;
		}
		imt = imt->chain;
	}
	return false;
}

static void
imt_f (void)
{
	int         c;
	imt_t      *imt;
	const char *imt_name = 0;
	const char *context_name;

	c = Cmd_Argc ();
	switch (c) {
		case 3:
			imt_name = Cmd_Argv (2);
		case 2:
			context_name = Cmd_Argv (1);
			break;
		default:
			return;
	}
	in_context_t *ctx = imt_find_context (context_name);
	if (!ctx) {
		Sys_Printf ("imt error: invalid context: %s\n", context_name);
		return;
	}

	if (!imt_name) {
		Sys_Printf ("Current imt is %s\n", ctx->active_imt->name);
		Sys_Printf ("imt <imt> : set to a specific input mapping table\n");
		return;
	}

	imt = imt_find_imt (ctx, imt_name);
	if (!imt) {
		Sys_Printf ("\"%s\" is not an imt in %s\n", imt_name, ctx->name);
		return;
	}

	ctx->active_imt = imt;
}

static void
imt_list_f (void)
{
    for (size_t i = 0; i < in_contexts.size; i++) {
		in_context_t *ctx = &in_contexts.a[i];
		Sys_Printf ("context: %s\n", ctx->name);
		for (imt_t *imt = ctx->imts; imt; imt = imt->next) {
			if (imt->chain) {
				Sys_Printf ("    %s -> %s\n", imt->name, imt->chain->name);
			} else {
				Sys_Printf ("    %s\n", imt->name);
			}
		}
	}
}

static void
imt_create_f (void)
{
	const char *context_name;
	const char *imt_name;
	const char *chain_imt_name = 0;

	if (Cmd_Argc () < 3 || Cmd_Argc () > 4) {
		Sys_Printf ("see help imt_create\n");
		return;
	}
	context_name = Cmd_Argv (1);
	imt_name = Cmd_Argv (2);
	if (Cmd_Argc () == 4) {
		chain_imt_name = Cmd_Argv (3);
	}
	in_context_t *ctx = imt_find_context (context_name);
	if (!ctx) {
		Sys_Printf ("imt error: invalid context: %s\n", context_name);
		return;
	}
	IMT_CreateIMT (ctx - in_contexts.a, imt_name, chain_imt_name);
}

static void
imt_switcher_create_f (void)
{
	int         argc = Cmd_Argc ();

	if (argc < 5) {
		Sys_Printf ("see help imt_switcher_create\n");
		return;
	}

	const char *switcher_name = Cmd_Argv (1);
	const char *context_name = Cmd_Argv (2);
	const char *default_imt_name = Cmd_Argv (3);

	in_context_t *ctx = imt_find_context (context_name);
	if (!ctx) {
		Sys_Printf ("imt error: invalid context: %s\n", context_name);
		return;
	}

	imt_t      *default_imt = imt_find_imt (ctx, default_imt_name);
	if (!default_imt) {
		Sys_Printf ("default imt %s not in context %s\n",
					default_imt_name, context_name);
		return;
	}

	int         num_inputs = argc - 4;
	const char **input_names = alloca (num_inputs * sizeof (const char*));
	for (int i = 0; i < num_inputs; i++) {
		input_names[i] = Cmd_Argv (i + 4);
	}

	IMT_CreateSwitcher (switcher_name, ctx - in_contexts.a, default_imt,
						num_inputs, input_names);
}

static void
imt_switcher_f (void)
{
	int         argc = Cmd_Argc ();

	// state/imt pairs result in an even number of arguments
	if (argc < 4 || (argc & 1)) {
		Sys_Printf ("see help imt_switcher\n");
		return;
	}
	const char *switcher_name = Cmd_Argv (1);
	imt_switcher_t *switcher = IMT_FindSwitcher (switcher_name);
	if (!switcher) {
		Sys_Printf ("switcher %s does not exist\n", switcher_name);
		return;
	}
	int         num_states = 1 << switcher->num_inputs;
	for (int i = 2; i < argc; i += 2) {
		const char *state_str = Cmd_Argv (i + 0);
		const char *imt_name = Cmd_Argv (i + 1);
		char       *end;
		int         state = strtol (state_str, &end, 0);
		imt_t      *imt = imt_find_imt (switcher->context, imt_name);
		if (*end || state < 0 || state >= num_states) {
			Sys_Printf ("invalid state: %s\n", state_str);
			continue;
		}
		if (!imt) {
			Sys_Printf ("imt %s not in context %s\n",
						imt_name, switcher->context->name);
			continue;
		}
		switcher->imts[state] = imt;
	}
}

static void
imt_drop_all_f (void)
{
	for (size_t i = 0; i < in_contexts.size; i++) {
		in_context_t *ctx = &in_contexts.a[i];
		while (ctx->imts) {
			imt_t      *imt = ctx->imts;
			ctx->imts = imt->next;
			for (size_t i = 0; i < imt->axis_bindings.size; i++) {
				free_axis_binding (imt->axis_bindings.a[i]);
			}
			for (size_t i = 0; i < imt->button_bindings.size; i++) {
				free_button_binding (imt->button_bindings.a[i]);
			}
			DARRAY_CLEAR (&imt->axis_bindings);
			DARRAY_CLEAR (&imt->button_bindings);
			free ((char *) imt->name);
			free (imt);
		}
		while (ctx->switchers) {
			imt_switcher_t *switcher = ctx->switchers;
			ctx->switchers = switcher->next;
			for (int i = 0; i < switcher->num_inputs; i++) {
				imt_input_t *input = &switcher->inputs[i];
				switch (input->type) {
					case imti_button:
						IN_ButtonRemoveListener (input->button,
												 imt_switcher_button_update,
												 switcher);
						break;
					case imti_cvar:
						Cvar_RemoveListener (input->cvar,
											 imt_switcher_cvar_update,
											 switcher);
						break;
				}
			}
			free ((char *) switcher->name);
			free (switcher);
		}
		ctx->active_imt = 0;
		ctx->default_imt = 0;
		ctx->imt_tail = &ctx->imts;
		ctx->switcher_tail = &ctx->switchers;
	}
}

typedef struct {
	const char *name;
	xcommand_t  func;
	const char *desc;
} imtcmd_t;

static imtcmd_t imt_commands[] = {
	{	"imt", imt_f,
		"Set the active imt of the specified context"
	},
	{	"imt_list", imt_list_f,
		"List the available input mapping tables."
	},
	{	"imt_create", imt_create_f,
		"create a new imt table:\n"
		"    imt_create <context> <imt_name> [chain_name]\n"
		"\n"
		"The new table will be attached to the specified context.\n"
		"\n"
		"imt_name must not already exist.\n"
		"If given, chain_name must already exist and be in the context.\n"
	},
	{	"imt_switcher_create", imt_switcher_create_f,
		"create a new imt switcher:\n"
		"    imt_switcher_create <name> <context> <default_imt> <input0>"
			" [..<inputN>]\n"
		"name is the name of the switcher and must be unique across all\n"
		"contexts.\n"
		"\n"
		"The new switcher will be attached to the specified context\n"
		"\n"
		"default_imt specifies the default imt to be used for all possible\n"
		"states and must exist and be in the context.\n"
		"\n"
		"input0..inputN specify the inputs (cvar or button) used to set the\n"
		"switcher's state. As each input forms a bit in the state index,\n"
		"there will be 2**(N+1) states (so 4 inputs will result in 16\n"
		"states, and 16 inputs will result in 65536 states). Up to 16 inputs\n"
		"are allowed.\n"
		"\n"
		"Buttons are spefied as +buttonname (eg, +mlook, +strafe).\n"
		"Cvars are just the cvar name (eg, freelook, lookstrafe).\n"
		"\n"
		"Use imt_switcher to set the imt for each state.\n"
		"\n"
		"There can be multiple switchers in a context, but they can wind up\n"
		"fighting over the active imt for the context if they share inputs.\n"
	},
	{	"imt_switcher", imt_switcher_f,
		"Set the imts for states in an imt switcher:\n"
		"    imt_switcher <name> <state_index> <imt>"
			" [..<state_indexM> <imtM>]\n"
		"name is the name of the switcher to be modifed and must exist\n"
		"state_index is the state index formed by the binary number\n"
		"interpretation of the inputs with input0 being bit 0 and inputN\n"
		"being bit N.\n"
		"\n"
		"imt is the name of the imt to be assigned to the state and must\n"
		"exist and be in the same context as the switcher.\n"
		"\n"
		"Any number of state_index imt pairs can be specified.\n"
	},
	{	"imt_drop_all", imt_drop_all_f,
		"Delete all imt tables.\n"
	},
	{},
};

void
IMT_Init (void)
{
	binding_mem = new_memsuper ();
	recipe_tab = Hash_NewTable (61, 0, recipe_free, 0, 0);
	Hash_SetHashCompare (recipe_tab, recipe_get_hash, recipe_compare);
	for (imtcmd_t *cmd = imt_commands; cmd->name; cmd++) {
		Cmd_AddCommand (cmd->name, cmd->func, cmd->desc);
	}
}

void
IMT_Shutdown (void)
{
	imt_drop_all_f ();
	Hash_DelTable (recipe_tab);

	delete_memsuper (binding_mem);
	binding_mem = 0;
	DARRAY_CLEAR (&axis_blocks);
	DARRAY_CLEAR (&button_blocks);
	DARRAY_CLEAR (&in_contexts);
}

void
IMT_SaveConfig (plitem_t *config)
{
	plitem_t   *ctx_list = PL_NewArray ();
	PL_D_AddObject (config, "contexts", ctx_list);
	for (size_t i = 0; i < in_contexts.size; i++) {
		in_context_t *context = &in_contexts.a[i];
		plitem_t   *ctx = PL_NewDictionary (0);
		PL_A_AddObject (ctx_list, ctx);
		PL_D_AddObject (ctx, "name", PL_NewString (context->name));
		if (context->imts) {
			plitem_t   *imt_list = PL_NewArray ();
			PL_D_AddObject (ctx, "imts", imt_list);
			for (imt_t *imt = context->imts; imt; imt = imt->next) {
				plitem_t   *imt_cfg = PL_NewDictionary (0);
				PL_D_AddObject (imt_cfg, "name", PL_NewString (imt->name));
				if (imt->chain) {
					PL_D_AddObject (imt_cfg, "chain",
									PL_NewString (imt->chain->name));
				}
				PL_A_AddObject (imt_list, imt_cfg);
				// the bindings are not written here because they are managed
				// by IN_Binding_SaveConfig: IMT does not really know the
				// device-input structure (it cound via the blocks, but it
				// doesn't know the device names (by design))
			}
		}
		if (context->default_imt) {
			PL_D_AddObject (ctx, "default_imt",
							PL_NewString (context->default_imt->name));
		}
		if (context->switchers) {
			plitem_t   *switcher_list = PL_NewArray ();
			PL_D_AddObject (ctx, "switchers", switcher_list);
			for (imt_switcher_t *switcher = context->switchers; switcher;
				 switcher = switcher->next) {
				plitem_t   *switcher_cfg = PL_NewDictionary (0);
				PL_A_AddObject (switcher_list, switcher_cfg);

				PL_D_AddObject (switcher_cfg, "name",
								PL_NewString (switcher->name));

				plitem_t   *input_list = PL_NewArray ();
				PL_D_AddObject (switcher_cfg, "inputs", input_list);
				for (int i = 0; i < switcher->num_inputs; i++) {
					imt_input_t *input = &switcher->inputs[i];
					const char *name = 0;
					switch (input->type) {
						case imti_button:
							name = va (0, "+%s", input->button->name);
							break;
						case imti_cvar:
							name = input->cvar->name;
							break;
					}
					PL_A_AddObject (input_list, PL_NewString (name));
				}

				plitem_t   *state_list = PL_NewArray ();
				PL_D_AddObject (switcher_cfg, "imts", state_list);
				int         num_states = 1 << switcher->num_inputs;
				for (int i = 0; i < num_states; i++) {
					imt_t      *imt = switcher->imts[i];
					PL_A_AddObject (state_list, PL_NewString (imt->name));
				}
			}
		}
	}
}

void
IMT_SaveAxisConfig (plitem_t *axes, int axis_ind, int dev_axis)
{
	for (size_t i = 0; i < in_contexts.size; i++) {
		in_context_t *context = &in_contexts.a[i];
		for (imt_t *imt = context->imts; imt; imt = imt->next) {
			in_axisbinding_t *a = imt->axis_bindings.a[axis_ind];
			if (a) {
				in_recipe_t *recipe = a->recipe;
				plitem_t   *axis = PL_NewDictionary (0);
				PL_A_AddObject (axes, axis);

				PL_D_AddObject (axis, "imt", PL_NewString (imt->name));
				PL_D_AddObject (axis, "num",
								PL_NewString (va (0, "%d", dev_axis)));
				PL_D_AddObject (axis, "axis", PL_NewString (a->axis->name));
				PL_D_AddObject (axis, "min",
								PL_NewString (va (0, "%d", recipe->min)));
				PL_D_AddObject (axis, "max",
								PL_NewString (va (0, "%d", recipe->max)));
				PL_D_AddObject (axis, "minzone",
								PL_NewString (va (0, "%d", recipe->minzone)));
				PL_D_AddObject (axis, "maxzone",
								PL_NewString (va (0, "%d", recipe->maxzone)));
				PL_D_AddObject (axis, "deadzone",
								PL_NewString (va (0, "%d", recipe->deadzone)));
				PL_D_AddObject (axis, "curve",
								PL_NewString (va (0, "%.9g", recipe->curve)));
				PL_D_AddObject (axis, "scale",
								PL_NewString (va (0, "%.9g", recipe->scale)));
			}
		}
	}
}

void
IMT_SaveButtonConfig (plitem_t *buttons, int button_ind, int dev_button)
{
	for (size_t i = 0; i < in_contexts.size; i++) {
		in_context_t *context = &in_contexts.a[i];
		for (imt_t *imt = context->imts; imt; imt = imt->next) {
			in_buttonbinding_t *b = imt->button_bindings.a[button_ind];
			if (b) {
				plitem_t   *button = PL_NewDictionary (0);
				PL_A_AddObject (buttons, button);

				PL_D_AddObject (button, "imt", PL_NewString (imt->name));
				PL_D_AddObject (button, "num",
								PL_NewString (va (0, "%d", dev_button)));
				switch (b->type) {
					case inb_button:
						PL_D_AddObject (button, "binding",
										PL_NewString (va (0, "+%s",
														  b->button->name)));
						break;
					case inb_command:
						PL_D_AddObject (button, "binding",
										PL_NewString (b->command));
						break;
				}
			}
		}
	}
}

void
IMT_LoadConfig (plitem_t *config)
{
	imt_drop_all_f ();
	imt_reset_blocks ();

	plitem_t   *ctx_list = PL_ObjectForKey (config, "contexts");
	if (PL_Type (ctx_list) != QFArray) {
		Sys_Printf ("IMT_LoadConfig: contexts not an array\n");
		return;
	}
	for (int i = 0, count = PL_A_NumObjects (ctx_list); i < count; i++) {
		plitem_t   *ctx = PL_ObjectAtIndex (ctx_list, i);
		const char *name = PL_String (PL_ObjectForKey (ctx, "name"));
		in_context_t *context = imt_find_context (name);
		if (!context) {
			continue;
		}
		plitem_t   *imts = PL_ObjectForKey (ctx, "imts");
		if (!imts || PL_Type (imts) != QFArray) {
			continue;
		}
		for (int j = 0, num_imts = PL_A_NumObjects (imts); j < num_imts; j++) {
			plitem_t   *imt = PL_ObjectAtIndex (imts, j);
			const char *imt_name = PL_String (PL_ObjectForKey (imt, "name"));
			const char *imt_chain = PL_String (PL_ObjectForKey (imt, "chain"));
			if (imt_name) {
				IMT_CreateIMT (context - in_contexts.a, imt_name, imt_chain);
			}
		}
		const char *default_imt = PL_String (PL_ObjectForKey (ctx,
															  "default_imt"));
		if (default_imt) {
			context->default_imt = IMT_FindIMT (default_imt);
		}
		if (!context->default_imt) {
			context->default_imt = context->imts;
		}
		context->active_imt = context->default_imt;

		plitem_t   *switcher_list = PL_ObjectForKey (ctx, "switchers");
		if (!switcher_list || PL_Type (switcher_list) != QFArray) {
			continue;
		}
		for (int j = 0, num_switchers = PL_A_NumObjects (switcher_list);
			 j < num_switchers; j++) {
			plitem_t   *switcher = PL_ObjectAtIndex (switcher_list, j);
			const char *name = PL_String (PL_ObjectForKey (switcher, "name"));
			plitem_t   *input_list = PL_ObjectForKey (switcher, "inputs");
			if (!name || !input_list || PL_Type (input_list) != QFArray) {
				continue;
			}
			int         num_inputs = PL_A_NumObjects (input_list);
			const char **input_names = alloca (num_inputs * sizeof (char *));
			for (int k = 0; k < num_inputs; k++) {
				input_names[k] = PL_String (PL_ObjectAtIndex (input_list, k));
			}
			if (!IMT_CreateSwitcher (name, context - in_contexts.a,
									 context->default_imt,
									 num_inputs, input_names)) {
				continue;
			}
			imt_switcher_t *s = imt_find_switcher (context, name);

			plitem_t   *imt_list = PL_ObjectForKey (switcher, "imts");
			if (!imt_list || PL_Type (imt_list) != QFArray) {
				continue;
			}
			for (int k = 0, count = PL_A_NumObjects (imt_list); k < count;
				 k++) {
				const char *imt_name = PL_String(PL_ObjectAtIndex(imt_list, k));
				if (!imt_name) {
					continue;
				}
				imt_t      *imt = imt_find_imt (context, imt_name);
				if (imt) {
					s->imts[k] = imt;
				}
			}
		}
	}
}