private void Listener_onSceneLoaded(string message, object sender, MessageArgs messageArgs, params object[] messageParams)
{
if ((messageArgs as OnSceneLoadedArgs).scene.name == TestGameMain.k_TestFrameworkStageSceneName)
{
StartCoroutine(LoadingSceneAsset(m_Args));
}
}
void FixedUpdate()
{
MessageArgs messageArgs = new MessageArgs();
valueGetterObject.SendMessage(valueGetterMethodByReference, messageArgs);
valueDisplay.text = valueDisplayText + messageArgs.value.ToString();
}
private async void DealMessage(MessageArgs e)
{
switch (e.ErrorType)
{
case ErrorTypes.NeedLogin:
var nav = await this.MainPage.DisplayAlert("提示", e.Message, "需要登陆", "返回上一页");
if (nav)
{
this.Container.GetInstance <INavigationService>()
.For <LoginViewModel>()
.Navigate();
}
else
{
await this.Container.GetInstance <INavigationService>().GoBackAsync();
}
break;
case ErrorTypes.Network:
await this.MainPage.DisplayAlert("网络异常", "当前网络不可用,请检查", "OK");
break;
default:
await this.MainPage.DisplayAlert("提示", e.Message, "OK");
break;
}
}
public override void ExecuteMessage(string message, object sender, MessageArgs messageArgs, params object[] messageParams)
{
OnSceneLoadedArgs args = messageArgs as OnSceneLoadedArgs;
Debug.Log("TestSceneLoadedController: " + args.scene.name + " Load Scene Assets.");
// Example 1:
/*
* SceneData data = SceneDataConfig.GetData(args.scene.name);
* AssetBundleManager.instance.LoadAssetBundle(data.assetBundleInfo, (bundle) =>
* {
* // TODO your code
* });
*/
// Example 2: 在SceneState的Load方法中完成场景读取
/*
* SceneState state = SceneState.CreateState(args.scene.name);
* state.Load();
*/
// 如果是Main Scene，打开默认面板
if (args.scene.name == TestGameMain.k_TestFrameworkMainSceneName)
{
TestUIManager.views.OpenView(TestUINames.Panel_TestUIDefaultPanel, true);
}
if (args.scene.name == TestGameMain.k_TestFrameworkAddSceneName)
{
TestUIManager.views.OpenView(TestUINames.Panel_TestUIPoolPanel, false);
}
}
/// <summary>
/// 向其它插件发送消息。
/// </summary>
/// <param name="message">消息。</param>
private void SendMessageImpl <TContent>(MessageArgs <TContent> message)
{
if (!_isInit)
{
throw new InvalidOperationException("Need initialize");
}
IEnumerable <AddinNode> nodes = GetNode(message.Destination).OfType <AddinNode>();
if (nodes == null)
{
return;
}
foreach (AddinNode node in nodes)
{
if (node == message.Sender)
{
continue;
}
AddinDescriptor descriptor = node.Descriptor.IsValueCreated ? node.Descriptor.Value : null;
if (descriptor != null && descriptor.BuildState == AddinBuildState.Build)
{
IHandler <TContent> handler = descriptor.Addin as IHandler <TContent>;
if (handler == null)
{
return;
}
handler.Handle(message);
}
}
}
/// <summary>
/// 向其它插件发送消息。
/// </summary>
/// <param name="sender">发送者。</param>
/// <param name="fullPath">目标插件的完整路径。</param>
/// <param name="content">消息。</param>
/// <param name="isAsync">是否异步处理消息。</param>
internal void SendMessage <TContent>(Object sender, String fullPath, TContent content, Boolean isAsync = false)
{
MessageArgs <TContent> message = new MessageArgs <TContent>(sender, fullPath, content);
if (isAsync)
{
lock (_syncObj)
{
if (_messageQueue == null)
{
InitMessageDispatcher();
}
message.IsAsync = true;
_messageQueue.Enqueue(message);
if (_messageQueue.Count == 1)
{
((ManualResetEvent)_syncEvent.Token.WaitHandle).Set();
}
}
}
else
{
SendMessageImpl <TContent> (message);
}
}
//Re-raise a message that was received from one of the plugins
public void HandleMessage(object sender, MessageArgs args)
{
if (MessageReceived != null) //Has some method been told to handle this event?
{
MessageReceived(this, args);
}
}
/// <summary>
/// Process messages from GStreamer
/// </summary>
static void HandleMessage(object o, MessageArgs args)
{
var msg = args.Message;
switch (msg.Type)
{
case MessageType.Error:
msg.ParseError(out GLib.GException err, out string debug);
$"Error received from element {msg.Src.Name}: {err.Message}".PrintErr();
$"Debugging information: {debug ?? "none"}".PrintErr();
return;
case MessageType.Eos:
Console.WriteLine("End of stream reached");
_data.MainLoop.Quit();
break;
case MessageType.StateChanged:
msg.ParseStateChanged(out State oldState, out State newState, out State pending);
if (msg.Src == _data.Playbin)
{
// Once we are in the playing state, analyze the streams
if (newState == State.Playing)
{
AnalyzeStreams();
}
}
break;
}
// We want to keep receiving messages
args.RetVal = true;
}
private void Bus_Message(object o, MessageArgs args)
{
var msg = args.Message;
//System.Diagnostics.Debug.WriteLine("HandleMessage received msg of type: {0}", msg.Type);
switch (msg.Type)
{
case MessageType.Error:
//
GLib.GException err;
string debug;
System.Diagnostics.Debug.WriteLine("Bus_Message: Error received: " + msg.ToString());
break;
case MessageType.StreamStatus:
Gst.StreamStatusType status;
Element theOwner;
msg.ParseStreamStatus(out status, out theOwner);
System.Diagnostics.Debug.WriteLine("Bus_Message: Case SteamingStatus: status is: " + status + " ; Owner is: " + theOwner.Name);
break;
case MessageType.StateChanged:
State oldState, newState, pendingState;
msg.ParseStateChanged(out oldState, out newState, out pendingState);
if (newState == State.Paused)
args.RetVal = false;
System.Diagnostics.Debug.WriteLine("Bus_Message: Pipeline state changed from {0} to {1}: ; Pending: {2}", Element.StateGetName(oldState), Element.StateGetName(newState), Element.StateGetName(pendingState));
break;
case MessageType.Element:
System.Diagnostics.Debug.WriteLine("Bus_Message: Element message: {0}", args.Message.ToString());
break;
default:
System.Diagnostics.Debug.WriteLine("Bus_Message: HandleMessage received msg of type: {0}", msg.Type);
break;
}
args.RetVal = true;
}
void Throw()
{
MessageArgs msg = new MessageArgs(transform);
rightGrab.SendMessage("OnThrow", msg, SendMessageOptions.DontRequireReceiver);
//Debug.Log("Throw");
//Vector3 angle = (new Vector3(throwingAngle, Mathf.Pow((1-Mathf.Pow(throwingAngle, 2)), 1/2), 0));
//throwingAngle = new Vector3(throwingAngleX, Mathf.Cos(throwingAngleX), 0).normalized;
//Debug.DrawRay(transform.position, throwingAngle, Color.magenta, 3f);
Transform obj = rightGrab;
if (obj)
{
if (obj.tag == "Item")
{
if (!msg.received)
{
//rightGrab.GetComponent<Rigidbody>().AddForce((transform.forward+transform.up)*f, ForceMode.Impulse);
ReleaseHand(true, false, true);
obj.GetComponent <Rigidbody>().AddForce(throwingAngle * throwPower * throwForce, ForceMode.Impulse);
}
}
else if (obj.tag == "Grabbable")
{
//rightGrab.GetComponent<Rigidbody>().AddForce((transform.forward+transform.up)*0.5f, ForceMode.Impulse);
ReleaseHand(true, true, true);
obj.GetComponent <Rigidbody>().AddForce(throwingAngle * throwPower * throwForce, ForceMode.Impulse);
}
else if (obj.tag == "Draggable")
{
ReleaseHand(true, true, true);
obj.GetComponent <Rigidbody>().AddForce(new Vector3(Mathf.Sign(rightGrab.position.x - transform.position.x), 0, 0) * 4f, ForceMode.Impulse);
}
}
}
public void HandleMessage(string type, MessageArgs args)
{
if (type == ProductTrader.MessageName && args != null)
{
HandleTraderAdd(args as TraderInstanceMessageArgs);
}
}
static void HandleMessage (object o, MessageArgs args)
{
var msg = args.Message;
switch (msg.Type) {
case MessageType.Error:
GLib.GException err;
string debug;
msg.ParseError (out err, out debug);
Console.WriteLine ("Error received from element {0}: {1}", msg.Src, err.Message);
Console.WriteLine ("Debugging information: {0}", debug != null ? debug : "none");
MainLoop.Quit ();
break;
case MessageType.Eos:
Console.WriteLine ("End-Of-Stream reached.");
MainLoop.Quit ();
break;
case MessageType.StateChanged: {
State oldState, newState, pendingState;
msg.ParseStateChanged (out oldState, out newState, out pendingState);
if (msg.Src == Playbin) {
if (newState == State.Playing) {
// Once we are in the playing state, analyze the streams
AnalyzeStreams ();
}
}
} break;
default:
break;
}
// We want to keep receiving messages
args.RetVal = true;
}
static void MessageCb(object o, MessageArgs args)
{
var bus = o as Bus;
var message = args.Message;
switch (message.Type)
{
case MessageType.Error:
{
var name = message.Src.PathString;
message.ParseError(out GLib.GException err, out string debug);
$"ERROR: from element {name}: {err.Message}".PrintErr();
if (debug != null)
{
$"Additional debug info:\n{debug}".PrintErr();
}
break;
}
case MessageType.Warning:
{
var name = message.Src.PathString;
message.ParseWarning(out IntPtr err, out string debug);
Console.WriteLine("WARNING");
break;
}
case MessageType.Eos:
{
Console.WriteLine("EOS");
_loop.Quit();
break;
}
}
}
void OnGrab(MessageArgs msg)
{
msg.received = true;
Transform t = msg.sender;
if (t.GetComponent <InteractControl>())
{
jump = t.GetComponent <Jump>();
if (jump)
{
if (jump.isActiveAndEnabled)
{
//Debug.Log("has jump");
if (rig.isKinematic && !jump.IsGrounded() && Input.GetButton("Jump"))
{
AxeJump();
}
}
}
if (rig.isKinematic)
{
rig.isKinematic = false;
}
}
}
static void MessageHandler(object sender, MessageArgs args)
{
Message message = args.Message;
string text = String.Format("Message from {0}: \t{1}", message.Src.Name, message.Type);
switch (message.Type)
{
case MessageType.Error:
Enum err;
string msg;
message.ParseError(out err, out msg);
text += String.Format("\t({0})", msg);
break;
case MessageType.StateChanged:
State oldstate, newstate, pending;
message.ParseStateChanged(out oldstate, out newstate, out pending);
text += String.Format("\t\t{0} -> {1} ({2})", oldstate, newstate, pending);
break;
case MessageType.Eos:
loop.Quit();
break;
}
Console.WriteLine(text);
}
private void addNewClient(string m, MessageArgs e)
{
try
{
if (clientSockets.Keys.Contains(m.Split('#')[0]))
{
bool isConnected = clientSockets[(m.Split('#')[0])].Connected;
if (!isConnected)
{
clientSockets.Remove(m.Split('#')[0]);
clientSockets.Add(m.Split('#')[0], e.ID);
addLog(this.logs, Constants.NEW_CLIENT_LOG + " " + m.Split('#')[0], Constants.LOG_INFO);
}
}
else
{
clientSockets.Add(m.Split('#')[0], e.ID);
addLog(this.logs, Constants.NEW_CLIENT_LOG + " " + m.Split('#')[0], Constants.LOG_INFO);
}
}
catch
{
addLog(this.logs, Constants.ALREADY_CONNECTED + " " + e.message.Split('#')[0], Constants.LOG_ERROR);
}
}
bool HoldInteract(Transform obj)
{
MessageArgs msg = new MessageArgs(transform);
obj.SendMessage("OnHoldInteract", msg, SendMessageOptions.DontRequireReceiver);
return(msg.received);
}
private bool IsRequiredValue(MessageArgs messageArgs)
{
if (value == null)
{
return(true);
}
if (value.valueType == MessageValueType.None)
{
return(true);
}
if (messageArgs.firstValue == null)
{
return(false);
}
switch (value.valueType)
{
case MessageValueType.String:
return(QuestMachineMessages.ArgToString(messageArgs.firstValue) == runtimeStringValue);
case MessageValueType.Int:
return(QuestMachineMessages.ArgToInt(messageArgs.firstValue) == value.intValue);
default:
Debug.LogError("Quest Machine: Unhandled MessageValueType " + value.valueType + ". Please contact the developer.", quest);
return(false);
}
}
public void HandleMessage(string type, MessageArgs args)
{
if (type == SpeedChangeMessageName && args is GameSpeedMessageArgs)
{
HandleSpeedChange(args as GameSpeedMessageArgs);
}
}
private void ClientServerWorker_MessageReceived(MessageArgs args)
{
this.Invoke((MethodInvoker) delegate
{
AppendMessage($"Doctor: {args.Message}");
});
}
void OnGrab(MessageArgs msg)
{
Debug.Log("on grab");
msg.received = true;
Transform t = msg.sender;
SpringJoint sj = null;
Rigidbody rig = t.GetComponent <Rigidbody>();
if (rig)
{
foreach (SpringJoint j in GetComponents <SpringJoint>())
{
if (j.connectedBody == rig)
{
sj = j;
break;
}
}
}
if (sj)
{
Debug.Log("Found sj: " + sj);
sj.autoConfigureConnectedAnchor = false;
sj.connectedAnchor = Vector3.zero;
sj.damper = 0;
sj.tolerance = 1f;
sj.minDistance = 0.0f;
sj.maxDistance = 0.1f;
}
}
private async Task ReportTemp(MessageArgs arg)
{
try
{
const string cmd = @"/opt/vc/bin/vcgencmd measure_temp";
var escapedArgs = cmd.Replace("\"", "\\\"");
var process = new Process()
{
StartInfo = new ProcessStartInfo
{
FileName = "/bin/bash",
Arguments = $"-c \"{escapedArgs}\"",
RedirectStandardOutput = true,
UseShellExecute = false,
CreateNoWindow = true,
}
};
process.Start();
await process.WaitForExitAsync();
var output = process.StandardOutput.ReadToEnd();
Context.System.Actor <TelegramMessageChannel>()
.Tell(new MessageArgs <string>(arg.ChatId, "[TEMP_ACTOR] " + output));
}
catch
{
Context.System.Actor <TelegramMessageChannel>()
.Tell(new MessageArgs <string>(arg.ChatId, "[TEMP_ACTOR] Not running on raspberry pi"));
}
}
private void Listener_onSceneUnloaded(string message, object sender, MessageArgs messageArgs, params object[] messageParams)
{
if ((messageArgs as OnSceneUnloadedArgs).scene.name == TestGameMain.k_TestFrameworkAddSceneName)
{
TestUIManager.views.CloseView(viewName);
}
}
public void HandleMessage(string type, MessageArgs args)
{
if (type == PlaceableMessages.PlaceablePlacedMessageName)
{
HandlePlaceableAdd(args as PlaceablePlacedArgs);
}
}
private async Task Restart(MessageArgs arg)
{
try
{
var actor = await Context.System.Actor <TeamspeakActor>().ResolveOne(TimeSpan.Zero);
Context.System.Actor <TelegramMessageChannel>().Tell(new MessageArgs <string>(arg.ChatId, "[RESTART_ACTOR] Teamspeak actor restart requested"));
var stopped = await actor.GracefulStop(TimeSpan.FromSeconds(5));
if (!stopped)
{
await actor.Ask(Kill.Instance);
}
Context.System.Actor <TelegramMessageChannel>().Tell(new MessageArgs <string>(arg.ChatId, "[RESTART_ACTOR] Actor stopped"));
Context.System.CreateActor <TeamspeakActor>();
Context.System.Actor <TelegramMessageChannel>().Tell(new MessageArgs <string>(arg.ChatId, "[RESTART_ACTOR] Actor restared"));
}
catch (ActorNotFoundException)
{
Context.System.CreateActor <TeamspeakActor>();
}
}
/// <summary>
/// 读取场景之前执行
/// </summary>
/// <param name="message"></param>
/// <param name="sender"></param>
/// <param name="messageArgs"></param>
/// <param name="messageParams"></param>
private void Listener_onLoadScene(string message, object sender, MessageArgs messageArgs, params object[] messageParams)
{
OnLoadSceneArgs args = messageArgs as OnLoadSceneArgs;
if (args.type == LoadSceneType.SceneName)
{
switch (args.sceneName)
{
case TestGameMain.k_TestFrameworkMainSceneName:
m_LoadStageSceneBtn.transform.Find("Text").GetComponent <Text>().text = "Load\n 'StageScene'";
break;
case TestGameMain.k_TestFrameworkStageSceneName:
m_LoadStageSceneBtn.transform.Find("Text").GetComponent <Text>().text = "Load\n 'MainScene'";
break;
case TestGameMain.k_TestFrameworkAddSceneName:
m_IsAddScene = true;
m_AddAddSceneBtn.transform.Find("Text").GetComponent <Text>().text = "Unload\n 'AddScene'";
break;
default:
break;
}
}
}
private void newConnection(object a, MessageArgs e)
{
int i = 0;
do
{
++i;
}while (connections[i] != 0);
connections[i] = 1;
switch (i)
{
case 1:
clients[0] = e.message.Split('#')[2];
this.call1.Dispatcher.Invoke(
System.Windows.Threading.DispatcherPriority.Normal,
new Action(() =>
{
this.call1.IsEnabled = true;
this.call1.Header = e.message.Split('#')[2];
this.Button_1.IsEnabled = true;
})
);
break;
}
}
void handle(MessageArgs command)
{
var message = _commandParser.GetArgumentString(_commandParser.Parse(command.Message).ToArray(), "'");
Logger.Write("Event handle: " + message);
_reactiveEngine.Handle(message);
}
private void MsgHandler(object o, MessageArgs args)
{
switch (args.Message.Type)
{
case MessageType.DurationChanged:
if (pipeline.QueryDuration(Format.Time, out duration))
{
duration /= Gst.Constants.SECOND;
ReadID();
}
break;
case MessageType.Eos:
// todo: finish
break;
case MessageType.Tag:
TagList tags = args.Message.ParseTag();
tags.GetString("chromaprint-fingerprint", out fingerprint);
if (fingerprint != null)
{
ReadID();
}
break;
}
}
private void RegexOnTextMessage(object sender, MessageArgs e)
{
var message = e.Message;
try
{
foreach (var(key, value) in regexHandlers)
{
var pattern = key;
var match = Regex.Match(message.Text, pattern, RegexOptions.IgnoreCase);
if (match.Success)
{
Logger.Log(LogType.Info, $"<{GetType().Name}:RegEx>({message.From.FirstName}:{message.From.Id}) -> {pattern}");
value?.Invoke(this, new RegExArgs(message, match, pattern));
}
}
if (RegexName != null)
{
var m = Regex.Match(message.Text, RegexName, RegexOptions.IgnoreCase);
if (m.Success)
{
message.Text = Regex.Replace(message.Text, RegexName, "", RegexOptions.IgnoreCase);
onNameRegexMatched?.Invoke(this, new RegExArgs(message, m, RegexName));
}
}
}
catch (Exception ex)
{
Logger.Log(LogType.Error, $"Exception: {ex.Message}");
}
}
private static async void DealMessage(MessageArgs e) {
switch (e.ErrorType) {
case ErrorTypes.NeedLogin:
var ns = IoC.Get<INavigationService>();
//ns.SuspendState();
ns.For<LoginViewModel>().Navigate();
break;
case ErrorTypes.DNSError:
case ErrorTypes.Network:
var dialog = new MessageDialog("当前网络不可用,请检查", "网络异常");
await dialog.ShowAsync();
break;
default:
var dialog2 = new MessageDialog(e.Message, "提示");
await dialog2.ShowAsync();
break;
}
}
private async void DealMessage(MessageArgs e) {
switch (e.ErrorType) {
case ErrorTypes.NoneForumPermission:
case ErrorTypes.NoneThreadPermission:
var nav = await this.MainPage.DisplayAlert("提示", e.Message, "切换账户", "返回上一页");
if (nav) {
this.Container.GetInstance<INavigationService>()
.For<LoginViewModel>()
.Navigate();
} else {
await this.Container.GetInstance<INavigationService>().GoBackAsync();
}
break;
default:
await this.MainPage.DisplayAlert("提示", e.Message, "OK");
break;
}
}
private async void DealMessage(MessageArgs e) {
switch (e.ErrorType) {
case ErrorTypes.NeedLogin:
var nav = await this.MainPage.DisplayAlert("提示", e.Message, "需要登陆", "返回上一页");
if (nav) {
this.Container.GetInstance<INavigationService>()
.For<LoginViewModel>()
.Navigate();
} else {
await this.Container.GetInstance<INavigationService>().GoBackAsync();
}
break;
case ErrorTypes.Network:
await this.MainPage.DisplayAlert("网络异常", "当前网络不可用,请检查", "OK");
break;
default:
await this.MainPage.DisplayAlert("提示", e.Message, "OK");
break;
}
}
private void MenuLoad(string loginId)
{
IEnvironmentMngService environmentMngService = SpringUtil.GetObject<IEnvironmentMngService>("EnvironmentMngService");
ICoordinator coordinator = workItem.Services.Get<ICoordinator>();
environmentMngService.EnvironmentinfoCall();
string menuProgramString = environmentMngService.GetAppSettingInfoByKey("MenuProgramId");
int menuProgramId = -1;
if (string.IsNullOrEmpty(menuProgramString) || !int.TryParse(menuProgramString, out menuProgramId))
{
MessageArgs messageArgs = new MessageArgs();
messageArgs.Message = "There is no information about menu program. Check the server configuration file";
workItem.Services.Get<IMessageService>().ShowMessage(messageArgs);
return;
}
Program program = workItem.Services.Get<Eland.GBFW.Win.Common.Interface.IRoleShellService>()
.GetProgramById(menuProgramId) as Program;
try
{
coordinator.LoadView(program.Name, program.Id, program.ClassName, program.AssemblyName,
null, "CreateMenu", new object[] { loginId },
coordinator.GetSmartPartInfo((SmartPartTypes)Enum.Parse(typeof(SmartPartTypes),
Enum.GetName(typeof(WorkspaceType),
program.WorkspaceType))));
}
catch (Exception ex)
{
MessageArgs messageArgs = new MessageArgs();
messageArgs.MessageLevel = MessageLevel.Error;
messageArgs.MessageType = MessageType.Alert;
messageArgs.Message = ex.Message;
messageArgs.Details = ex.StackTrace;
if (ex.InnerException != null) messageArgs.Details += "\n\rInnerMessage : " + ex.InnerException.Message;
workItem.Services.Get<IMessageService>().ShowMessage(messageArgs);
}
}
void ApiClient_OnMessage(object sender, MessageArgs e) {
Debug.WriteLine(e.Message);
}
private void OnEmpireMessage(object sender, MessageArgs e)
{
if (e.Message.nick.ToLower() == settings.empireUser.ToLower())
return;
SendMessage(new UbiMessage(String.Format("{0}", e.Message.text), EndPoint.Empiretv, EndPoint.SteamAdmin)
{
FromName = e.Message.nick,
NickColor = settings.empireNickColor,
TextOnly = false
});
}
void ApiClient_OnMessage(object sender, MessageArgs e) {
Device.BeginInvokeOnMainThread(() => {
this.DealMessage(e);
});
}
public bool Broadcast(MessageArgs arg)
{
if (subscriber != null)
{
try
{
subscriber.SendMessage(arg);
}
catch (Exception ex)
{
log.Error(ex);
return false;
}
}
return true;
}
public Object RemoveJob(object arg, bool ifUserRemoved)
{
try
{
if (arg != null)
{
string jobname = arg.ToString();
log.InfoFormat("Removing job {0}", jobname);
if (jobWrappers.ContainsKey(jobname))
{
if (jobWrappers[jobname].Job.Modules[jobWrappers[jobname].Job.OrderedModuleList[0]].GetType().FullName.Equals("Bits.ModulesNS.JobScheduler"))
{
//this is a timer-based job
timeManager.RemoveTimer(jobname);
log.InfoFormat("Removing timer for job {0}", jobname);
}
else
{
//assume it's a folder-based job
flatFileLoader.RemoverWatcher(jobname);
log.InfoFormat("Removing folder watcher for job {0}", jobname);
}
}
if (ifUserRemoved)
{
if (jobWrappers.ContainsKey(jobname))
jobWrappers.Remove(jobname);
if (guiJobStatus.ContainsKey(jobname))
guiJobStatus.Remove(jobname);
if (guiJobHistories.ContainsKey(jobname))
guiJobHistories.Remove(jobname);
log.InfoFormat("Removed job {0} from internal stacks", jobname);
MessageArgs msg = new MessageArgs(Enums.RequestType.Broadcast,
new string[] { "REMOVE_JOB", jobname });
Broadcast(msg);
log.InfoFormat("Sent message to client to remove job {0}.", jobname);
}
ResetUniqueJobInstance(jobname);
}
else
log.Warn("Null jobname passed to RemoveJob()");
}
catch (Exception ex){
log.Warn(ex);
}
return true;
}
/// <summary>
/// Background worker broadcasts status to NB and clients (see InitializeBackgroundWorkerBroadcastJobStatus)
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void threadJobStatusBroadcastRun(object sender, DoWorkEventArgs e)
{
while (Thread.CurrentThread.IsAlive)
{
MessageArgs msg = new MessageArgs(Enums.RequestType.Broadcast, guiStatusPkg);
Broadcast(msg);
string refreshInt = ConfigUtils.GetMetatagValue("*GUI_REFRESH_INTERVAL*");
if (refreshInt != null && refreshInt != "")
{
int ri = JOB_STATUS_REFRESH;
Int32.TryParse(refreshInt, out ri);
Thread.Sleep(ri);
}
else
Thread.Sleep(JOB_STATUS_REFRESH);
}
}
/////////////////////////////////////////////////////////////////////////////////////
// Scrollback
/////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// This hook is started before the item is ignored
/// </summary>
/// <param name="_IgnoreArgs"></param>
/// <returns></returns>
public virtual bool Hook_BeforeIgnore(MessageArgs _IgnoreArgs)
{
return true;
}
private void UbietyMessagesAllMessages(object sender, MessageArgs e)
{
State.Execute(e.Tag);
}
private void OnEmpireMessage(object sender, MessageArgs e)
{
SendMessage(new Message(String.Format("{0} ({1}{2})", e.Message.text, e.Message.nick, settings.empireAlias), EndPoint.Empiretv, EndPoint.SteamAdmin));
}
/// <summary>
/// Background worker broadcasts Status to NB and clients (see InitializeBackgroundWorkerBroadcastJobStatus)
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void threadJobStatusBroadcastRun(object sender, DoWorkEventArgs e)
{
while (Thread.CurrentThread.IsAlive)
{
guiStatusPkg[0] = guiJobStatus;
guiStatusPkg[1] = guiJobHistories;
MessageArgs msg = new MessageArgs(Enums.RequestType.Broadcast, guiStatusPkg);
Broadcast(msg);
string refreshInt = MetaTagReplacer.GetMetaTagValueFromPB("*GUI_REFRESH_INTERVAL*", GlobalConfig.GlobalParameters);
if (refreshInt != null && refreshInt != "")
{
int ri = JOB_STATUS_REFRESH;
Int32.TryParse(refreshInt, out ri);
Thread.Sleep(ri);
}
else
Thread.Sleep(JOB_STATUS_REFRESH);
}
}
protected void SendMessage(MessageArgs message)
{
Owner.EmitMessage(message);
}
protected void DoTemplateElement(TextWriter contentsStream, XmlNode node)
{
m_templateRootNode = node;
string sIcuNormalizationMode = XmlUtils.GetOptionalAttributeValue(m_templateRootNode, "normalization", "NFC");
if (sIcuNormalizationMode == "NFD")
m_eIcuNormalizationMode = Icu.UNormalizationMode.UNORM_NFD;
else
m_eIcuNormalizationMode = Icu.UNormalizationMode.UNORM_NFC;
string style = XmlUtils.GetOptionalAttributeValue(m_templateRootNode, "writingSystemAttributeStyle", WritingSystemAttrStyles.FieldWorks.ToString());
m_writingSystemAttrStyle = (WritingSystemAttrStyles) System.Enum.Parse(typeof(WritingSystemAttrStyles), style);
string sFormatOutput = XmlUtils.GetOptionalAttributeValue(m_templateRootNode, "stringFormatOutputStyle", StringFormatOutputStyle.None.ToString());
m_eStringFormatOutput = (StringFormatOutputStyle)System.Enum.Parse(typeof(StringFormatOutputStyle), sFormatOutput);
m_requireClassTemplatesForEverything = XmlUtils.GetBooleanAttributeValue(node,"requireClassTemplatesForEverything");
m_doUseBaseClassTemplatesIfNeeded = XmlUtils.GetBooleanAttributeValue(node, "doUseBaseClassTemplatesIfNeeded");
// kalpLoadForAllOfObjectClass is much slower in the presence of null data,
// especially for multiple vernacular and analysis writing systems! Use the faster
// policy if requested.
string sAutoloadPolicy = XmlUtils.GetOptionalAttributeValue(m_templateRootNode, "autoloadPolicy", String.Empty);
if (sAutoloadPolicy.ToLowerInvariant() == "readonly")
m_cache.VwOleDbDaAccessor.AutoloadPolicy = AutoloadPolicies.kalpLoadAllOfClassForReadOnly;
if (UpdateProgress != null)
UpdateProgress(this);
string sProgressMsgId = XmlUtils.GetOptionalAttributeValue(m_templateRootNode, "messageId");
if (!String.IsNullOrEmpty(sProgressMsgId) && SetProgressMessage != null)
{
MessageArgs ma = new MessageArgs();
ma.MessageId = sProgressMsgId;
ma.Max = XmlUtils.GetOptionalIntegerValue(m_templateRootNode, "progressMax", 20);
SetProgressMessage.Invoke(this, ma);
}
if (String.IsNullOrEmpty(m_sAuxiliaryFxtFile)) // don't recurse in Go() more than once.
ComputeAuxiliaryFilename(contentsStream, node);
DumpObject(contentsStream, m_rootObject, null);
}
private static void BroadcastMsg(MessageArgs message)
{
Object[] oo = message.PayloadBroadcast as Object[];
if (IsStatusMessage(message))
{
if (FormsManager.JobLauncher.RunningJobsCtl.isBusy == false)
FormsManager.JobLauncher.RunningJobsCtl.RefreshJobs(oo);
}
else if( IsRemoveJobMessage(message))
FormsManager.JobLauncher.RunningJobsCtl.RemoveJob(oo);
}
static void c_OnDataReceivedSuccessfully(object sender, MessageArgs e)
{
try
{
JObject msg = JObject.Parse(e.Message);
string msg_type = (string)msg["type"];
switch (msg_type)
{
case "wc_hello":
break;
case "wc_hello_response":
if (OnCreateConnectionCompleted != null)
OnCreateConnectionCompleted("CrunchCore", new ConnectionArgs(true));
break;
case "wc_in_queue":
// Do nothing.. Display waiting message to user
break;
case "wc_start_game":
WordGame.InitGame(500, 800);
StartGameMessage s = StartGameMessage.fromJSON(e.Message);
if (Int32.Parse(s.player_id) == 0)
{
Globals.PlayerIndex = 0;
//Globals.YourUsername
Globals.OpponentUsername = s.user2;
}
else
{
Globals.PlayerIndex = 1;
Globals.OpponentUsername = s.user1;
}
if (OnGameStart != null)
{
OnGameStart("CrunchCore", new RoutedEventArgs());
PhoneApplicationService.Current.ApplicationIdleDetectionMode = IdleDetectionMode.Disabled;
}
break;
case "wc_good_guess":
GoodGuessResponseMessage response = GoodGuessResponseMessage.fromJSON(e.Message);
WordGame.scoreYou = response.scoreYou;
WordGame.scoreOpponent = response.scoreOpponent;
if (OnScoreChange != null)
OnScoreChange("Crunch Core", new RoutedEventArgs());
if (OnGoodGuess != null)
OnGoodGuess("CrunchCore", new GoodGuessArgs(response));
break;
case "wc_bombed_guess":
BombedGuessResponseMessage bomb = BombedGuessResponseMessage.fromJSON(e.Message);
RoutedEventArgs args = new RoutedEventArgs();
WordGame.scoreYou = bomb.scoreYou;
WordGame.scoreOpponent = bomb.scoreOpponent;
if (OnBombed != null)
OnBombed("CrunchCore", new BombedArgs(bomb));
break;
case "wc_stop_game":
c.Disconnect();
JObject json = JObject.Parse(e.Message);
string reason = (String)json.Property("reason").Value;
if (OnGameEnd != null)
{
OnGameEnd("CrunchCore", new EventArgs());
}
break;
case "wc_high_scores":
HighScoresResponseMessage scoresResponse = HighScoresResponseMessage.fromJSON(e.Message);
if (OnHighScoresReturned != null)
OnHighScoresReturned("CrunchCore", new HighScoresArgs());
break;
case "wc_goodbye":
c.Disconnect();
if (OnError != null)
OnError("CrunchCore", new ErrorArgs((string)msg["reason"]));
break;
}
}
catch (Exception ex)
{
c.Disconnect();
if (OnError != null)
OnError("CrunchCore", new ErrorArgs(e.Message));
}
}
private void ProcessSearch(MessageArgs args)
{
List<string> results = new List<string>();
Regex rx = new Regex(SearEvArgs.Condition, RegexOptions.IgnoreCase);
// 課程名稱
if (SearchCourseName.Checked)
{
foreach (string key in _AllCourseDict.Keys)
{
if (rx.Match(_AllCourseDict[key].CourseName).Success)
if (!results.Contains(key))
results.Add(key);
}
}
// 科目名稱
if (SearchSubjectName.Checked)
{
foreach (string key in _AllCourseDict.Keys)
{
if (rx.Match(_AllCourseDict[key].SubjectName).Success)
if (!results.Contains(key))
results.Add(key);
}
}
// 科目類別
if (SearchSubjectType.Checked)
{
foreach (string key in _AllCourseDict.Keys)
{
if (rx.Match(_AllCourseDict[key].SubjectType).Success)
if (!results.Contains(key))
results.Add(key);
}
}
}
void VmRecievedMessage(object sender, MessageArgs e)
{
if (e.Message.GetType() == typeof(AbortMessage))
{
if (((AbortMessage)e.Message).Reason.Equals("ProfilerAborted"))
AskUserToEnableOrDisableProfiler();
}
}
public void SendMessage(MessageArgs message)
{
subscriber.SendMessage(message);
}
