InputProvider.java

package org.newdawn.slick.command;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.newdawn.slick.Input;
import org.newdawn.slick.util.InputAdapter;

/**
 * The central provider that maps real device input into abstract commands
 * defined by the developer. Registering a control against an command with this
 * class will cause the provider to produce an event for the command when the
 * input is pressed and released.
 * 
 * @author joverton
 */
public class InputProvider {
	/** The commands that have been defined */
	private HashMap commands;

	/** The list of listeners that may be listening */
	private ArrayList listeners = new ArrayList();

	/** The input context we're responding to */
	private Input input;

	/** The command input states */
	private HashMap commandState = new HashMap();

	/** True if this provider is actively sending events */
	private boolean active = true;

	/**
	 * Create a new input proider which will provide abstract input descriptions
	 * based on the input from the supplied context.
	 * 
	 * @param input
	 *            The input from which this provider will receive events
	 */
	public InputProvider(Input input) {
		this.input = input;

		input.addListener(new InputListenerImpl());
		commands = new HashMap();
	}

	/**
	 * Get the list of commands that have been registered with the provider,
	 * i.e. the commands that can be issued to the listeners
	 * 
	 * @return The list of commands (@see Command) that can be issued from this
	 *         provider
	 */
	public List getUniqueCommands() {
		List uniqueCommands = new ArrayList();

		for (Iterator it = commands.values().iterator(); it.hasNext();) {
			Command command = (Command) it.next();

			if (!uniqueCommands.contains(command)) {
				uniqueCommands.add(command);
			}
		}

		return uniqueCommands;
	}

	/**
	 * Get a list of the registered controls (@see Control) that can cause a
	 * particular command to be invoked
	 * 
	 * @param command
	 *            The command to be invoked
	 * @return The list of controls that can cause the command (@see Control)
	 */
	public List getControlsFor(Command command) {
		List controlsForCommand = new ArrayList();

		for (Iterator it = commands.entrySet().iterator(); it.hasNext();) {
			Map.Entry entry = (Map.Entry) it.next();
			Control key = (Control) entry.getKey();
			Command value = (Command) entry.getValue();

			if (value == command) {
				controlsForCommand.add(key);
			}
		}
		return controlsForCommand;
	}

	/**
	 * Indicate whether this provider should be sending events
	 * 
	 * @param active
	 *            True if this provider should be sending events
	 */
	public void setActive(boolean active) {
		this.active = active;
	}

	/**
	 * Check if this provider should be sending events
	 * 
	 * @return True if this provider should be sending events
	 */
	public boolean isActive() {
		return active;
	}

	/**
	 * Add a listener to the provider. This listener will be notified of
	 * commands detected from the input.
	 * 
	 * @param listener
	 *            The listener to be added
	 */
	public void addListener(InputProviderListener listener) {
		listeners.add(listener);
	}

	/**
	 * Remove a listener from this provider. The listener will no longer be
	 * provided with notification of commands performe.
	 * 
	 * @param listener
	 *            The listener to be removed
	 */
	public void removeListener(InputProviderListener listener) {
		listeners.remove(listener);
	}

	/**
	 * Bind an command to a control.
	 * 
	 * @param command
	 *            The command to bind to
	 * @param control
	 *            The control that is pressed/released to represent the command
	 */
	public void bindCommand(Control control, Command command) {
		commands.put(control, command);

		if (commandState.get(command) == null) {
			commandState.put(command, new CommandState());
		}
	}

	/**
	 * Clear all the controls that have been configured for a given command
	 * 
	 * @param command The command whose controls should be unbound
	 */
	public void clearCommand(Command command) {
		List controls = getControlsFor(command);
		
		for (int i=0;i<controls.size();i++) {
	    	unbindCommand((Control) controls.get(i));
	    }
	}
	
	/**
	 * Unbinds the command associated with this control
	 * 
	 * @param control
	 *            The control to remove
	 */
	public void unbindCommand(Control control) {
		Command command = (Command) commands.remove(control);
		if (command != null) {
			if (!commands.keySet().contains(command)) {
				commandState.remove(command);
			}
		}
	}

	/**
	 * Get the recorded state for a given command
	 * 
	 * @param command
	 *            The command to get the state for
	 * @return The given command state
	 */
	private CommandState getState(Command command) {
		return (CommandState) commandState.get(command);
	}

	/**
	 * Check if the last control event we recieved related to the given command
	 * indicated that a control was down
	 * 
	 * @param command
	 *            The command to check
	 * @return True if the last event indicated a button down
	 */
	public boolean isCommandControlDown(Command command) {
		return getState(command).isDown();
	}

	/**
	 * Check if one of the controls related to the command specified has been
	 * pressed since we last called this method
	 * 
	 * @param command
	 *            The command to check
	 * @return True if one of the controls has been pressed
	 */
	public boolean isCommandControlPressed(Command command) {
		return getState(command).isPressed();
	}

	/**
	 * Fire notification to any interested listeners that a control has been
	 * pressed indication an particular command
	 * 
	 * @param command
	 *            The command that has been pressed
	 */
	protected void firePressed(Command command) {
		getState(command).down = true;
		getState(command).pressed = true;

		if (!isActive()) {
			return;
		}

		for (int i = 0; i < listeners.size(); i++) {
			((InputProviderListener) listeners.get(i)).controlPressed(command);
		}
	}

	/**
	 * Fire notification to any interested listeners that a control has been
	 * released indication an particular command should be stopped
	 * 
	 * @param command
	 *            The command that has been pressed
	 */
	protected void fireReleased(Command command) {
		getState(command).down = false;

		if (!isActive()) {
			return;
		}

		for (int i = 0; i < listeners.size(); i++) {
			((InputProviderListener) listeners.get(i)).controlReleased(command);
		}
	}

	/**
	 * A token representing the state of all the controls causing an command to
	 * be invoked
	 * 
	 * @author kevin
	 */
	private class CommandState {
		/** True if one of the controls for this command is down */
		private boolean down;

		/** True if one of the controls for this command is pressed */
		private boolean pressed;

		/**
		 * Check if a control for the command has been pressed since last call.
		 * 
		 * @return True if the command has been pressed
		 */
		public boolean isPressed() {
			if (pressed) {
				pressed = false;
				return true;
			}

			return false;
		}

		/**
		 * Check if the last event we had indicated the control was pressed
		 * 
		 * @return True if the control was pressed
		 */
		public boolean isDown() {
			return down;
		}
	}

	/**
	 * A simple listener to respond to input and look up any required commands
	 * 
	 * @author kevin
	 */
	private class InputListenerImpl extends InputAdapter {
		/**
		 * @see org.newdawn.slick.util.InputAdapter#isAcceptingInput()
		 */
		public boolean isAcceptingInput() {
			return true;
		}

		/**
		 * @see org.newdawn.slick.util.InputAdapter#keyPressed(int, char)
		 */
		public void keyPressed(int key, char c) {
			Command command = (Command) commands.get(new KeyControl(key));
			if (command != null) {
				firePressed(command);
			}
		}

		/**
		 * @see org.newdawn.slick.util.InputAdapter#keyReleased(int, char)
		 */
		public void keyReleased(int key, char c) {
			Command command = (Command) commands.get(new KeyControl(key));
			if (command != null) {
				fireReleased(command);
			}
		}

		/**
		 * @see org.newdawn.slick.util.InputAdapter#mousePressed(int, int, int)
		 */
		public void mousePressed(int button, int x, int y) {
			Command command = (Command) commands.get(new MouseButtonControl(
					button));
			if (command != null) {
				firePressed(command);
			}
		}

		/**
		 * @see org.newdawn.slick.util.InputAdapter#mouseReleased(int, int, int)
		 */
		public void mouseReleased(int button, int x, int y) {
			Command command = (Command) commands.get(new MouseButtonControl(
					button));
			if (command != null) {
				fireReleased(command);
			}
		}

		/**
		 * @see org.newdawn.slick.util.InputAdapter#controllerLeftPressed(int)
		 */
		public void controllerLeftPressed(int controller) {
			Command command = (Command) commands
					.get(new ControllerDirectionControl(controller,
							ControllerDirectionControl.LEFT));
			if (command != null) {
				firePressed(command);
			}
		}

		/**
		 * @see org.newdawn.slick.util.InputAdapter#controllerLeftReleased(int)
		 */
		public void controllerLeftReleased(int controller) {
			Command command = (Command) commands
					.get(new ControllerDirectionControl(controller,
							ControllerDirectionControl.LEFT));
			if (command != null) {
				fireReleased(command);
			}
		}

		/**
		 * @see org.newdawn.slick.util.InputAdapter#controllerRightPressed(int)
		 */
		public void controllerRightPressed(int controller) {
			Command command = (Command) commands
					.get(new ControllerDirectionControl(controller,
							ControllerDirectionControl.RIGHT));
			if (command != null) {
				firePressed(command);
			}
		}

		/**
		 * @see org.newdawn.slick.util.InputAdapter#controllerRightReleased(int)
		 */
		public void controllerRightReleased(int controller) {
			Command command = (Command) commands
					.get(new ControllerDirectionControl(controller,
							ControllerDirectionControl.RIGHT));
			if (command != null) {
				fireReleased(command);
			}
		}

		/**
		 * @see org.newdawn.slick.util.InputAdapter#controllerUpPressed(int)
		 */
		public void controllerUpPressed(int controller) {
			Command command = (Command) commands
					.get(new ControllerDirectionControl(controller,
							ControllerDirectionControl.UP));
			if (command != null)
				firePressed(command);
		}

		/**
		 * @see org.newdawn.slick.util.InputAdapter#controllerUpReleased(int)
		 */
		public void controllerUpReleased(int controller) {
			Command command = (Command) commands
					.get(new ControllerDirectionControl(controller,
							ControllerDirectionControl.UP));
			if (command != null) {
				fireReleased(command);
			}
		}

		/**
		 * @see org.newdawn.slick.util.InputAdapter#controllerDownPressed(int)
		 */
		public void controllerDownPressed(int controller) {
			Command command = (Command) commands
					.get(new ControllerDirectionControl(controller,
							ControllerDirectionControl.DOWN));
			if (command != null) {
				firePressed(command);
			}
		}

		/**
		 * @see org.newdawn.slick.util.InputAdapter#controllerDownReleased(int)
		 */
		public void controllerDownReleased(int controller) {
			Command command = (Command) commands
					.get(new ControllerDirectionControl(controller,
							ControllerDirectionControl.DOWN));
			if (command != null) {
				fireReleased(command);
			}
		}

		/**
		 * @see org.newdawn.slick.util.InputAdapter#controllerButtonPressed(int,
		 *      int)
		 */
		public void controllerButtonPressed(int controller, int button) {
			Command command = (Command) commands
					.get(new ControllerButtonControl(controller, button));
			if (command != null) {
				firePressed(command);
			}
		}

		/**
		 * @see org.newdawn.slick.util.InputAdapter#controllerButtonReleased(int,
		 *      int)
		 */
		public void controllerButtonReleased(int controller, int button) {
			Command command = (Command) commands
					.get(new ControllerButtonControl(controller, button));
			if (command != null) {
				fireReleased(command);
			}
		}
	};
}