Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-06-02 19:06:43 +03:00
Code Issues Actions 4 Packages Projects Releases Wiki Activity
cdd0600db4
mame/src/emu/ioport.h
Nathan Woods cdd0600db4 Added hot/cold attributes. Made the MAME executable 1% smaller by using the 
cold attribute on setup functions
2011-11-06 11:06:58 +00:00

1421 lines
45 KiB
C++
Raw Blame History

/***************************************************************************
ioport.h
Input/output port handling.
Copyright Nicola Salmoria and the MAME Team.
Visit http://mamedev.org for licensing and usage restrictions.
***************************************************************************/
#pragma once
#ifndef __EMU_H__
#error Dont include this file directly; include emu.h instead.
#endif
#ifndef __INPTPORT_H__
#define __INPTPORT_H__
#include <time.h>
/***************************************************************************
CONSTANTS
***************************************************************************/
#define MAX_PLAYERS 8
#define IP_ACTIVE_HIGH 0x00000000
#define IP_ACTIVE_LOW 0xffffffff
/* flags for input_field_configs */
#define FIELD_FLAG_UNUSED 0x01 /* set if this field is unused but relevant to other games on the same hw */
#define FIELD_FLAG_COCKTAIL 0x02 /* set if this field is relevant only for cocktail cabinets */
#define FIELD_FLAG_TOGGLE 0x04 /* set if this field should behave as a toggle */
#define FIELD_FLAG_ROTATED 0x08 /* set if this field represents a rotated control */
#define ANALOG_FLAG_REVERSE 0x10 /* analog only: reverse the sense of the axis */
#define ANALOG_FLAG_RESET 0x20 /* analog only: always preload in->default for relative axes, returning only deltas */
#define ANALOG_FLAG_WRAPS 0x40 /* analog only: positional count wraps around */
#define ANALOG_FLAG_INVERT 0x80 /* analog only: bitwise invert bits */
/* INP file information */
#define INP_HEADER_SIZE 64
#define INP_HEADER_MAJVERSION 3
#define INP_HEADER_MINVERSION 0
/* sequence types for input_port_seq() call */
enum _input_seq_type
{
SEQ_TYPE_STANDARD = 0,
SEQ_TYPE_INCREMENT,
SEQ_TYPE_DECREMENT,
SEQ_TYPE_TOTAL
};
typedef enum _input_seq_type input_seq_type;
DECLARE_ENUM_OPERATORS(input_seq_type)
/* conditions for DIP switches */
enum
{
PORTCOND_ALWAYS = 0,
PORTCOND_EQUALS,
PORTCOND_NOTEQUALS,
PORTCOND_GREATERTHAN,
PORTCOND_NOTGREATERTHAN,
PORTCOND_LESSTHAN,
PORTCOND_NOTLESSTHAN
};
/* crosshair types */
enum
{
CROSSHAIR_AXIS_NONE = 0,
CROSSHAIR_AXIS_X,
CROSSHAIR_AXIS_Y
};
/* groups for input ports */
enum ioport_group
{
IPG_UI = 0,
IPG_PLAYER1,
IPG_PLAYER2,
IPG_PLAYER3,
IPG_PLAYER4,
IPG_PLAYER5,
IPG_PLAYER6,
IPG_PLAYER7,
IPG_PLAYER8,
IPG_OTHER,
IPG_TOTAL_GROUPS,
IPG_INVALID
};
/* various input port types */
enum
{
/* pseudo-port types */
IPT_INVALID = 0,
IPT_UNUSED,
IPT_END,
IPT_UNKNOWN,
IPT_PORT,
IPT_DIPSWITCH,
IPT_VBLANK,
IPT_CONFIG,
/* start buttons */
IPT_START1,
IPT_START2,
IPT_START3,
IPT_START4,
IPT_START5,
IPT_START6,
IPT_START7,
IPT_START8,
/* coin slots */
IPT_COIN1,
IPT_COIN2,
IPT_COIN3,
IPT_COIN4,
IPT_COIN5,
IPT_COIN6,
IPT_COIN7,
IPT_COIN8,
IPT_COIN9,
IPT_COIN10,
IPT_COIN11,
IPT_COIN12,
IPT_BILL1,
/* service coin */
IPT_SERVICE1,
IPT_SERVICE2,
IPT_SERVICE3,
IPT_SERVICE4,
/* tilt inputs */
IPT_TILT1,
IPT_TILT2,
IPT_TILT3,
IPT_TILT4,
/* misc other digital inputs */
IPT_SERVICE,
IPT_TILT,
IPT_INTERLOCK,
IPT_VOLUME_UP,
IPT_VOLUME_DOWN,
IPT_START, /* MESS only */
IPT_SELECT, /* MESS only */
IPT_KEYPAD, /* MESS only */
IPT_KEYBOARD, /* MESS only */
#define __ipt_digital_joystick_start IPT_JOYSTICK_UP
/* use IPT_JOYSTICK for panels where the player has one single joystick */
IPT_JOYSTICK_UP,
IPT_JOYSTICK_DOWN,
IPT_JOYSTICK_LEFT,
IPT_JOYSTICK_RIGHT,
/* use IPT_JOYSTICKLEFT and IPT_JOYSTICKRIGHT for dual joystick panels */
IPT_JOYSTICKRIGHT_UP,
IPT_JOYSTICKRIGHT_DOWN,
IPT_JOYSTICKRIGHT_LEFT,
IPT_JOYSTICKRIGHT_RIGHT,
IPT_JOYSTICKLEFT_UP,
IPT_JOYSTICKLEFT_DOWN,
IPT_JOYSTICKLEFT_LEFT,
IPT_JOYSTICKLEFT_RIGHT,
#define __ipt_digital_joystick_end IPT_JOYSTICKLEFT_RIGHT
/* action buttons */
IPT_BUTTON1,
IPT_BUTTON2,
IPT_BUTTON3,
IPT_BUTTON4,
IPT_BUTTON5,
IPT_BUTTON6,
IPT_BUTTON7,
IPT_BUTTON8,
IPT_BUTTON9,
IPT_BUTTON10,
IPT_BUTTON11,
IPT_BUTTON12,
IPT_BUTTON13,
IPT_BUTTON14,
IPT_BUTTON15,
IPT_BUTTON16,
/* mahjong inputs */
#define __ipt_mahjong_start IPT_MAHJONG_A
IPT_MAHJONG_A,
IPT_MAHJONG_B,
IPT_MAHJONG_C,
IPT_MAHJONG_D,
IPT_MAHJONG_E,
IPT_MAHJONG_F,
IPT_MAHJONG_G,
IPT_MAHJONG_H,
IPT_MAHJONG_I,
IPT_MAHJONG_J,
IPT_MAHJONG_K,
IPT_MAHJONG_L,
IPT_MAHJONG_M,
IPT_MAHJONG_N,
IPT_MAHJONG_O,
IPT_MAHJONG_P,
IPT_MAHJONG_Q,
IPT_MAHJONG_KAN,
IPT_MAHJONG_PON,
IPT_MAHJONG_CHI,
IPT_MAHJONG_REACH, //IPT_MAHJONG_RIICHI, // REACH is Japanglish
IPT_MAHJONG_RON,
IPT_MAHJONG_BET,
IPT_MAHJONG_LAST_CHANCE,
IPT_MAHJONG_SCORE,
IPT_MAHJONG_DOUBLE_UP,
IPT_MAHJONG_FLIP_FLOP,
IPT_MAHJONG_BIG,
IPT_MAHJONG_SMALL,
#define __ipt_mahjong_end IPT_MAHJONG_SMALL
/* hanafuda inputs */
#define __ipt_hanafuda_start IPT_HANAFUDA_A
IPT_HANAFUDA_A,
IPT_HANAFUDA_B,
IPT_HANAFUDA_C,
IPT_HANAFUDA_D,
IPT_HANAFUDA_E,
IPT_HANAFUDA_F,
IPT_HANAFUDA_G,
IPT_HANAFUDA_H,
IPT_HANAFUDA_YES,
IPT_HANAFUDA_NO,
#define __ipt_hanafuda_end IPT_HANAFUDA_NO
#define __ipt_gambling_start IPT_GAMBLE_KEYIN
/* gambling inputs */
IPT_GAMBLE_KEYIN, // attendant
IPT_GAMBLE_KEYOUT, // attendant
IPT_GAMBLE_SERVICE, // attendant
IPT_GAMBLE_BOOK, // attendant
IPT_GAMBLE_DOOR, // attendant
// IPT_GAMBLE_DOOR2, // many gambling games have several doors.
// IPT_GAMBLE_DOOR3,
// IPT_GAMBLE_DOOR4,
// IPT_GAMBLE_DOOR5,
IPT_GAMBLE_HIGH, // player
IPT_GAMBLE_LOW, // player
IPT_GAMBLE_HALF, // player
IPT_GAMBLE_DEAL, // player
IPT_GAMBLE_D_UP, // player
IPT_GAMBLE_TAKE, // player
IPT_GAMBLE_STAND, // player
IPT_GAMBLE_BET, // player
IPT_GAMBLE_PAYOUT, // player
// IPT_GAMBLE_BUTTON1, // player
// IPT_GAMBLE_BUTTON2, // many many gambling games have multi-games and/or multi-function-buttons
// IPT_GAMBLE_BUTTON3, // I suggest to eliminate specific names
// IPT_GAMBLE_BUTTON4,
// IPT_GAMBLE_BUTTON5,
// IPT_GAMBLE_BUTTON6,
// IPT_GAMBLE_BUTTON7,
// IPT_GAMBLE_BUTTON8,
// IPT_GAMBLE_BUTTON9,
// IPT_GAMBLE_BUTTON10,
// IPT_GAMBLE_BUTTON11,
// IPT_GAMBLE_BUTTON12,
// IPT_GAMBLE_BUTTON13,
// IPT_GAMBLE_BUTTON14,
// IPT_GAMBLE_BUTTON15,
// IPT_GAMBLE_BUTTON16,
/* poker-specific inputs */
IPT_POKER_HOLD1,
IPT_POKER_HOLD2,
IPT_POKER_HOLD3,
IPT_POKER_HOLD4,
IPT_POKER_HOLD5,
IPT_POKER_CANCEL,
IPT_POKER_BET,
/* slot-specific inputs */
IPT_SLOT_STOP1,
IPT_SLOT_STOP2,
IPT_SLOT_STOP3,
IPT_SLOT_STOP4,
IPT_SLOT_STOP_ALL,
#define __ipt_gambling_end IPT_SLOT_STOP_ALL
/* analog inputs */
#define __ipt_analog_start IPT_AD_STICK_X
#define __ipt_analog_absolute_start IPT_AD_STICK_X
IPT_AD_STICK_X, // absolute // autocenter
IPT_AD_STICK_Y, // absolute // autocenter
IPT_AD_STICK_Z, // absolute // autocenter
IPT_PADDLE, // absolute // autocenter
IPT_PADDLE_V, // absolute // autocenter
IPT_PEDAL, // absolute // autocenter
IPT_PEDAL2, // absolute // autocenter
IPT_PEDAL3, // absolute // autocenter
IPT_LIGHTGUN_X, // absolute
IPT_LIGHTGUN_Y, // absolute
IPT_POSITIONAL, // absolute // autocenter if not wraps
IPT_POSITIONAL_V, // absolute // autocenter if not wraps
#define __ipt_analog_absolute_end IPT_POSITIONAL_V
IPT_DIAL, // relative
IPT_DIAL_V, // relative
IPT_TRACKBALL_X, // relative
IPT_TRACKBALL_Y, // relative
IPT_MOUSE_X, // relative
IPT_MOUSE_Y, // relative
#define __ipt_analog_end IPT_MOUSE_Y
/* analog adjuster support */
IPT_ADJUSTER,
/* the following are special codes for user interface handling - not to be used by drivers! */
#define __ipt_ui_start IPT_UI_CONFIGURE
IPT_UI_CONFIGURE,
IPT_UI_ON_SCREEN_DISPLAY,
IPT_UI_DEBUG_BREAK,
IPT_UI_PAUSE,
IPT_UI_RESET_MACHINE,
IPT_UI_SOFT_RESET,
IPT_UI_SHOW_GFX,
IPT_UI_FRAMESKIP_DEC,
IPT_UI_FRAMESKIP_INC,
IPT_UI_THROTTLE,
IPT_UI_FAST_FORWARD,
IPT_UI_SHOW_FPS,
IPT_UI_SNAPSHOT,
IPT_UI_RECORD_MOVIE,
IPT_UI_TOGGLE_CHEAT,
IPT_UI_UP,
IPT_UI_DOWN,
IPT_UI_LEFT,
IPT_UI_RIGHT,
IPT_UI_HOME,
IPT_UI_END,
IPT_UI_PAGE_UP,
IPT_UI_PAGE_DOWN,
IPT_UI_SELECT,
IPT_UI_CANCEL,
IPT_UI_DISPLAY_COMMENT,
IPT_UI_CLEAR,
IPT_UI_ZOOM_IN,
IPT_UI_ZOOM_OUT,
IPT_UI_PREV_GROUP,
IPT_UI_NEXT_GROUP,
IPT_UI_ROTATE,
IPT_UI_SHOW_PROFILER,
IPT_UI_TOGGLE_UI,
IPT_UI_TOGGLE_DEBUG,
IPT_UI_PASTE,
IPT_UI_SAVE_STATE,
IPT_UI_LOAD_STATE,
/* additional OSD-specified UI port types (up to 16) */
IPT_OSD_1,
IPT_OSD_2,
IPT_OSD_3,
IPT_OSD_4,
IPT_OSD_5,
IPT_OSD_6,
IPT_OSD_7,
IPT_OSD_8,
IPT_OSD_9,
IPT_OSD_10,
IPT_OSD_11,
IPT_OSD_12,
IPT_OSD_13,
IPT_OSD_14,
IPT_OSD_15,
IPT_OSD_16,
#define __ipt_ui_end IPT_OSD_16
/* other meaning not mapped to standard defaults */
IPT_OTHER,
/* special meaning handled by custom code */
IPT_SPECIAL,
IPT_OUTPUT,
__ipt_max
};
/* default strings used in port definitions */
enum
{
INPUT_STRING_Off = 1,
INPUT_STRING_On,
INPUT_STRING_No,
INPUT_STRING_Yes,
INPUT_STRING_Lives,
INPUT_STRING_Bonus_Life,
INPUT_STRING_Difficulty,
INPUT_STRING_Demo_Sounds,
INPUT_STRING_Coinage,
INPUT_STRING_Coin_A,
INPUT_STRING_Coin_B,
// INPUT_STRING_20C_1C, // 0.050000
// INPUT_STRING_15C_1C, // 0.066667
// INPUT_STRING_10C_1C, // 0.100000
#define __input_string_coinage_start INPUT_STRING_9C_1C
INPUT_STRING_9C_1C, // 0.111111
INPUT_STRING_8C_1C, // 0.125000
INPUT_STRING_7C_1C, // 0.142857
INPUT_STRING_6C_1C, // 0.166667
// INPUT_STRING_10C_2C, // 0.200000
INPUT_STRING_5C_1C, // 0.200000
// INPUT_STRING_9C_2C, // 0.222222
// INPUT_STRING_8C_2C, // 0.250000
INPUT_STRING_4C_1C, // 0.250000
// INPUT_STRING_7C_2C, // 0.285714
// INPUT_STRING_10C_3C, // 0.300000
// INPUT_STRING_9C_3C, // 0.333333
// INPUT_STRING_6C_2C, // 0.333333
INPUT_STRING_3C_1C, // 0.333333
INPUT_STRING_8C_3C, // 0.375000
// INPUT_STRING_10C_4C, // 0.400000
// INPUT_STRING_5C_2C, // 0.400000
// INPUT_STRING_7C_3C, // 0.428571
// INPUT_STRING_9C_4C, // 0.444444
// INPUT_STRING_10C_5C, // 0.500000
// INPUT_STRING_8C_4C, // 0.500000
// INPUT_STRING_6C_3C, // 0.500000
INPUT_STRING_4C_2C, // 0.500000
INPUT_STRING_2C_1C, // 0.500000
// INPUT_STRING_9C_5C, // 0.555556
// INPUT_STRING_7C_4C, // 0.571429
// INPUT_STRING_10C_6C, // 0.600000
INPUT_STRING_5C_3C, // 0.600000
// INPUT_STRING_8C_5C, // 0.625000
// INPUT_STRING_9C_6C, // 0.666667
// INPUT_STRING_6C_4C, // 0.666667
INPUT_STRING_3C_2C, // 0.666667
// INPUT_STRING_10C_7C, // 0.700000
// INPUT_STRING_7C_5C, // 0.714286
// INPUT_STRING_8C_6C, // 0.750000
INPUT_STRING_4C_3C, // 0.750000
// INPUT_STRING_9C_7C, // 0.777778
// INPUT_STRING_10C_8C, // 0.800000
// INPUT_STRING_5C_4C, // 0.800000
// INPUT_STRING_6C_5C, // 0.833333
// INPUT_STRING_7C_6C, // 0.857143
// INPUT_STRING_8C_7C, // 0.875000
// INPUT_STRING_9C_8C, // 0.888889
// INPUT_STRING_10C_9C, // 0.900000
// INPUT_STRING_10C_10C, // 1.000000
// INPUT_STRING_9C_9C, // 1.000000
// INPUT_STRING_8C_8C, // 1.000000
// INPUT_STRING_7C_7C, // 1.000000
// INPUT_STRING_6C_6C, // 1.000000
// INPUT_STRING_5C_5C, // 1.000000
INPUT_STRING_4C_4C, // 1.000000
INPUT_STRING_3C_3C, // 1.000000
INPUT_STRING_2C_2C, // 1.000000
INPUT_STRING_1C_1C, // 1.000000
// INPUT_STRING_9C_10C, // 1.111111
// INPUT_STRING_8C_9C, // 1.125000
// INPUT_STRING_7C_8C, // 1.142857
// INPUT_STRING_6C_7C, // 1.166667
// INPUT_STRING_5C_6C, // 1.200000
// INPUT_STRING_8C_10C, // 1.250000
INPUT_STRING_4C_5C, // 1.250000
// INPUT_STRING_7C_9C, // 1.285714
// INPUT_STRING_6C_8C, // 1.333333
INPUT_STRING_3C_4C, // 1.333333
// INPUT_STRING_5C_7C, // 1.400000
// INPUT_STRING_7C_10C, // 1.428571
// INPUT_STRING_6C_9C, // 1.500000
// INPUT_STRING_4C_6C, // 1.500000
INPUT_STRING_2C_3C, // 1.500000
// INPUT_STRING_5C_8C, // 1.600000
// INPUT_STRING_6C_10C, // 1.666667
// INPUT_STRING_3C_5C, // 1.666667
INPUT_STRING_4C_7C, // 1.750000
// INPUT_STRING_5C_9C, // 1.800000
// INPUT_STRING_5C_10C, // 2.000000
// INPUT_STRING_4C_8C, // 2.000000
// INPUT_STRING_3C_6C, // 2.000000
INPUT_STRING_2C_4C, // 2.000000
INPUT_STRING_1C_2C, // 2.000000
// INPUT_STRING_4C_9C, // 2.250000
// INPUT_STRING_3C_7C, // 2.333333
// INPUT_STRING_4C_10C, // 2.500000
INPUT_STRING_2C_5C, // 2.500000
// INPUT_STRING_3C_8C, // 2.666667
// INPUT_STRING_3C_9C, // 3.000000
INPUT_STRING_2C_6C, // 3.000000
INPUT_STRING_1C_3C, // 3.000000
// INPUT_STRING_3C_10C, // 3.333333
INPUT_STRING_2C_7C, // 3.500000
INPUT_STRING_2C_8C, // 4.000000
INPUT_STRING_1C_4C, // 4.000000
// INPUT_STRING_2C_9C, // 4.500000
// INPUT_STRING_2C_10C, // 5.000000
INPUT_STRING_1C_5C, // 5.000000
INPUT_STRING_1C_6C, // 6.000000
INPUT_STRING_1C_7C, // 7.000000
INPUT_STRING_1C_8C, // 8.000000
INPUT_STRING_1C_9C, // 9.000000
#define __input_string_coinage_end INPUT_STRING_1C_9C
// INPUT_STRING_1C_10C, // 10.000000
// INPUT_STRING_1C_11C, // 11.000000
// INPUT_STRING_1C_12C, // 12.000000
// INPUT_STRING_1C_13C, // 13.000000
// INPUT_STRING_1C_14C, // 14.000000
// INPUT_STRING_1C_15C, // 15.000000
// INPUT_STRING_1C_20C, // 20.000000
// INPUT_STRING_1C_25C, // 25.000000
// INPUT_STRING_1C_30C, // 30.000000
// INPUT_STRING_1C_40C, // 40.000000
// INPUT_STRING_1C_50C, // 50.000000
// INPUT_STRING_1C_99C, // 99.000000
// INPUT_STRING_1C_100C, // 100.000000
// INPUT_STRING_1C_120C, // 120.000000
// INPUT_STRING_1C_125C, // 125.000000
// INPUT_STRING_1C_150C, // 150.000000
// INPUT_STRING_1C_200C, // 200.000000
// INPUT_STRING_1C_250C, // 250.000000
// INPUT_STRING_1C_500C, // 500.000000
// INPUT_STRING_1C_1000C, // 1000.000000
INPUT_STRING_Free_Play,
INPUT_STRING_Cabinet,
INPUT_STRING_Upright,
INPUT_STRING_Cocktail,
INPUT_STRING_Flip_Screen,
INPUT_STRING_Service_Mode,
INPUT_STRING_Pause,
INPUT_STRING_Test,
INPUT_STRING_Tilt,
INPUT_STRING_Version,
INPUT_STRING_Region,
INPUT_STRING_International,
INPUT_STRING_Japan,
INPUT_STRING_USA,
INPUT_STRING_Europe,
INPUT_STRING_Asia,
INPUT_STRING_China,
INPUT_STRING_Hong_Kong,
INPUT_STRING_Korea,
INPUT_STRING_Southeast_Asia,
INPUT_STRING_Taiwan,
INPUT_STRING_World,
INPUT_STRING_Language,
INPUT_STRING_English,
INPUT_STRING_Japanese,
INPUT_STRING_Chinese,
INPUT_STRING_French,
INPUT_STRING_German,
INPUT_STRING_Italian,
INPUT_STRING_Korean,
INPUT_STRING_Spanish,
INPUT_STRING_Very_Easy,
INPUT_STRING_Easiest,
INPUT_STRING_Easier,
INPUT_STRING_Easy,
INPUT_STRING_Medium_Easy,
INPUT_STRING_Normal,
INPUT_STRING_Medium,
INPUT_STRING_Medium_Hard,
INPUT_STRING_Hard,
INPUT_STRING_Harder,
INPUT_STRING_Hardest,
INPUT_STRING_Very_Hard,
INPUT_STRING_Medium_Difficult,
INPUT_STRING_Difficult,
INPUT_STRING_Very_Difficult,
INPUT_STRING_Very_Low,
INPUT_STRING_Low,
INPUT_STRING_High,
INPUT_STRING_Higher,
INPUT_STRING_Highest,
INPUT_STRING_Very_High,
INPUT_STRING_Players,
INPUT_STRING_Controls,
INPUT_STRING_Dual,
INPUT_STRING_Single,
INPUT_STRING_Game_Time,
INPUT_STRING_Continue_Price,
INPUT_STRING_Controller,
INPUT_STRING_Light_Gun,
INPUT_STRING_Joystick,
INPUT_STRING_Trackball,
INPUT_STRING_Continues,
INPUT_STRING_Allow_Continue,
INPUT_STRING_Level_Select,
// INPUT_STRING_Allow,
// INPUT_STRING_Forbid,
// INPUT_STRING_Enable,
// INPUT_STRING_Disable,
INPUT_STRING_Infinite,
// INPUT_STRING_Invincibility,
// INPUT_STRING_Invulnerability,
INPUT_STRING_Stereo,
INPUT_STRING_Mono,
INPUT_STRING_Unused,
INPUT_STRING_Unknown,
// INPUT_STRING_Undefined,
INPUT_STRING_Standard,
INPUT_STRING_Reverse,
INPUT_STRING_Alternate,
// INPUT_STRING_Reserve,
// INPUT_STRING_Spare,
// INPUT_STRING_Invalid,
INPUT_STRING_None,
INPUT_STRING_COUNT
};
/* input classes */
enum
{
INPUT_CLASS_INTERNAL,
INPUT_CLASS_KEYBOARD,
INPUT_CLASS_CONTROLLER,
INPUT_CLASS_CONFIG,
INPUT_CLASS_DIPSWITCH,
INPUT_CLASS_MISC
};
#define UCHAR_PRIVATE (0x100000)
#define UCHAR_SHIFT_1 (UCHAR_PRIVATE + 0)
#define UCHAR_SHIFT_2 (UCHAR_PRIVATE + 1)
#define UCHAR_MAMEKEY_BEGIN (UCHAR_PRIVATE + 2)
#define UCHAR_MAMEKEY(code) (UCHAR_MAMEKEY_BEGIN + ITEM_ID_##code)
#define UCHAR_SHIFT_BEGIN (UCHAR_SHIFT_1)
#define UCHAR_SHIFT_END (UCHAR_SHIFT_2)
/***************************************************************************
TYPE DEFINITIONS
***************************************************************************/
/* input ports support up to 32 bits each */
typedef UINT32 input_port_value;
/* opaque types pointing to live state */
typedef struct _input_port_state input_port_state;
typedef struct _input_field_state input_field_state;
/* forward declarations */
class input_port_config;
class input_field_config;
/* template specializations */
typedef tagged_list<input_port_config> ioport_list;
/* read input port callback function */
typedef delegate<UINT32 (const input_field_config &, void *)> input_field_read_delegate;
/* input port write callback function */
typedef delegate<void (const input_field_config &, void *, input_port_value, input_port_value)> input_field_write_delegate;
/* crosshair mapping function */
typedef delegate<float (const input_field_config &, float)> input_field_crossmap_delegate;
/* encapsulates a condition on a port field or setting */
typedef struct _input_condition input_condition;
struct _input_condition
{
const char * tag; /* tag of port whose condition is to be tested */
input_port_value mask; /* mask to apply to the port */
input_port_value value; /* value to compare against */
UINT8 condition; /* condition to use */
};
/* a single setting for a configuration or DIP switch */
class input_setting_config
{
DISABLE_COPYING(input_setting_config);
friend class simple_list<input_setting_config>;
public:
input_setting_config(input_field_config &field, input_port_value value, const char *name);
input_setting_config *next() const { return m_next; }
input_port_value value; /* value of the bits in this setting */
input_condition condition; /* condition under which this setting is valid */
const char * name; /* user-friendly name to display */
private:
input_field_config & m_field; /* pointer back to the field that owns us */
input_setting_config * m_next; /* pointer to next setting in sequence */
};
/* a mapping from a bit to a physical DIP switch description */
class input_field_diplocation
{
DISABLE_COPYING(input_field_diplocation);
friend class simple_list<input_field_diplocation>;
public:
input_field_diplocation(const char *string, UINT8 swnum, bool invert);
input_field_diplocation *next() const { return m_next; }
astring swname; /* name of the physical DIP switch */
UINT8 swnum; /* physical switch number */
bool invert; /* is this an active-high DIP? */
private:
input_field_diplocation * m_next; /* pointer to the next bit */
};
/* a single bitfield within an input port */
class input_field_config
{
DISABLE_COPYING(input_field_config);
friend class simple_list<input_field_config>;
public:
input_field_config(input_port_config &port, int type, input_port_value defvalue, input_port_value maskbits, const char *name = NULL);
input_field_config *next() const { return m_next; }
input_port_config &port() const { return m_port; }
running_machine &machine() const;
simple_list<input_setting_config> &settinglist() { return m_settinglist; }
const simple_list<input_setting_config> &settinglist() const { return m_settinglist; }
simple_list<input_field_diplocation> &diploclist() { return m_diploclist; }
int modcount() const { return m_modcount; }
/* generally-applicable data */
input_port_value mask; /* mask of bits belonging to the field */
input_port_value defvalue; /* default value of these bits */
input_condition condition; /* condition under which this field is relevant */
UINT32 type; /* IPT_* type for this port */
UINT8 player; /* player number (0-based) */
UINT32 flags; /* combination of FIELD_FLAG_* and ANALOG_FLAG_* above */
UINT8 impulse; /* number of frames before reverting to defvalue */
const char * name; /* user-friendly name to display */
input_seq seq[SEQ_TYPE_TOTAL];/* sequences of all types */
input_field_read_delegate read; /* read callback routine */
void * read_param; /* parameter for read callback routine */
const char * read_device; /* parameter for read callback routine */
input_field_write_delegate write; /* write callback routine */
void * write_param; /* parameter for write callback routine */
const char * write_device; /* parameter for write callback routine */
/* data relevant to analog control types */
INT32 min; /* minimum value for absolute axes */
INT32 max; /* maximum value for absolute axes */
INT32 sensitivity; /* sensitivity (100=normal) */
INT32 delta; /* delta to apply each frame a digital inc/dec key is pressed */
INT32 centerdelta; /* delta to apply each frame no digital inputs are pressed */
UINT8 crossaxis; /* crosshair axis */
double crossscale; /* crosshair scale */
double crossoffset; /* crosshair offset */
double crossaltaxis; /* crosshair alternate axis value */
input_field_crossmap_delegate crossmapper; /* crosshair mapping function */
const char * crossmapper_device; /* parameter for write callback routine */
UINT16 full_turn_count;/* number of optical counts for 1 full turn of the original control */
const input_port_value * remap_table; /* pointer to an array that remaps the port value */
/* data relevant to other specific types */
UINT8 way; /* digital joystick 2/4/8-way descriptions */
unicode_char chars[3]; /* (MESS-specific) unicode key data */
/* this field is only valid if the device is live */
input_field_state * state; /* live state of field (NULL if not live) */
private:
input_field_config * m_next; /* pointer to next field in sequence */
input_port_config & m_port; /* pointer back to the port that owns us */
int m_modcount;
simple_list<input_setting_config> m_settinglist; /* list of input_setting_configs */
simple_list<input_field_diplocation> m_diploclist; /* list of locations for various bits */
};
/* user-controllable settings for a field */
typedef struct _input_field_user_settings input_field_user_settings;
struct _input_field_user_settings
{
input_port_value value; /* for DIP switches */
input_seq seq[SEQ_TYPE_TOTAL];/* sequences of all types */
INT32 sensitivity; /* for analog controls */
INT32 delta; /* for analog controls */
INT32 centerdelta; /* for analog controls */
UINT8 reverse; /* for analog controls */
};
/* device defined default input settings */
typedef struct _input_device_default input_device_default;
struct _input_device_default
{
const char * tag; /* tag of port to update */
input_port_value mask; /* mask to apply to the port */
input_port_value defvalue; /* new default value */
};
/* a single input port configuration */
class input_port_config
{
DISABLE_COPYING(input_port_config);
friend class simple_list<input_port_config>;
public:
// construction/destruction
input_port_config(device_t &owner, const char *tag);
// getters
input_port_config *next() const { return m_next; }
device_t &owner() const { return m_owner; }
running_machine &machine() const;
input_field_config *first_field() const { return m_fieldlist.first(); }
simple_list<input_field_config> &fieldlist() { return m_fieldlist; }
const char *tag() const { return m_tag; }
int modcount() const { return m_modcount; }
void bump_modcount() { m_modcount++; }
void collapse_fields(astring &errorbuf);
/* these fields are only valid if the port is live */
input_port_state * state; /* live state of port (NULL if not live) */
input_port_value active; /* mask of active bits in the port */
private:
input_port_config * m_next; /* pointer to next port */
device_t & m_owner; /* associated device, when appropriate */
simple_list<input_field_config> m_fieldlist; /* list of input_field_configs */
astring m_tag; /* pointer to this port's tag */
int m_modcount;
};
/* describes a fundamental input type, including default input sequences */
class input_type_entry
{
friend class simple_list<input_type_entry>;
public:
input_type_entry(UINT32 type, ioport_group group, int player, const char *token, const char *name, input_seq standard);
input_type_entry(UINT32 type, ioport_group group, int player, const char *token, const char *name, input_seq standard, input_seq decrement, input_seq increment);
input_type_entry *next() const { return m_next; }
UINT32 type; /* IPT_* for this entry */
ioport_group group; /* which group the port belongs to */
UINT8 player; /* player number (0 is player 1) */
const char * token; /* token used to store settings */
const char * name; /* user-friendly name */
input_seq defseq[SEQ_TYPE_TOTAL];/* default input sequence */
input_seq seq[SEQ_TYPE_TOTAL];/* currently configured sequences */
private:
input_type_entry * m_next; /* next description in the list */
};
/* header at the front of INP files */
typedef struct _inp_header inp_header;
struct _inp_header
{
char header[8]; /* +00: 8 byte header - must be "MAMEINP\0" */
UINT64 basetime; /* +08: base time of recording */
UINT8 majversion; /* +10: major INP version */
UINT8 minversion; /* +11: minor INP version */
UINT8 reserved[2]; /* +12: must be zero */
char gamename[12]; /* +14: game name string, NULL-terminated */
char version[32]; /* +20: system version string, NULL-terminated */
};
/***************************************************************************
MACROS
***************************************************************************/
/* macro for a read callback function (PORT_CUSTOM) */
#define CUSTOM_INPUT(name) input_port_value name(device_t &device, const input_field_config &field, void *param)
#define CUSTOM_INPUT_MEMBER(name) input_port_value name(const input_field_config &field, void *param)
#define DECLARE_CUSTOM_INPUT_MEMBER(name) input_port_value name(const input_field_config &field, void *param)
/* macro for port write callback functions (PORT_CHANGED) */
#define INPUT_CHANGED(name) void name(device_t &device, const input_field_config &field, void *param, input_port_value oldval, input_port_value newval)
#define INPUT_CHANGED_MEMBER(name) void name(const input_field_config &field, void *param, input_port_value oldval, input_port_value newval)
#define DECLARE_INPUT_CHANGED_MEMBER(name) void name(const input_field_config &field, void *param, input_port_value oldval, input_port_value newval)
/* macro for port changed callback functions (PORT_CROSSHAIR_MAPPER) */
#define CROSSHAIR_MAPPER(name) float name(device_t &device, const input_field_config &field, float linear_value)
#define CROSSHAIR_MAPPER_MEMBER(name) float name(const input_field_config &field, float linear_value)
#define DECLARE_CROSSHAIR_MAPPER_MEMBER(name) float name(const input_field_config &field, float linear_value)
/* macro for wrapping a default string */
#define DEF_STR(str_num) ((const char *)INPUT_STRING_##str_num)
template<int (*_FunctionPointer)(device_t *)>
input_port_value ioport_read_line_wrapper(device_t &device, const input_field_config &field, void *param)
{
return (*_FunctionPointer)(&device);
}
template<class _FunctionClass, int (_FunctionClass::*_FunctionPointer)()>
input_port_value ioport_read_line_wrapper(_FunctionClass &device, const input_field_config &field, void *param)
{
return (device.*_FunctionPointer)();
}
template<void (*_FunctionPointer)(device_t *, int)>
void ioport_write_line_wrapper(device_t &device, const input_field_config &field, void *param, input_port_value oldval, input_port_value newval)
{
return (*_FunctionPointer)(&device, newval);
}
template<class _FunctionClass, void (_FunctionClass::*_FunctionPointer)(int)>
void ioport_write_line_wrapper(_FunctionClass &device, const input_field_config &field, void *param, input_port_value oldval, input_port_value newval)
{
return (device.*_FunctionPointer)(newval);
}
/***************************************************************************
MACROS FOR BUILDING INPUT PORTS
***************************************************************************/
typedef void (*ioport_constructor)(device_t &owner, ioport_list &portlist, astring &errorbuf);
/* so that "0" can be used for unneeded input ports */
#define construct_ioport_0 NULL
/* name of table */
#define INPUT_PORTS_NAME(_name) construct_ioport_##_name
/* start of table */
#define INPUT_PORTS_START(_name) \
ATTR_COLD void INPUT_PORTS_NAME(_name)(device_t &owner, ioport_list &portlist, astring &errorbuf) \
{ \
astring fulltag; \
input_setting_config *cursetting = NULL; \
input_field_config *curfield = NULL; \
input_port_config *curport = NULL; \
input_port_value maskbits = 0; \
(void)cursetting; (void)curfield; (void)curport; (void)maskbits; \
/* end of table */
#define INPUT_PORTS_END \
}
/* aliasing */
#define INPUT_PORTS_EXTERN(_name) \
extern void INPUT_PORTS_NAME(_name)(device_t &owner, ioport_list &portlist, astring &errorbuf)
/* including */
#define PORT_INCLUDE(_name) \
INPUT_PORTS_NAME(_name)(owner, portlist, errorbuf); \
/* start of a new input port (with included tag) */
#define PORT_START(_tag) \
curport = ioconfig_alloc_port(portlist, owner, _tag); \
curfield = NULL; \
cursetting = NULL; \
maskbits = 0; \
/* modify an existing port */
#define PORT_MODIFY(_tag) \
curport = ioconfig_modify_port(portlist, owner, _tag); \
curfield = NULL; \
cursetting = NULL; \
maskbits = 0; \
/* input bit definition */
#define PORT_BIT(_mask, _default, _type) \
curfield = ioconfig_alloc_field(*curport, (_type), (_default), (_mask)); \
cursetting = NULL;
#define PORT_SPECIAL_ONOFF(_mask, _default, _strindex) PORT_SPECIAL_ONOFF_DIPLOC(_mask, _default, _strindex, NULL)
#define PORT_SPECIAL_ONOFF_DIPLOC(_mask, _default, _strindex, _diploc) \
curfield = ioconfig_alloc_onoff(*curport, DEF_STR(_strindex), _default, _mask, _diploc, errorbuf); \
cursetting = NULL;
/* append a code */
#define PORT_CODE(_code) \
ioconfig_add_code(*curfield, SEQ_TYPE_STANDARD, _code);
#define PORT_CODE_DEC(_code) \
ioconfig_add_code(*curfield, SEQ_TYPE_DECREMENT, _code);
#define PORT_CODE_INC(_code) \
ioconfig_add_code(*curfield, SEQ_TYPE_INCREMENT, _code);
/* joystick flags */
#define PORT_2WAY \
curfield->way = 2;
#define PORT_4WAY \
curfield->way = 4;
#define PORT_8WAY \
curfield->way = 8;
#define PORT_16WAY \
curfield->way = 16;
#define PORT_ROTATED \
curfield->flags |= FIELD_FLAG_ROTATED
/* general flags */
#define PORT_NAME(_name) \
curfield->name = input_port_string_from_token(_name);
#define PORT_PLAYER(_player) \
curfield->player = (_player) - 1;
#define PORT_COCKTAIL \
curfield->flags |= FIELD_FLAG_COCKTAIL; \
curfield->player = 1;
#define PORT_TOGGLE \
curfield->flags |= FIELD_FLAG_TOGGLE;
#define PORT_IMPULSE(_duration) \
curfield->impulse = _duration;
#define PORT_REVERSE \
curfield->flags |= ANALOG_FLAG_REVERSE;
#define PORT_RESET \
curfield->flags |= ANALOG_FLAG_RESET;
#define PORT_UNUSED \
curfield->flags |= FIELD_FLAG_UNUSED;
/* analog settings */
/* if this macro is not used, the minimum defaluts to 0 and maximum defaults to the mask value */
#define PORT_MINMAX(_min, _max) \
curfield->min = _min; \
curfield->max = _max;
#define PORT_SENSITIVITY(_sensitivity) \
curfield->sensitivity = _sensitivity;
#define PORT_KEYDELTA(_delta) \
curfield->delta = curfield->centerdelta = _delta;
/* note that PORT_CENTERDELTA must appear after PORT_KEYDELTA */
#define PORT_CENTERDELTA(_delta) \
curfield->centerdelta = _delta;
#define PORT_CROSSHAIR(axis, scale, offset, altaxis) \
curfield->crossaxis = CROSSHAIR_AXIS_##axis; \
curfield->crossaltaxis = altaxis; \
curfield->crossscale = scale; \
curfield->crossoffset = offset;
#define PORT_CROSSHAIR_MAPPER(_callback) \
curfield->crossmapper = input_field_crossmap_delegate(_callback, #_callback, (device_t *)NULL); \
curfield->crossmapper_device = DEVICE_SELF;
#define PORT_CROSSHAIR_MAPPER_MEMBER(_device, _class, _member) \
curfield->crossmapper = input_field_crossmap_delegate(&_class::_member, #_class "::" #_member, (_class *)NULL); \
curfield->crossmapper_device = _device;
/* how many optical counts for 1 full turn of the control */
#define PORT_FULL_TURN_COUNT(_count) \
curfield->full_turn_count = _count;
/* positional controls can be binary or 1 of X */
/* 1 of X not completed yet */
/* if it is specified as PORT_REMAP_TABLE then it is binary, but remapped */
/* otherwise it is binary */
#define PORT_POSITIONS(_positions) \
curfield->max = _positions;
/* positional control wraps at min/max */
#define PORT_WRAPS \
curfield->flags |= ANALOG_FLAG_WRAPS;
/* positional control uses this remap table */
#define PORT_REMAP_TABLE(_table) \
curfield->remap_table = _table;
/* positional control bits are active low */
#define PORT_INVERT \
curfield->flags |= ANALOG_FLAG_INVERT;
/* read callbacks */
#define PORT_CUSTOM(_callback, _param) \
curfield->read = input_field_read_delegate(_callback, #_callback, (device_t *)NULL); \
curfield->read_param = (void *)(_param); \
curfield->read_device = DEVICE_SELF;
#define PORT_CUSTOM_MEMBER(_device, _class, _member, _param) \
curfield->read = input_field_read_delegate(&_class::_member, #_class "::" #_member, (_class *)NULL); \
curfield->read_param = (void *)(_param); \
curfield->read_device = (_device);
/* write callbacks */
#define PORT_CHANGED(_callback, _param) \
curfield->write = input_field_write_delegate(_callback, #_callback, (device_t *)NULL); \
curfield->write_param = (void *)(_param); \
curfield->write_device = DEVICE_SELF;
#define PORT_CHANGED_MEMBER(_device, _class, _member, _param) \
curfield->write = input_field_write_delegate(&_class::_member, #_class "::" #_member, (_class *)NULL); \
curfield->write_param = (void *)(_param); \
curfield->write_device = (_device);
/* input device handler */
#define PORT_READ_LINE_DEVICE(_device, _read_line_device) \
curfield->read = input_field_read_delegate(&ioport_read_line_wrapper<_read_line_device>, #_read_line_device, (device_t *)NULL); \
curfield->read_param = NULL; \
curfield->read_device = _device;
#define PORT_READ_LINE_DEVICE_MEMBER(_device, _class, _member) \
curfield->read = input_field_read_delegate(&ioport_read_line_wrapper<_class, &_class::_member>, #_class "::" #_member, (_class *)NULL); \
curfield->read_param = NULL; \
curfield->read_device = _device;
/* output device handler */
#define PORT_WRITE_LINE_DEVICE(_device, _write_line_device) \
curfield->write = input_field_write_delegate(&ioport_write_line_wrapper<_write_line_device>, #_write_line_device, (device_t *)NULL); \
curfield->write_param = NULL; \
curfield->write_device = _device;
#define PORT_WRITE_LINE_DEVICE_MEMBER(_device, _class, _member) \
curfield->write = input_field_write_delegate(&ioport_write_line_wrapper<_class, &_class::_member>, #_class "::" #_member, (_class *)NULL); \
curfield->write_param = NULL; \
curfield->write_device = _device;
/* dip switch definition */
#define PORT_DIPNAME(_mask, _default, _name) \
curfield = ioconfig_alloc_field(*curport, IPT_DIPSWITCH, (_default), (_mask), (_name)); \
cursetting = NULL;
#define PORT_DIPSETTING(_default, _name) \
cursetting = ioconfig_alloc_setting(*curfield, (_default) & curfield->mask, (_name));
/* physical location, of the form: name:[!]sw,[name:][!]sw,... */
/* note that these are specified LSB-first */
#define PORT_DIPLOCATION(_location) \
diplocation_list_alloc(*curfield, _location, errorbuf);
/* conditionals for dip switch settings */
#define PORT_CONDITION(_tag, _mask, _condition, _value) \
{ \
input_condition &condition = (cursetting != NULL) ? cursetting->condition : curfield->condition; \
condition.tag = (_tag); \
condition.mask = (_mask); \
condition.condition = (_condition); \
condition.value = (_value); \
}
/* analog adjuster definition */
#define PORT_ADJUSTER(_default, _name) \
curfield = ioconfig_alloc_field(*curport, IPT_ADJUSTER, (_default), 0xff, (_name)); \
cursetting = NULL; \
/* config definition */
#define PORT_CONFNAME(_mask, _default, _name) \
curfield = ioconfig_alloc_field(*curport, IPT_CONFIG, (_default), (_mask), (_name)); \
cursetting = NULL; \
#define PORT_CONFSETTING(_default, _name) \
cursetting = ioconfig_alloc_setting(*curfield, (_default) & curfield->mask, (_name));
/* keyboard chars */
#define PORT_CHAR(_ch) \
ioconfig_field_add_char(*curfield, _ch, errorbuf);
/* name of table */
#define DEVICE_INPUT_DEFAULTS_NAME(_name) device_iptdef_##_name
#define device_iptdef_0 NULL
#define device_iptdef___null NULL
/* start of table */
#define DEVICE_INPUT_DEFAULTS_START(_name) \
const input_device_default DEVICE_INPUT_DEFAULTS_NAME(_name)[] = {
/* end of table */
#define DEVICE_INPUT_DEFAULTS(_tag,_mask,_defval) \
{ _tag ,_mask, _defval }, \
/* end of table */
#define DEVICE_INPUT_DEFAULTS_END \
{NULL,0,0} };
/***************************************************************************
HELPER MACROS
***************************************************************************/
#define PORT_DIPUNUSED_DIPLOC(_mask, _default, _diploc) \
PORT_SPECIAL_ONOFF_DIPLOC(_mask, _default, Unused, _diploc)
#define PORT_DIPUNUSED(_mask, _default) \
PORT_SPECIAL_ONOFF(_mask, _default, Unused)
#define PORT_DIPUNKNOWN_DIPLOC(_mask, _default, _diploc) \
PORT_SPECIAL_ONOFF_DIPLOC(_mask, _default, Unknown, _diploc)
#define PORT_DIPUNKNOWN(_mask, _default) \
PORT_SPECIAL_ONOFF(_mask, _default, Unknown)
#define PORT_SERVICE_DIPLOC(_mask, _default, _diploc) \
PORT_SPECIAL_ONOFF_DIPLOC(_mask, _default, Service_Mode, _diploc)
#define PORT_SERVICE(_mask, _default) \
PORT_SPECIAL_ONOFF(_mask, _default, Service_Mode)
#define PORT_SERVICE_NO_TOGGLE(_mask, _default) \
PORT_BIT( _mask, _mask & _default, IPT_SERVICE ) PORT_NAME( DEF_STR( Service_Mode ))
/***************************************************************************
FUNCTION PROTOTYPES
***************************************************************************/
/* ----- core system management ----- */
/* initialize the input ports, processing the given token list */
time_t input_port_init(running_machine &machine);
/* ----- port configurations ----- */
/* initialize an input port list structure and allocate ports according to the given tokens */
void input_port_list_init(device_t &device, ioport_list &portlist, astring &errorbuf);
/* return the field that matches the given tag and mask */
const input_field_config *input_field_by_tag_and_mask(const ioport_list &portlist, const char *tag, input_port_value mask);
/* ----- accessors for input types ----- */
/* return TRUE if the given type represents an analog control */
int input_type_is_analog(int type);
/* return the name for the given type/player */
const char *input_type_name(running_machine &machine, int type, int player);
/* return the group for the given type/player */
int input_type_group(running_machine &machine, int type, int player);
/* return the global input mapping sequence for the given type/player */
const input_seq &input_type_seq(running_machine &machine, int type, int player, input_seq_type seqtype);
/* change the global input sequence for the given type/player */
void input_type_set_seq(running_machine &machine, int type, int player, input_seq_type seqtype, const input_seq *newseq);
/* return TRUE if the sequence for the given input type/player is pressed */
int input_type_pressed(running_machine &machine, int type, int player);
/* return the list of default mappings */
const simple_list<input_type_entry> &input_type_list(running_machine &machine);
/* ----- accessors for input fields ----- */
/* return the expanded string name of the field */
const char *input_field_name(const input_field_config *field);
/* return the input sequence for the given input field */
const input_seq &input_field_seq(const input_field_config *field, input_seq_type seqtype);
/* return the current settings for the given input field */
void input_field_get_user_settings(const input_field_config *field, input_field_user_settings *settings);
/* modify the current settings for the given input field */
void input_field_set_user_settings(const input_field_config *field, const input_field_user_settings *settings);
/* return the expanded setting name for a field */
const char *input_field_setting_name(const input_field_config *field);
/* return TRUE if the given field has a "previous" setting */
int input_field_has_previous_setting(const input_field_config *field);
/* select the previous item for a DIP switch or configuration field */
void input_field_select_previous_setting(const input_field_config *field);
/* return TRUE if the given field has a "next" setting */
int input_field_has_next_setting(const input_field_config *field);
/* select the next item for a DIP switch or configuration field */
void input_field_select_next_setting(const input_field_config *field);
/* ----- port checking ----- */
/* return whether an input port exists */
bool input_port_exists(running_machine &machine, const char *tag);
/* return a bitmask of which bits of an input port are active (i.e. not unused or unknown) */
input_port_value input_port_active(running_machine &machine, const char *tag);
/* return a bitmask of which bits of an input port are active (i.e. not unused or unknown), or a default value if the port does not exist */
input_port_value input_port_active_safe(running_machine &machine, const char *tag, input_port_value defvalue);
/* ----- port reading ----- */
/* return the value of an input port */
input_port_value input_port_read_direct(const input_port_config *port);
/* return the value of an input port specified by tag */
input_port_value input_port_read(running_machine &machine, const char *tag);
/* return the value of a device input port specified by tag */
input_port_value input_port_read(device_t *device, const char *tag);
/* return the value of an input port specified by tag, or a default value if the port does not exist */
input_port_value input_port_read_safe(running_machine &machine, const char *tag, input_port_value defvalue);
/* return the extracted crosshair values for the given player */
int input_port_get_crosshair_position(running_machine &machine, int player, float *x, float *y);
/* force an update to the input port values based on current conditions */
void input_port_update_defaults(running_machine &machine);
/* ----- port writing ----- */
/* write a value to a port */
void input_port_write_direct(const input_port_config *port, input_port_value value, input_port_value mask);
/* write a value to a port specified by tag */
void input_port_write(running_machine &machine, const char *tag, input_port_value value, input_port_value mask);
/* write a value to a port, ignore if the port does not exist */
void input_port_write_safe(running_machine &machine, const char *tag, input_port_value value, input_port_value mask);
/* ----- misc helper functions ----- */
/* return the TRUE if the given condition attached is true */
int input_condition_true(running_machine &machine, const input_condition *condition,device_t &owner);
/* convert an input_port_token to a default string */
const char *input_port_string_from_token(const char *token);
/* return TRUE if machine use full keyboard emulation */
int input_machine_has_keyboard(running_machine &machine);
/* these are called by the core; they should not be called from FEs */
void inputx_init(running_machine &machine);
/* called by drivers to setup natural keyboard support */
void inputx_setup_natural_keyboard(running_machine &machine,
int (*queue_chars)(running_machine &machine, const unicode_char *text, size_t text_len),
int (*accept_char)(running_machine &machine, unicode_char ch),
int (*charqueue_empty)(running_machine &machine));
/* validity checks */
int validate_natural_keyboard_statics(void);
/* these can be called from FEs */
int inputx_can_post(running_machine &machine);
/* various posting functions; can be called from FEs */
void inputx_postc(running_machine &machine, unicode_char ch);
void inputx_post_utf8(running_machine &machine, const char *text);
void inputx_post_utf8_rate(running_machine &machine, const char *text, attotime rate);
int inputx_is_posting(running_machine &machine);
/* miscellaneous functions */
int input_classify_port(const input_field_config *field);
int input_has_input_class(running_machine &machine, int inputclass);
int input_player_number(const input_field_config *field);
int input_count_players(running_machine &machine);
inline running_machine &input_field_config::machine() const
{
return m_port.machine();
}
// temporary construction helpers
void field_config_insert(input_field_config &newfield, input_port_value &disallowedbits, astring &errorbuf);
void diplocation_list_alloc(input_field_config &field, const char *location, astring &errorbuf);
input_port_config *ioconfig_alloc_port(ioport_list &portlist, device_t &device, const char *tag);
input_port_config *ioconfig_modify_port(ioport_list &portlist, device_t &device, const char *tag);
input_field_config *ioconfig_alloc_field(input_port_config &port, int type, input_port_value defval, input_port_value mask, const char *name = NULL);
input_field_config *ioconfig_alloc_onoff(input_port_config &port, const char *name, input_port_value defval, input_port_value mask, const char *diplocation, astring &errorbuf);
input_setting_config *ioconfig_alloc_setting(input_field_config &field, input_port_value value, const char *name);
void ioconfig_field_add_char(input_field_config &field, unicode_char ch, astring &errorbuf);
void ioconfig_add_code(input_field_config &field, int which, input_code code);
#endif /* __INPTPORT_H__ */
Reference in New Issue View Git Blame Copy Permalink