public static void Raise <TEventArgValue>(this EventHandlerT <TEventArgValue> handler, object sender, TEventArgValue value)
{
if (handler != null)
{
handler.Invoke(sender, new EventArgs <TEventArgValue>(value));
}
}
public static void Raise(this EventHandlerT <string> handler, object sender, string format, params object[] args)
{
if (handler != null)
{
var value = string.Format(format, args);
handler.Invoke(sender, new EventArgs <string>(value));
}
}
public static void RemoveListener(string eventName, EventHandlerT <T> call)
{
if (Instance.mEvenDictionary.ContainsKey(eventName))
{
Instance.mEvenDictionary [eventName] -= call;
}
else
{
Debug.LogWarning("[MessageCenter] NO SUCH EVENT NAME FOUND");
}
}
public static TEventArgValue RaiseGet <TEventArgValue>(this EventHandlerT <TEventArgValue> handler, object sender, TEventArgValue value)
{
if (handler != null)
{
var args = new EventArgs <TEventArgValue>(value);
handler.Invoke(sender, args);
return(args.Value);
}
return(default(TEventArgValue));
}
/// <summary>
/// Adds the listener.
/// </summary>
/// <param name="eventName">Event name.</param>
/// <param name="call">Call.</param>
public static void AddListener(string eventName, EventHandlerT <T> call)
{
if (Instance.mEvenDictionary.ContainsKey(eventName))
{
Instance.mEvenDictionary [eventName] += call;
}
else
{
Instance.mEvenDictionary.Add(eventName, call);
//Instance.mEvenDictionary [eventName] += call;
}
Debug.LogWarning("[MessageCenter] LISTENER ADD :" + eventName);
}
private void SetHotkeyHandlers(TextBox txtBox, Action <KeyOrButton> keySetCallback)
{
var oldText = txtBox.Text;
txtBox.Text = "Set Hotkey...";
txtBox.Select(0, 0);
KeyEventHandler handlerDown = null;
KeyEventHandler handlerUp = null;
EventHandler leaveHandler = null;
EventHandlerT <GamepadButton> gamepadButtonPressed = null;
Action unregisterEvents = () =>
{
txtBox.KeyDown -= handlerDown;
txtBox.KeyUp -= handlerUp;
txtBox.Leave -= leaveHandler;
Hook.AnyGamepadButtonPressed -= gamepadButtonPressed;
};
handlerDown = (s, x) =>
{
var key = x.KeyCode == Keys.Escape ? null : new KeyOrButton(x.KeyCode | x.Modifiers);
if (x.KeyCode == Keys.ControlKey || x.KeyCode == Keys.ShiftKey || x.KeyCode == Keys.Menu)
{
return;
}
keySetCallback(key);
unregisterEvents();
txtBox.Select(0, 0);
chkGlobalHotkeys.Select();
txtBox.Text = FormatKey(key);
};
handlerUp = (s, x) =>
{
var key = x.KeyCode == Keys.Escape ? null : new KeyOrButton(x.KeyCode | x.Modifiers);
if (x.KeyCode == Keys.ControlKey || x.KeyCode == Keys.ShiftKey || x.KeyCode == Keys.Menu)
{
keySetCallback(key);
unregisterEvents();
txtBox.Select(0, 0);
chkGlobalHotkeys.Select();
txtBox.Text = FormatKey(key);
}
};
leaveHandler = (s, x) =>
{
unregisterEvents();
txtBox.Text = oldText;
};
gamepadButtonPressed = (s, x) =>
{
var key = new KeyOrButton(x);
keySetCallback(key);
unregisterEvents();
Action action = () =>
{
txtBox.Select(0, 0);
chkGlobalHotkeys.Select();
txtBox.Text = FormatKey(key);
};
if (InvokeRequired)
{
Invoke(action);
}
else
{
action();
}
};
txtBox.KeyDown += handlerDown;
txtBox.KeyUp += handlerUp;
txtBox.Leave += leaveHandler;
Hook.AnyGamepadButtonPressed += gamepadButtonPressed;
}
public static bool HasHandler <TEventArgValue>(this EventHandlerT <TEventArgValue> handler)
{
return(handler != null);
}
// Behaviour essentially Lifted from LiveSplit Settings.
private void SetHotkeyHandlers(TextBox txtBox, Action <KeyOrButton> keySetCallback)
{
string oldText = txtBox.Text;
txtBox.Text = "Set Hotkey...";
txtBox.Select(0, 0);
KeyEventHandler handlerDown = null;
KeyEventHandler handlerUp = null;
EventHandler leaveHandler = null;
EventHandlerT <GamepadButton> gamepadButtonPressed = null;
// Remove Input handlers.
Action unregisterEvents = () =>
{
txtBox.KeyDown -= handlerDown;
txtBox.KeyUp -= handlerUp;
txtBox.Leave -= leaveHandler;
Hook.AnyGamepadButtonPressed -= gamepadButtonPressed;
};
// Handler for KeyDown
handlerDown = (s, x) =>
{
KeyOrButton keyOrButton = x.KeyCode == Keys.Escape ? null : new KeyOrButton(x.KeyCode | x.Modifiers);
// No action for special keys.
if (x.KeyCode == Keys.ControlKey || x.KeyCode == Keys.ShiftKey || x.KeyCode == Keys.Menu)
{
return;
}
keySetCallback(keyOrButton);
unregisterEvents();
// Remove Focus.
txtBox.Select(0, 0);
chkGlobalHotKeys.Select();
txtBox.Text = FormatKey(keyOrButton);
// Re-Register inputs.
RegisterHotKeys();
};
// Handler for KeyUp (allows setting of special keys, shift, ctrl etc.).
handlerUp = (s, x) =>
{
KeyOrButton keyOrButton = x.KeyCode == Keys.Escape ? null : new KeyOrButton(x.KeyCode | x.Modifiers);
// No action for normal keys.
if (x.KeyCode != Keys.ControlKey && x.KeyCode != Keys.ShiftKey && x.KeyCode != Keys.Menu)
{
return;
}
keySetCallback(keyOrButton);
unregisterEvents();
txtBox.Select(0, 0);
chkGlobalHotKeys.Select();
txtBox.Text = FormatKey(keyOrButton);
RegisterHotKeys();
};
leaveHandler = (s, x) =>
{
unregisterEvents();
txtBox.Text = oldText;
};
// Handler for gamepad/joystick inputs.
gamepadButtonPressed = (s, x) =>
{
KeyOrButton key = new KeyOrButton(x);
keySetCallback(key);
unregisterEvents();
Action keyOrButton = () =>
{
txtBox.Select(0, 0);
chkGlobalHotKeys.Select();
txtBox.Text = FormatKey(key);
RegisterHotKeys();
};
// May not be in the UI thread (likely).
if (InvokeRequired)
{
Invoke(keyOrButton);
}
else
{
keyOrButton();
}
};
txtBox.KeyDown += handlerDown;
txtBox.KeyUp += handlerUp;
txtBox.Leave += leaveHandler;
Hook.AnyGamepadButtonPressed += gamepadButtonPressed;
}
public DisposableHandler(T obj, EventHandlerT <T> disposed) : base(obj, disposed)
{
}
public static IDisposable AsDisposable <T>(this T obj, EventHandlerT <T> disposed)
{
return(new DisposableHandler <T>(obj, disposed));
}
private void ProcessMessage(String message, string[] arguments, Connection clientConnection)
{
try
{
if (message == "registerEvent")
{
if (arguments.Length == 0)
{
}
foreach (string ev in arguments)
{
dynamic handler;
switch (ev)
{
case "pause":
handler = new EventHandler((object o, EventArgs e) =>
{
clientConnection.SendMessage(ev);
});
State.OnPause += handler;
clientConnection.addDisconnectHandler(() => State.OnPause -= handler);
break;
case "reset":
handler = new EventHandlerT <TimerPhase>((object o, TimerPhase e) =>
{
clientConnection.SendMessage(ev, e.ToString());
});
State.OnReset += handler;
clientConnection.addDisconnectHandler(() => State.OnReset -= handler);
break;
case "resume":
handler = new EventHandler((object o, EventArgs e) =>
{
clientConnection.SendMessage(ev);
});
State.OnResume += handler;
clientConnection.addDisconnectHandler(() => State.OnResume -= handler);
break;
case "skipSplit":
handler = new EventHandler((object o, EventArgs e) =>
{
clientConnection.SendMessage(ev);
});
State.OnSkipSplit += handler;
clientConnection.addDisconnectHandler(() => State.OnSkipSplit -= handler);
break;
case "split":
handler = new EventHandler((object o, EventArgs e) =>
{
clientConnection.SendMessage(ev);
});
State.OnSplit += handler;
clientConnection.addDisconnectHandler(() => State.OnSplit -= handler);
break;
case "start":
handler = new EventHandler((object o, EventArgs e) =>
{
clientConnection.SendMessage(ev);
});
State.OnStart += handler;
clientConnection.addDisconnectHandler(() => State.OnStart -= handler);
break;
case "switchComparison":
handler = new EventHandler((object o, EventArgs e) =>
{
clientConnection.SendMessage(ev, State.CurrentComparison);
});
State.OnSwitchComparisonNext += handler;
State.OnSwitchComparisonPrevious += handler;
clientConnection.addDisconnectHandler(() =>
{
State.OnSwitchComparisonNext -= handler;
State.OnSwitchComparisonPrevious -= handler;
});
break;
case "undoAllPauses":
handler = new EventHandler((object o, EventArgs e) =>
{
clientConnection.SendMessage(ev);
});
State.OnUndoAllPauses += handler;
clientConnection.addDisconnectHandler(() => State.OnUndoAllPauses -= handler);
break;
case "undoSplit":
handler = new EventHandler((object o, EventArgs e) =>
{
clientConnection.SendMessage(ev);
});
State.OnUndoSplit += handler;
clientConnection.addDisconnectHandler(() => State.OnUndoSplit -= handler);
break;
}
}
}
if (message == "startorsplit")
{
if (State.CurrentPhase == TimerPhase.Running)
{
Model.Split();
}
else
{
Model.Start();
}
}
else if (message == "split")
{
Model.Split();
}
else if (message == "unsplit")
{
Model.UndoSplit();
}
else if (message == "skipsplit")
{
Model.SkipSplit();
}
else if (message == "pause" && State.CurrentPhase != TimerPhase.Paused)
{
Model.Pause();
}
else if (message == "resume" && State.CurrentPhase == TimerPhase.Paused)
{
Model.Pause();
}
else if (message == "reset")
{
Model.Reset();
}
else if (message == "starttimer")
{
Model.Start();
}
else if (message.StartsWith("setgametime "))
{
var value = message.Split(' ')[1];
var time = parseTime(value);
State.SetGameTime(time);
}
else if (message.StartsWith("setloadingtimes "))
{
var value = message.Split(' ')[1];
var time = parseTime(value);
State.LoadingTimes = time ?? TimeSpan.Zero;
}
else if (message == "pausegametime")
{
State.IsGameTimePaused = true;
}
else if (message == "unpausegametime")
{
AlwaysPauseGameTime = false;
State.IsGameTimePaused = false;
}
else if (message == "alwayspausegametime")
{
AlwaysPauseGameTime = true;
State.IsGameTimePaused = true;
}
else if (message == "getdelta" || message.StartsWith("getdelta "))
{
var comparison = State.CurrentComparison;
if (message.Contains(" "))
{
comparison = message.Split(new char[] { ' ' }, 2)[1];
}
var delta = LiveSplitStateHelper.GetLastDelta(State, State.CurrentSplitIndex, comparison, State.CurrentTimingMethod);
clientConnection.SendMessage(message.Trim(), delta.HasValue ? delta.Value.TotalMilliseconds : 0);
}
else if (message == "getsplits")
{
clientConnection.SendMessage(message, State.Run.Select((segment) =>
{
dynamic result = new System.Dynamic.ExpandoObject();
result.icon = segment.Icon;
result.name = segment.Name;
var comparison = segment.Comparisons[State.CurrentComparison][State.CurrentTimingMethod];
if (comparison.HasValue)
{
result.comparison = comparison.Value.TotalMilliseconds;
}
var splitTime = segment.SplitTime[State.CurrentTimingMethod];
if (splitTime.HasValue)
{
result.splitTime = splitTime.Value.TotalMilliseconds;
}
var personalBestSplitTime = segment.PersonalBestSplitTime[State.CurrentTimingMethod];
if (personalBestSplitTime.HasValue)
{
result.personalBestSplitTime = personalBestSplitTime.Value.TotalMilliseconds;
}
var bestSegmentTime = segment.BestSegmentTime[State.CurrentTimingMethod];
if (bestSegmentTime.HasValue)
{
result.bestSegmentTime = bestSegmentTime.Value.TotalMilliseconds;
}
return(result);
}));
}
else if (message == "getsplitindex")
{
clientConnection.SendMessage(message, State.CurrentSplitIndex);
}
else if (message == "getcurrentsplitname")
{
var splitindex = State.CurrentSplitIndex;
var currentsplitname = State.CurrentSplit.Name;
var response = currentsplitname;
clientConnection.SendMessage(message, response);
}
else if (message == "getprevioussplitname")
{
var previoussplitindex = State.CurrentSplitIndex - 1;
var previoussplitname = State.Run[previoussplitindex].Name;
var response = previoussplitname;
clientConnection.SendMessage(message, response);
}
else if (message == "getlastsplittime" && State.CurrentSplitIndex > 0)
{
var splittime = State.Run[State.CurrentSplitIndex - 1].SplitTime[State.CurrentTimingMethod];
clientConnection.SendMessage(message, splittime.HasValue ? splittime.Value.TotalMilliseconds : 0);
}
else if (message == "getcomparisonsplittime")
{
try
{
TimeSpan?splittime;
if (State.CurrentSplit == null)
{
splittime = State.Run[0].Comparisons[State.CurrentComparison][State.CurrentTimingMethod];
}
else
{
splittime = State.CurrentSplit.Comparisons[State.CurrentComparison][State.CurrentTimingMethod];
}
var response = 0.0;
if (splittime.HasValue)
{
response = splittime.Value.TotalMilliseconds;
}
clientConnection.SendMessage(message, response);
}
catch (Exception e)
{
clientConnection.SendError(message, e);
}
}
else if (message == "getcurrenttime")
{
var timingMethod = State.CurrentTimingMethod;
if (timingMethod == TimingMethod.GameTime && !State.IsGameTimeInitialized)
{
timingMethod = TimingMethod.RealTime;
}
var time = State.CurrentTime[timingMethod];
clientConnection.SendMessage(message, time.HasValue ? time.Value.TotalMilliseconds : 0);
}
else if (message == "getfinaltime" || message.StartsWith("getfinaltime "))
{
var comparison = State.CurrentComparison;
if (message.Contains(" "))
{
comparison = message.Split(new char[] { ' ' }, 2)[1];
}
var time = (State.CurrentPhase == TimerPhase.Ended)
? State.CurrentTime[State.CurrentTimingMethod]
: State.Run.Last().Comparisons[comparison][State.CurrentTimingMethod];
clientConnection.SendMessage(message.Trim(), time.HasValue ? time.Value.TotalMilliseconds : 0);
}
else if (message.StartsWith("getpredictedtime "))
{
var comparison = message.Split(new char[] { ' ' }, 2)[1];
var prediction = PredictTime(State, comparison);
clientConnection.SendMessage(message, prediction.HasValue ? prediction.Value.TotalMilliseconds : 0);
}
else if (message == "getbestpossibletime")
{
var comparison = LiveSplit.Model.Comparisons.BestSegmentsComparisonGenerator.ComparisonName;
var prediction = PredictTime(State, comparison);
clientConnection.SendMessage(message, prediction.HasValue ? prediction.Value.TotalMilliseconds : 0);
}
else if (message == "getcurrenttimerphase")
{
var response = State.CurrentPhase.ToString();
clientConnection.SendMessage(message, response);
}
else if (message == "getcomparison")
{
clientConnection.SendMessage(message, State.CurrentComparison);
}
else if (message.StartsWith("setcomparison "))
{
var comparison = message.Split(new char[] { ' ' }, 2)[1];
State.CurrentComparison = comparison;
}
else if (message == "switchto realtime")
{
State.CurrentTimingMethod = TimingMethod.RealTime;
}
else if (message == "switchto gametime")
{
State.CurrentTimingMethod = TimingMethod.GameTime;
}
else if (message.StartsWith("setsplitname "))
{
int index = Convert.ToInt32(message.Split(new char[] { ' ' }, 3)[1]);
string title = message.Split(new char[] { ' ' }, 3)[2];
State.Run[index].Name = title;
State.Run.HasChanged = true;
}
else if (message.StartsWith("setcurrentsplitname "))
{
string title = message.Split(new char[] { ' ' }, 2)[1];
State.Run[State.CurrentSplitIndex].Name = title;
State.Run.HasChanged = true;
}
else if (message == "getGame")
{
dynamic response = new System.Dynamic.ExpandoObject();
response.gameName = State.Run.GameName;
response.gameIcon = State.Run.GameIcon;
response.categoryName = State.Run.CategoryName;
response.attempts = State.Run.AttemptCount;
response.completedAttempts = State.Run.AttemptHistory.Where(x => x.Time.RealTime != null).Count();
clientConnection.SendMessage(message, response);
}
}
catch (Exception ex)
{
Log.Error(ex);
}
}
public DisposableBase(T internalObject, EventHandlerT <T> disposed)
{
this.InternalObject = internalObject;
this.disposed = disposed;
}
