public CurrentPageContainer(IInput input, IRenderer renderer, IUrhoScheduler scheduler)
{
_input = new InputDispatcher();
_inputProxy = new InputProxy(input, _input);
_renderer = renderer;
_scheduler = scheduler;
}
void Start()
{
animator = GetComponent <Animator>();
InputDispatcher inputDispatcher = FindObjectOfType <InputDispatcher>();
inputDispatcher.AddKeyDownHandler(KeyCode.F, (KeyCode) => {
activateLastCollidedInteractive();
GameObject.Find("ProgressObject").GetComponent <ProgressController>().advanceIfPossible();
});
inputDispatcher.AddKeyDownHandler(KeyCode.E, (KeyCode) => {
if (heldObject == null)
{
pickupLastCollidedInteractive();
}
else
{
if (!isTouchingAnything)
{
dropHeldObject();
}
}
GameObject.Find("ProgressObject").GetComponent <ProgressController>().advanceIfPossible();
});
}
public void TransmitUncontrolInfo(InputDispatcher dispatcher)
{
inTakeOver = dispatcher.inTakeOver;
uncontrolTime = dispatcher.uncontrolTime;
Debug.Log(string.Format("TransmitUncontrolInfo from {0} to {1}, inTakeOver:{2}, uncontrolTime:{3}",
dispatcher.m_player.m_name, m_player.m_name, inTakeOver, uncontrolTime));
}
/// <summary>
/// Load the hardware data and maps existing functions with the hardware
/// </summary>
public static void InitHardware()
{
HardwareData hardware = HardwareDataManager.LoadData();
HardwareAction actions = new HardwareAction(hardware);
InputDispatcher.RegisterHardware(actions.HardwareCreator());
}
public ClickScene()
{
Enabled = true;
InputDispatcher
.Create(this)
.SetOnMouseUpFn(OnMouseUp);
}
public static void AddAllEventListener <T>(InputEventHandle <T> callback) where T : IInputEventBase
{
string eventName = typeof(T).Name;
InputDispatcher <T> dispatcher = GetDispatcher <T>();
dispatcher.OnEventDispatch += callback;
}
public void SendInputsAsyncEmptyList()
{
var result = InputDispatcher.SendInputsAsync(new List <IInput>());
result.GetAwaiter().OnCompleted(() =>
{
var numInputsSent = result.GetAwaiter().GetResult();
Assert.AreEqual(0, numInputsSent);
});
}
public Scene()
{
InputDispatcher
.Create(this)
.SetOnMouseUpFn(OnMouseUp);
Enabled = true;
Visible = true;
Push(new Menu());
DrawOrder = 124;
}
private void ReceiveData()
{
while (running)
{
IPEndPoint host = new IPEndPoint(IPAddress.Any, 0);
byte[] data = client.Receive(ref host);
string str = Encoding.ASCII.GetString(data);
Console.WriteLine("Received {0} from ESP32", str);
InputDispatcher.PerformAction(str);
}
}
public Scene() : base(GlblRes.RoomsLetterScene)
{
Background
.Get <Sprite>()
.SetRenderStage(RenderStage.PostBloom);
DrawOrder = 500;
InputDispatcher
.Create(this)
.SetOnMouseUpFn(OnMouseUp);
}
public Scene()
{
Enabled = true;
Visible = true;
InputDispatcher
.Create(this)
.SetOnMouseUpFn(OnMouseUp)
.SetOnKeyDownFn(OnKeyDown);
Push(new Ego(), new Mouse(), new ShadowEgo());
}
public Scene()
{
this.AutoAddEntities();
InputDispatcher
.Create(this)
.SetOnKeyDownFn(OnKeyDown);
Enabled = true;
Visible = true;
DrawOrder = 1019;
}
public virtual void Start()
{
connectionManager = GameObject.Find("World").GetComponent("ConnectionManager") as ConnectionManager;
playerManager = GameObject.Find("World").GetComponent("PlayerManager") as PlayerManager;
netPlayer = GameObject.Find("World").GetComponent("NetPlayer") as NetPlayer;
inputDispatcher = GameObject.Find("World").GetComponent("InputDispatcher") as InputDispatcher;
inputReceiver = GameObject.Find("World").GetComponent("InputReceiver") as InputReceiver;
//gameManager = GameObject.Find("World").GetComponent<GameManager>() as GameManager;
mapManager = GameObject.Find("World").GetComponent<MapManager>() as MapManager;
menuManager = GameObject.Find("World").GetComponent<MenuManager>() as MenuManager;
world = GameObject.Find("World");
}
private void Start()
{
InputDispatcher dispatcher = FindObjectOfType <InputDispatcher>();
dispatcher.AddKeyDownHandler(KeyCode.W, keyCode => startMovement(MovementDirection.North));
dispatcher.AddKeyDownHandler(KeyCode.D, keyCode => startMovement(MovementDirection.East));
dispatcher.AddKeyDownHandler(KeyCode.S, keyCode => startMovement(MovementDirection.South));
dispatcher.AddKeyDownHandler(KeyCode.A, keyCode => startMovement(MovementDirection.West));
dispatcher.AddKeyUpHandler(KeyCode.W, keyCode => stopMovement(MovementDirection.North));
dispatcher.AddKeyUpHandler(KeyCode.D, keyCode => stopMovement(MovementDirection.East));
dispatcher.AddKeyUpHandler(KeyCode.S, keyCode => stopMovement(MovementDirection.South));
dispatcher.AddKeyUpHandler(KeyCode.A, keyCode => stopMovement(MovementDirection.West));
}
/// <summary>
/// Listen on the serial port while the SerialIO instance is open
/// </summary>
private void Listen()
{
while (SerialIO.GetInstance().Active())
{
try
{
string msg = SerialIO.GetInstance().Read();
InputDispatcher.PerformAction(msg);
}
catch (Exception e)
{
Console.WriteLine(e.Message.ToString()); //TODO better exceptions
}
}
}
public Scene()
{
this.AutoAddEntities();
InputDispatcher
.Create(this)
.SetOnMouseUpFn(OnMouseUp);
ScenePath
.Create(this);
Enabled = false;
DrawOrder = 125;
}
public void Initialize(ScreenLayer initialLayer = null)
{
ResourceContainer = new AssemblyResourceContainer(Assembly.GetEntryAssembly(), $"{nameof(StorybrewEditor)}.Resources", "resources");
DrawState.Initialize(ResourceContainer, Window.Width, Window.Height);
drawContext = new DrawContext();
drawContext.Register(this, false);
drawContext.Register <TextureContainer>(new TextureContainerAtlas(ResourceContainer), true);
drawContext.Register <QuadRenderer>(new QuadRendererBuffered(), true);
drawContext.Register <LineRenderer>(new LineRendererBuffered(), true);
try
{
var brewLibAssembly = Assembly.GetAssembly(typeof(Drawable));
Skin = new Skin(drawContext.Get <TextureContainer>())
{
ResolveDrawableType = (drawableTypeName) =>
brewLibAssembly.GetType($"{nameof(BrewLib)}.{nameof(BrewLib.Graphics)}.{nameof(BrewLib.Graphics.Drawables)}.{drawableTypeName}", true, true),
ResolveWidgetType = (widgetTypeName) =>
Type.GetType($"{nameof(StorybrewEditor)}.{nameof(UserInterface)}.{widgetTypeName}", false, true) ??
brewLibAssembly.GetType($"{nameof(BrewLib)}.{nameof(UserInterface)}.{widgetTypeName}", true, true),
ResolveStyleType = (styleTypeName) =>
Type.GetType($"{nameof(StorybrewEditor)}.{nameof(UserInterface)}.{nameof(UserInterface.Skinning)}.{nameof(UserInterface.Skinning.Styles)}.{styleTypeName}", false, true) ??
brewLibAssembly.GetType($"{nameof(BrewLib)}.{nameof(UserInterface)}.{nameof(UserInterface.Skinning)}.{nameof(UserInterface.Skinning.Styles)}.{styleTypeName}", true, true),
};
Skin.Load("skin.json", ResourceContainer);
}
catch (Exception e)
{
Trace.WriteLine($"Failed to load skin: {e}");
Skin = new Skin(drawContext.Get <TextureContainer>());
}
var inputDispatcher = new InputDispatcher();
InputManager = new InputManager(Window, inputDispatcher);
ScreenLayerManager = new ScreenLayerManager(Window, clock, this);
inputDispatcher.Add(createOverlay(ScreenLayerManager));
inputDispatcher.Add(ScreenLayerManager.InputHandler);
Restart(initialLayer);
Window.Resize += window_Resize;
Window.Closing += window_Closing;
resizeToWindow();
}
public Scene()
{
this.AutoAddEntities();
Enabled = true;
Visible = true;
Interactive = true;
DrawOrder = 122;
InputDispatcher
.Create(this)
.SetOnMouseUpFn(OnMouseUp)
.SetOnKeyUpFn(OnKeyUp)
.SetOnMouseScrollFn(OnMouseScroll);
Reset();
}
public Scene()
{
Enabled = true;
Visible = true;
InputDispatcher
.Create(this)
.SetOnMouseUpFn(OnMouseUp)
.SetOnMouseMoveFn(OnMouseMove)
.SetOnKeyDownFn(OnKeyDown);
ScenePath
.Create(this)
.SetPath(CreatePath());
Push(new Mouse());
}
public static InputDispatcher <T> LoadDispatcher <T>() where T : IInputEventBase
{
string DispatcherName = typeof(T).ToString();
if (s_dispatcher.ContainsKey(DispatcherName))
{
throw new Exception(DispatcherName + " Dispatcher has exist!");
}
InputDispatcher <T> Dispatcher = new InputDispatcher <T>();
Dispatcher.m_OnAllEventDispatch = s_OnEventDispatch;
s_dispatcher.Add(DispatcherName, (IInputDispatcher)Dispatcher);
return(Dispatcher);
}
public static void RemoveListener <T>(string eventKey, InputEventHandle <T> callback) where T : IInputEventBase
{
InputDispatcher <T> dispatcher = GetDispatcher <T>();
dispatcher.RemoveListener(eventKey, callback);
}
public override void OnGet(HttpListenerRequest request, HttpListenerResponse response)
{
ResponseFactory.GenerateResponse(response, InputDispatcher.ObjectsToJSON());
}
public override void OnPost(HttpListenerRequest request, HttpListenerResponse response)
{
// Check if the request has the correct json content
if (request.ContentType == null)
{
ConsoleManager.LogError("Missing Content-Type in " + ActionName);
return;
}
if (!request.ContentType.Equals("application/json"))
{
return;
}
string jsonBody = ResponseFactory.JsonStringFromRequest(request);
// Data parsing:
JToken t = JToken.Parse(jsonBody);
int componentId = (int)t.SelectToken("id");
JObject obj = (JObject)t.SelectToken("data");
DigitalActionType eventType = (DigitalActionType)(int)obj.SelectToken("action");
switch (eventType)
{
case DigitalActionType.None:
InputDispatcher.UpdatePushButtonAction(componentId, null);
break;
case DigitalActionType.LaunchApp:
string actionName = (string)obj.SelectToken("name");
string appPath = (string)obj.SelectToken("path");
InputDispatcher.UpdatePushButtonAction(componentId, new ActionRunProgram(actionName)
{
FullAppDirectory = appPath, AppName = actionName
});
break;
case DigitalActionType.OpenWebsite:
string uri = (string)obj.SelectToken("websiteUri");
string name = (string)obj.SelectToken("name");
var action = new ActionOpenWebsite()
{
WebsiteName = name, WebsiteUri = uri
};
action.Init();
InputDispatcher.UpdatePushButtonAction(componentId, action);
break;
case DigitalActionType.Macro:
ActionRunMacro.MacroType macroType = (ActionRunMacro.MacroType)(int) obj.SelectToken("macroType");
string macroText = (string)obj.SelectToken("macroText");
InputDispatcher.UpdatePushButtonAction(componentId, new ActionRunMacro(macroType, macroText));
break; // TODO add selected keys to execute macro
}
// Store new action mapping:
InputDispatcher.UpdateActionMappingFile();
// Send response to the frontend
string jsonResponse = "{\"result\":true}";
ResponseFactory.GenerateResponse(response, jsonResponse);
}
public InputDispatcherFixture()
{
InputDispatcher = new InputDispatcher();
CreateInputList();
}
/// <summary>
/// Function executed when a slave accepts the master
/// </summary>
private static void MasterAcceptFunction(NetworkStream _stream)
{
Message m;
NetworkStream stream = _stream;
try
{
while (stream.CanRead && Form1.getForm().isConnectedMaster)
{
try
{
m = Message.ReadFromSocket(stream);
if (m.typeMessage == Message.TypeMessage.Input)
{
SlaveGlobalVars.SocketToDispatcherQueue.Enqueue(m.Content <INPUT_EXTENDED>());
//formUI.BeginInvoke((Action)(() => { ((Form1)formUI).setLabel("get_000"); InputDispatcher.DispatchInput(); ((Form1)formUI).setLabel("get " + m.Content<INPUT>().mkhi.ki.Vk); }));
formUI.BeginInvoke((Action)(() => { /*((Form1)formUI).setLabel("get_000"); */ InputDispatcher.DispatchInput(); /* ((Form1)formUI).setLabel("get " + m.Content<INPUT>().mkhi.ki.Vk); */ }));
//throw new Exception("ok");
//SlaveGlobalVars.SocketToDispatcherQueue.Add(m.Content<INPUT>());
}
else if (m.typeMessage == Message.TypeMessage.ClipboardAttached)
{//TODO move to another socket
formUI.BeginInvoke((Action)(() => { ((Form1)formUI).setLabel("clipboard copying"); CommonClasses.ManageClipboard.setCurrentClipboard(m); ((Form1)formUI).setLabel("clipboard copied"); }));
}
else if (m.typeMessage == Message.TypeMessage.Error)
{
SlaveGlobalVars.isTarget = false;
return;
}
else if (m.typeMessage == Message.TypeMessage.CloseConnection)
{
Form1.getForm().isConnectedMaster = false;
return;//in some case is not reached
}
else
{
System.Threading.Thread.Sleep(10);//TODO use async
}
}
catch (Exception e)
{
int a;
//no problem?
}
}
}
catch (Exception e)
{
Form1.getForm().isConnectedMaster = false;
//Console.WriteLine("Can't read from socket anymore");
}
}
public async Task SendInputsAsyncTest()
{
var result = await InputDispatcher.SendInputsAsync(InputList);
Assert.AreEqual(InputList.Count, result);
}
public InputDispatcherTests()
{
InputDispatcher = new InputDispatcher();
CreateInputList();
}
public static void RemoveAllEventListener <T>(InputEventHandle <T> callback) where T : IInputEventBase
{
InputDispatcher <T> dispatcher = GetDispatcher <T>();
dispatcher.OnEventDispatch -= callback;
}
public static void Dispatch <T>(T inputEvent) where T : IInputEventBase
{
InputDispatcher <T> dispatcher = GetDispatcher <T>();
dispatcher.Dispatch(inputEvent);
}
public static void RemoveListener <T>(InputEventHandle <T> callback) where T : IInputEventBase
{
InputDispatcher <T> dispatcher = GetDispatcher <T>();
dispatcher.RemoveListener(typeof(T).Name, callback);
}
public TestScene()
{
InputDispatcher
.Create(this)
.SetOnMouseUpFn(OnMouseUp);
}
