input.c

/* Xep128: Minimalistic Enterprise-128 emulator with focus on "exotic" hardware
   Copyright (C)2015,2016 LGB (Gábor Lénárt) <lgblgblgb@gmail.com>
   http://xep128.lgb.hu/

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 the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */

#include "xep128.h"
#include "input.h"
#include "dave.h"
#include "keyboard_mapping.h"
#include "screen.h"
#include "joystick.h"

#include <SDL.h>


static int move_dx, move_dy, nibble_counter;
int mouse_grab = 0;
static int wheel_dx, wheel_dy;
static Uint8 nibble;
static int mouse_button1, mouse_button2;
static int rts_old_level = -1;
static int mouse_pulse = 0;
//static int _mouse_wait_warn = 1;
extern Uint32 raster_time; // we use Nick's raster_time "timing source" because it's kinda free without introducing another timer source
static Uint32 watchdog_mouse;		// watchdog value (raster_time related) used by the mouse nibble-reset protocol
static Uint32 watchdog_xep128;		// watchdog value (raster_time related) used by Xep128 to decide between joy-1 and j-column mouse

int show_keys = 0;
static int control_port_emu_mode = -1;

/* The mouse buffer. nibble_counter shows which nibble is to read (thus "nibble_counter >> 1" is the byte pointer actually.
   mouse_protocol_nibbles limits the max nibbles to read, ie it's 4 (= 2 bytes) for boxsoft protocol for the default setting */
static Uint8 mouse_buffer[] = {
	0x00,	// BOXSOFT: delta X as signed, positive-left, updated from mouse_dx
	0x00,	// BOXSOFT: delta Y as signed, positive-up, updates from mouse_dy
	0x10,	// EXTENDED MSX: proto ID + extra buttons on lower nibble (I update those - lower nibble - on mouse SDL events)
	0x00,	// EXTENDED MSX: horizontal wheel (it's splitted for horizontal/Z, but according to entermice it's handled as a 8 bit singed now for a single wheel, so I do this as well)
	0x44,	// ENTERMICE: extra bytes to read (incl this: 4 now) + PS/2 Mouse ID [it's 4 now ...]
	0x14,	// ENTERMICE: hardware version major.minor
	0x19,	// ENTERMICE: firmware version major.minor
	0x5D	// ENTERMICE: Device ID, should be 5D for Entermice
};

#define WATCHDOG_USEC(n) (n / 64)

/* Values can be used in mouse modes, buttons[] array to map PC mouse buttons to EP related mouse buttons 
   The first two are mapped then according to the button*_mask of the mode struct.
   The EX buttons instructs setting the button status in mouse buffer directly at byte 3, lower nibble
*/
#define BUTTON_MAIN	1
#define BUTTON_OTHER	2
#define BUTTON_EX3	3
#define BUTTON_EX4	4
#define BUTTON_EX5	5

/* Values can be used in *_mask options in mouse modes struct */
#define J_COLUMN	1
#define K_COLUMN	2

struct mouse_modes_st {
	const char *name;	// some name for the given mouse protocol/mode ...
	int buttons[5];		// button map: indexed by emulator given PC left/middle/right/x1/x2 (in this order), with values of the BUTTON_* macros above to map to protcol values
	int nibbles;		// nibbles in the protocol (before the constant zero answer or warping around if warp is non-zero)
	int wrap;		// wraps around nibble counter automatically or not (not = constant zero nibble answer, watchdog can only reset the counter)
	int watchdog;		// watchdog time-out, or -1, for not using watchdog, times are Xep128 specific use the WATCHDOG_USEC macro to convert from usec!
	int data_mask;		// bit mask for mouse data read (J/K/L = 1 / 2 / 4), you can use *_COLUMN macros
};

/* Definition of mouse modes follows :) */
static const struct mouse_modes_st mouse_modes[] = {
	{	// MODE - 0: NOT USED POSITION
	}, {	// MODE - 1:
		.name =		"BoxSoft J-col",
		.buttons =	{ BUTTON_MAIN, BUTTON_EX3, BUTTON_OTHER, BUTTON_EX4, BUTTON_EX5 },	// mapping for SDL left/middle/right/X1/X2 events to EP
		.nibbles =	4,
		.wrap =		0,
		.watchdog =	WATCHDOG_USEC(1500),
		.data_mask =	J_COLUMN
	}, {	// MODE - 2:
		.name =		"ExtMSX J-col",
		.buttons =	{ BUTTON_MAIN, BUTTON_EX3, BUTTON_OTHER, BUTTON_EX4, BUTTON_EX5 },	// mapping for SDL left/middle/right/X1/X2 events to EP
		.nibbles =	8,
		.wrap =		0,
		.watchdog =	WATCHDOG_USEC(1500),
		.data_mask =	J_COLUMN
	}, {	// MODE - 3:
		.name =		"EnterMice J-col",
		.buttons =	{ BUTTON_MAIN, BUTTON_EX3, BUTTON_OTHER, BUTTON_EX4, BUTTON_EX5 },	// mapping for SDL left/middle/right/X1/X2 events to EP
		.nibbles =	16,
		.wrap =		0,
		.watchdog =	WATCHDOG_USEC(1500),
		.data_mask =	J_COLUMN
	}, {	// MODE - 4:
		.name =		"BoxSoft K-col",
		.buttons =	{ BUTTON_MAIN, BUTTON_EX3, BUTTON_OTHER, BUTTON_EX4, BUTTON_EX5 },	// mapping for SDL left/middle/right/X1/X2 events to EP
		.nibbles =	4,
		.wrap =		0,
		.watchdog =	WATCHDOG_USEC(1500),
		.data_mask =	K_COLUMN
	}, {	// MODE - 5:
		.name =		"ExtMSX K-col",
		.buttons =	{ BUTTON_MAIN, BUTTON_EX3, BUTTON_OTHER, BUTTON_EX4, BUTTON_EX5 },	// mapping for SDL left/middle/right/X1/X2 events to EP
		.nibbles =	8,
		.wrap =		0,
		.watchdog =	WATCHDOG_USEC(1500),
		.data_mask =	K_COLUMN
	}, {	// MODE - 6:
		.name =		"EnterMice K-col",
		.buttons =	{ BUTTON_MAIN, BUTTON_EX3, BUTTON_OTHER, BUTTON_EX4, BUTTON_EX5 },	// mapping for SDL left/middle/right/X1/X2 events to EP
		.nibbles =	16,
		.wrap =		0,
		.watchdog =	WATCHDOG_USEC(1500),
		.data_mask =	K_COLUMN
	}
};

#define LAST_MOUSE_MODE ((sizeof(mouse_modes) / sizeof(const struct mouse_modes_st)) - 1)

static const struct mouse_modes_st *mode;	// current mode mode, pointer to the selected mouse_modes
int mouse_mode;					// current mode, with an integer

#define JOYSTICK_SCAN(num, dir) joystick_scan(num, dir)



int mouse_mode_description ( int cfg, char *buffer )
{
	if (cfg == 0)
		cfg = mouse_mode;
	if (cfg < 1 || cfg > LAST_MOUSE_MODE) {
		sprintf(buffer, "#%d *** Invalid mouse mode ***", cfg);
		return 1;
	} else {
		sprintf(
			buffer,
			"#%d (%s) nibbles=%d wrap=%d watchdog=%d mask=%d",
			cfg,
			mouse_modes[cfg].name,
			mouse_modes[cfg].nibbles,
			mouse_modes[cfg].wrap,
			mouse_modes[cfg].watchdog,
			mouse_modes[cfg].data_mask
		);
		return 0;
	}
}



void mouse_reset_button ( void )
{
	mouse_button1 = 0;
	mouse_button2 = 0;
	mouse_buffer[2] &= 0xF0;	// extra buttons for MSX extended protocol should be cleared as well
}



static inline void set_button ( Uint8 *storage, int mask, int pressed )
{
	if (pressed)
		*storage |= mask;
	else
		*storage &= 255 - mask;
}



void emu_mouse_button ( Uint8 sdl_button, int press )
{
	const char *name;
	int id;
	switch (sdl_button) {
		case SDL_BUTTON_LEFT:
			name = "left";
			id = 0;
			break;
		case SDL_BUTTON_MIDDLE:
			name = "middle";
			id = 1;
			break;
		case SDL_BUTTON_RIGHT:
			name = "right";
			id = 2;
			break;
		case SDL_BUTTON_X1:
			name = "x1";
			id = 3;
			break;
		case SDL_BUTTON_X2:
			name = "x2";
			id = 4;
			break;
		default:
			name = "UNKNOWN";
			id = -1;
			break;
	}
	DEBUG("MOUSE: BUTTON: event: SDL#%d XEP#%d (%s) %s" NL, sdl_button, id, name, press ? "pressed" : "released");
	if (id == -1) {
		DEBUG("MOUSE: BUTTON: unknown button on SDL level (see previous MOUSE: line)!!" NL);
		return;	// unknown mouse button??
	}
	if (sdl_button == SDL_BUTTON_LEFT && press && mouse_grab == 0) {
		//emu_osd_msg("Mouse grab. Press ESC to exit.");
		screen_grab(SDL_TRUE);
		mouse_grab = 1;
		mouse_reset_button();
	}
	if (!mouse_grab) {
		DEBUG("MOUSE: BUTTON: not in grab mode, do not forward event" NL);
		return; // not in mouse grab mode
	}
	switch (mode->buttons[id]) {
		case BUTTON_MAIN:
			mouse_button1 = press;
			break;
		case BUTTON_OTHER:
			mouse_button2 = press;
			break;
		case BUTTON_EX3:
			set_button(&mouse_buffer[2], 1, press);
			break;
		case BUTTON_EX4:
			set_button(&mouse_buffer[2], 2, press);
			break;
		case BUTTON_EX5:
			set_button(&mouse_buffer[2], 4, press);
			break;
		default:
			DEBUG("MOUSE: used mouse button cannot be mapped for the given mouse mode (map=%d), ignored" NL, mode->buttons[id]);
			break;
	}
}



void emu_mouse_motion ( int dx, int dy )
{
	DEBUG("MOUSE: MOTION: event: dx = %d, dy = %d" NL, dx, dy);
	if (!mouse_grab) {
		DEBUG("MOUSE: MOTION: not in grab mode, do not forward event" NL);
		return; // not in mouse grab mode
	}
	move_dx -= dx;
	if (move_dx > 127) move_dx = 127;
	else if (move_dx < -128) move_dx = -128;
	move_dy -= dy;
	if (move_dy > 127) move_dy = 127;
	else if (move_dy < -128) move_dy = -128;
}



void emu_mouse_wheel ( int x, int y, int flipped )
{
	DEBUG("MOUSE: WHEEL: event: x = %d, y = %d, flipped = %d" NL, x, y, flipped);
	if (!mouse_grab) {
		DEBUG("MOUSE: WHEEL: not in grab mode, do not forward event" NL);
		return; // not in mouse grab mode
	}
	flipped = flipped ? -1 : 1;
	wheel_dx -= x * flipped;
	if (wheel_dx > 127) wheel_dx = 127;
	else if (wheel_dx < -128) wheel_dx = -128;
	wheel_dy -= y * flipped;
	if (wheel_dy > 127) wheel_dy = 127;
	else if (wheel_dy < -128) wheel_dy = -128;
}



void mouse_reset ( void )
{
	// mouse_grab = 0; // commented out to fix the issue: emu reset hotkey is pressed with grabbed mouse ...
	nibble_counter = 0;
	//if (rts_old_level == -1)
	rts_old_level = 0;
	nibble = 0;
	move_dx = 0;
	move_dy = 0;
	wheel_dx = 0;
	wheel_dy = 0;
	watchdog_mouse = raster_time;
	watchdog_xep128 = raster_time;
	mouse_reset_button();
	mouse_buffer[0] = mouse_buffer[1] = mouse_buffer[3] = 0;
}



static inline void check_mouse_watchdog ( void )
{
	int time = raster_time - watchdog_mouse;
	watchdog_mouse = raster_time;
	if (mode->watchdog >= 0 && (time > mode->watchdog || time < 0))	// negative case in case of raster_time counter warp-around (integer overflow)
		nibble_counter = 0;	// in case of timeout, nibble counter resets to zero
}



// Called from cpu.c in case of read port 0xB6, this function MUST only give back bits 0-2, ie control ports ones, higher bits
// bits should be zero as they are used for other purposes (ie: tape, printer ...) and OR'ed by cpu.c at port reading func ...
Uint8 read_control_port_bits ( void )
{
	int mouse_ok, joy1_ok;
	int time = raster_time - watchdog_xep128;
	// Note: unlike watchdog_mouse, watchdog_xep128 is set in check data shift only but queried here
	if (time < 0)
		watchdog_xep128 = raster_time;	// integer overflow
	if (mode->data_mask == K_COLUMN) {		// mouse on K-column, joy-1 is always enabled
		mouse_ok = 2;
		joy1_ok = 1;
	} else if (mouse_pulse && (time < WATCHDOG_USEC(100000) || time < 0)) {	// mouse on J-column, joy-1 is disabled on mouse usage
		mouse_ok = 2;
		joy1_ok = 0;
	} else {					// mouse on J-column, joy-1 is enabled because no mouse usage
		mouse_ok = 0;
		joy1_ok = 1;
		mouse_pulse = 0;
	}
	if (control_port_emu_mode != mouse_ok + joy1_ok) {
		static const char *m[] = { "joystick", "Mouse", "dual (K-col)" };
		control_port_emu_mode = mouse_ok + joy1_ok;
		OSD("Control port: %s mode", m[control_port_emu_mode - 1 ]);
	}
	switch (kbd_selector) {
		/* joystick-1 or mouse related */
		case  0: // The Entermice wiki mentioned priority of mouse buttons are not so much implemented ... TODO
			return
				(mouse_ok ? ((mouse_button1 ? 0 : mode->data_mask) | (7 - mode->data_mask - 4) | (mouse_button2 ? 0 : 4)) : 7) &
				(joy1_ok ? ((JOYSTICK_SCAN(0, JOY_SCAN_FIRE1) ? 0 : 1) | (JOYSTICK_SCAN(0, JOY_SCAN_FIRE2) ? 0 : 2) | (JOYSTICK_SCAN(0, JOY_SCAN_FIRE3) ? 0 : 4)) : 7);
		case  1: return (mouse_ok ? (((nibble & 1) ? mode->data_mask : 0) | (7 - mode->data_mask)) : 7) & ((joy1_ok && JOYSTICK_SCAN(0, JOY_SCAN_UP   )) ? 6 : 7);
		case  2: return (mouse_ok ? (((nibble & 2) ? mode->data_mask : 0) | (7 - mode->data_mask)) : 7) & ((joy1_ok && JOYSTICK_SCAN(0, JOY_SCAN_DOWN )) ? 6 : 7);
		case  3: return (mouse_ok ? (((nibble & 4) ? mode->data_mask : 0) | (7 - mode->data_mask)) : 7) & ((joy1_ok && JOYSTICK_SCAN(0, JOY_SCAN_LEFT )) ? 6 : 7);
		case  4: return (mouse_ok ? (((nibble & 8) ? mode->data_mask : 0) | (7 - mode->data_mask)) : 7) & ((joy1_ok && JOYSTICK_SCAN(0, JOY_SCAN_RIGHT)) ? 6 : 7);
		/* always joystick#2 on J-column (bit 0), other bits are spare */
		case  5: return (JOYSTICK_SCAN(1, JOY_SCAN_FIRE1) ? 0 : 1) | (JOYSTICK_SCAN(1, JOY_SCAN_FIRE2) ? 0 : 2) | (JOYSTICK_SCAN(1, JOY_SCAN_FIRE3) ? 0 : 4);
		case  6: return  JOYSTICK_SCAN(1, JOY_SCAN_UP   ) ? 6 : 7;
		case  7: return  JOYSTICK_SCAN(1, JOY_SCAN_DOWN ) ? 6 : 7;
		case  8: return  JOYSTICK_SCAN(1, JOY_SCAN_LEFT ) ? 6 : 7;
		case  9: return  JOYSTICK_SCAN(1, JOY_SCAN_RIGHT) ? 6 : 7;
		/* and if not ... */
		default: return 7;	// it shouldn't happen too much (only if no valid scan row is selected?)
	}
}



// Called from cpu.c in case of write of port 0xB7
void mouse_check_data_shift ( Uint8 val )
{
	if ((val & 2) == rts_old_level)		// check of change on the RTS signal change
		return;	// if no change, we're not interested in at all, mouse "nibble shifting" in RTS _edge_ triggered (both of the edges!) not level
	rts_old_level = val & 2;
	mouse_pulse = 1;			// this variable is only for the emulator to keep track of mouse reading tries and display OSD, etc
	watchdog_xep128 = raster_time;		// this watchdog is used to control auto-switch of Xep128 between J-column mouse and joy-1 emulation
	check_mouse_watchdog();			// this is the mouse watchdog to reset nibble counter in a given timeout
	if (nibble_counter >= mode->nibbles && mode->wrap)	// support nibble counter wrap-around mode, if the current mouse mode directs that
		nibble_counter = 0;
	// note:  information larger than one nibble shouldn't updated by the mouse SDL events directly in mouse_buffer, because it's possible
	// that between the reading of two nibbles that is modified. To avoid this, these things are updated here at a well defined counter state only:
	if (nibble_counter == 0) {
		// update mouse buffer byte 0 with delta X
		//mouse_buffer[0] = ((unsigned int)move_dx) & 0xFF;    // signed will be converted to unsigned
		mouse_buffer[0] = move_dx;
		move_dx = 0;
	} else if (nibble_counter == 2) {
		// update mouse buffer byte 1 with delta Y
		//mouse_buffer[1] = ((unsigned int)move_dy) & 0xFF;    // signed will be converted to unsigned
		mouse_buffer[1] = move_dy;
		move_dy = 0;
	} else if (nibble_counter == 6) {	// this may not be used at all, if mouse_protocol_nibbles limits the available nibbles to read, boxsoft will not read this ever!
		mouse_buffer[3] = wheel_dy;
		wheel_dy = 0;
	}
	if (nibble_counter < mode->nibbles) {
		// if nibble counter is below the constraint of the used mouse protocol, provide the upper or lower nibble of the buffer
		// based on the counter's lowest bit (ie, odd or even)
		nibble = ((nibble_counter & 1) ? (mouse_buffer[nibble_counter >> 1] & 15) : (mouse_buffer[nibble_counter >> 1] >> 4));
		nibble_counter++;
	} else
		nibble = 0;	// if we hit the max number of nibbles, we constantly provide zero as the nibble, until watchdog resets
}



int mouse_setup ( int cfg )
{
	char buffer[128];
	if (cfg < 0)
		return mouse_mode;
	if (cfg < 1 || cfg > LAST_MOUSE_MODE)
		cfg = 1;
	mouse_mode = cfg;
	mode = &mouse_modes[cfg];
	mouse_mode_description(cfg, buffer);
	DEBUG("MOUSE: SETUP: %s" NL, buffer);
	mouse_reset();
	return cfg;
}


/* ------------------- KEYBOARD ----------------------- */


int emu_kbd(SDL_Keysym sym, int press)
{
	if (show_keys && press)
		OSD("SDL scancode is \"%s\" (%d)", SDL_GetScancodeName(sym.scancode), sym.scancode);
	if (mouse_grab && sym.scancode == SDL_SCANCODE_ESCAPE && press) {
		mouse_grab = 0;
		screen_grab(SDL_FALSE);
	} else {
		const struct keyMappingTable_st *ke = keymap_resolve_event(sym);
		if (ke) {
			int sel  = ke->posep >> 4;
			int mask = 1 << (ke->posep & 15);
			if (mask < 0x100) {
				if (press)
					kbd_matrix[sel] &= 255 - mask;
				else
					kbd_matrix[sel] |= mask;
			} else
				return ke->posep;	// give special code back to be handled by the caller!
		}
	}
	return 0;	// no kbd should be handled by the caller ...
}