Master thesis

namespace Everywhere.ApplicationInterface
{
	public delegate Model.IWindow RegisterWindowHandler(string name, UserControl window);
	public delegate Model.IPanTiltOutput RegisterPanTiltOutputHandler(string name, EverywherePanTiltOutput output);
	public delegate Model.IInput RegisterInputHandler(string name, EverywhereInput input);
	
	public delegate void InputKeyEventHandler(Key key);

	/// <summary>
	/// Base class for every application which has to interface with the
	/// Everywhere display.
	/// </summary>
	public class EverywhereApplication
	{
		protected readonly Model.IEverywhereModel Model;
		protected readonly Dictionary<string, string> Parameters;
		protected readonly RegisterWindowHandler RegisterWindow;
		protected readonly RegisterPanTiltOutputHandler RegisterPanTiltOutput;
		protected readonly RegisterInputHandler RegisterInput;

		// Every application should have the same constructor as this one
		public EverywhereApplication(EverywhereApplicationArguments arguments)
		{
			this.Model = arguments.Model;
			this.Parameters = arguments.Parameters;
			this.RegisterWindow = arguments.RegisterWindow;
			this.RegisterPanTiltOutput = arguments.RegisterPanTiltOutput;
			this.RegisterInput = arguments.RegisterInput;
		}
	}

	/// <summary>
	/// Arguments which are passed during the initialisation of an EverywhereApplication
	/// </summary>
	public class EverywhereApplicationArguments
	{
		private readonly Model.IEverywhereModel _model;
		private readonly Dictionary<string, string> _parameters;
		private readonly RegisterWindowHandler _registerWindow;
		private readonly RegisterPanTiltOutputHandler _registerPanTiltOutput;
		private readonly RegisterInputHandler _registerInput;

		public Model.IEverywhereModel Model { get { return _model; } }
		public Dictionary<string, string> Parameters { get { return _parameters; } }
		public RegisterWindowHandler RegisterWindow { get { return _registerWindow; } }
		public RegisterPanTiltOutputHandler RegisterPanTiltOutput { get { return _registerPanTiltOutput; } }
		public RegisterInputHandler RegisterInput { get { return _registerInput; } }

		public EverywhereApplicationArguments(
			Model.IEverywhereModel model,
			Dictionary<string, string> parameters,
			RegisterWindowHandler registerWindow,
			RegisterPanTiltOutputHandler registerPanTiltOutput,
			RegisterInputHandler registerInput)
		{
			_model = model;
			_parameters = parameters;
			_registerWindow = registerWindow;
			_registerPanTiltOutput = registerPanTiltOutput;
			_registerInput = registerInput;
		}
	}
}
 

namespace Everywhere.ApplicationInterface
{
	public class EverywhereInput
	{
		public event InputKeyEventHandler KeyUp;
		public event InputKeyEventHandler KeyDown;

		public void SendKeyUp(Key key)
		{
			if (KeyUp != null) KeyUp(key);
		}

		public void SendKeyDown(Key key)
		{
			if (KeyDown != null) KeyDown(key);
		}
	}
}
 

namespace Everywhere.ApplicationInterface
{
	public class EverywherePanTiltOutput
	{
		public virtual void SetPanTilt(float pan, float tilt) { }
	}
}
 

namespace Everywhere.Model
{
	public delegate void WallEventHandler(IWall wall);
	public delegate void ProjectorEventHandler(IProjector projector);
	public delegate void ApplicationEventHandler(IApplication application);
	public delegate void WindowEventHandler(IWindow window);
	public delegate void WindowMappingEventHandler(IWindowMapping mapping);
	public delegate void InputMappingEventHandler(IInputMapping mapping);
	public delegate void InputEventHandler(IInput input);
	public delegate void PanTiltOutputEventHandler(IPanTiltOutput output);

	public interface IEverywhereModel
	{
		// Events
		event WallEventHandler WallAdded;
		event ProjectorEventHandler ProjectorAdded;
		event ApplicationEventHandler ApplicationInserted;
		event WindowEventHandler WindowLoaded;
		event WindowEventHandler WindowRemoved;
		event WindowMappingEventHandler WindowMappingAdded;
		event WindowMappingEventHandler WindowMappingRemoved;
		event InputMappingEventHandler InputMappingAdded;
		event InputEventHandler InputAdded;
		event PanTiltOutputEventHandler PanTiltOutputAdded;

		/// <summary>
		///   Retrieve all windows in the model
		/// </summary>
		IEnumerable<IWindow> GetWindows();
//		IEnumerable<IWindow> GetWindows(Interface.EverywhereApplication application);

		/// <summary>
		///   Retrieve window from the model matching with this
		///   application window.
		/// </summary>
		IWindow GetWindow(UserControl applicationWindow);
		IWindow GetWindow(string name);

		/// <summary>
		/// List all the window mappings
		/// </summary>
		IEnumerable<IWindowMapping> GetWindowMappings();
		IEnumerable<IWindowMapping> GetWindowMappings(IWindow window);
		IEnumerable<IWindowMapping> GetWindowMappings(UserControl window);

		/// <summary>
		/// List all the inputs
		/// </summary>
		/// <returns></returns>
		IEnumerable<IInput> GetInputs();
		IInput GetInput(string name);

        /// <summary>
        /// List all pan/tilt outputs
        /// </summary>
        IEnumerable<IPanTiltOutput> GetPanTiltOutputs();
        IPanTiltOutput GetPanTiltOutput(string name);

		/// <summary>
		/// List all the walls
		/// </summary>
		IEnumerable<IWall> GetWalls();
		IWall GetWall(string name);

		/// <summary>
		///   Steer projectors to get this window into focus
		///   The engine can decide which mappings are used to
		///   show this window. If possible, all mappings will be used.
		/// </summary>
		void Focus(IWindowMapping window);
		void Focus(IWindowMapping window, IProjector projector);
		void Focus(IWindow window);
		void Focus(IWindow window, IProjector projector);

		/// <summary>
		///   List all the projectors
		/// </summary>
		IEnumerable<IProjector> GetProjectors();
		IProjector GetProjector(string name);

		/// <summary>
		///   List all the currently active applications.
		/// </summary>
		IEnumerable<IApplication> GetApplications();

		/// <summary>
		/// Creates a new mapping between a window and a wall
		/// </summary>
		IWindowMapping CreateWindowMapping(IWindow window, IWall wall);
	}

	public interface IWall
	{
		string Name { get; }
		Size2d Size { get; }
	}

	public interface IProjector
	{
		string Name { get; }
		PanTiltRange Range { get; }
		float Pan { get; set; }
		float Tilt { get; set; }

		event ProjectorEventHandler ViewAngleChanged;
	}

	public interface IApplication
	{
		string Name { get; }
		ApplicationInterface.EverywhereApplication EverywhereApplication { get; }
	}

	public interface IWindow
	{
		string Name { get; }
		UserControl EverywhereWindow { get; }
	}

	public interface IWindowMapping
	{
		void MoveWindowHorizontal(float amounth);
		void MoveWindowVertical(float amounth);

		// Dimensions
		Point2d Position {get; set; }
		Size2d Size {get; set; }

		float FloatingDistance { get; set; }

		// Wall and window
		IWall Wall { get; }
		IWindow Window { get; }

		// Events
		event WindowMappingEventHandler PositionChanged;
	}

	public interface IInputMapping
	{
		IInput Input { get; }
		IWindow Receiver { get; }
	}

	public interface IInput
	{
		string Name { get; }
	}

	public interface IPanTiltOutput
	{
		string Name { get; }
        IProjector Projector { get; }
	}

	public class PanTiltRange
	{
		// Angles are in radians
		private readonly float _minPan, _maxPan, _minTilt, _maxTilt;
		public float MinPan { get { return _minPan; } }
		public float MaxPan { get { return _maxPan; } }
		public float MinTilt { get { return _minTilt; } }
		public float MaxTilt { get { return _maxTilt; } }

		public PanTiltRange(float minpan, float maxpan, float mintilt, float maxtilt)
		{
			_minPan = minpan;
			_maxPan = maxpan;
			_minTilt = mintilt;
			_maxTilt = maxtilt;
		}
	}
}