private async void Run(object parameter)
{
if (RunHandler != null)
{
RunHandler.Invoke();
}
}
public ZoneSpecification(
HandleUncaughtErrorHandler handleUncaughtError = null,
RunHandler run = null,
RunUnaryHandler runUnary = null,
RunBinaryHandler runBinary = null,
RegisterCallbackHandler registerCallback = null,
RegisterUnaryCallbackHandler registerUnaryCallback = null,
RegisterBinaryCallbackHandler registerBinaryCallback = null,
ErrorCallbackHandler errorCallback = null,
ScheduleMicrotaskHandler scheduleMicrotask = null,
CreateTimerHandler createTimer = null,
CreatePeriodicTimerHandler createPeriodicTimer = null,
PrintHandler print = null,
ForkHandler fork = null)
{
this.handleUncaughtError = handleUncaughtError;
this.run = run;
this.runUnary = runUnary;
this.runBinary = runBinary;
this.registerCallback = registerCallback;
this.registerUnaryCallback = registerUnaryCallback;
this.registerBinaryCallback = registerBinaryCallback;
this.errorCallback = errorCallback;
this.scheduleMicrotask = scheduleMicrotask;
this.createTimer = createTimer;
this.createPeriodicTimer = createPeriodicTimer;
this.print = print;
this.fork = fork;
}
private static GameHandlerBase Setup()
{
var runHandler = new RunHandler();
runHandler.SetSuccessor(new StopHandler());
return runHandler;
}
public static ZoneSpecification from(
ZoneSpecification other,
HandleUncaughtErrorHandler handleUncaughtError = null,
RunHandler run = null,
RunUnaryHandler runUnary = null,
RunBinaryHandler runBinary = null,
RegisterCallbackHandler registerCallback = null,
RegisterUnaryCallbackHandler registerUnaryCallback = null,
RegisterBinaryCallbackHandler registerBinaryCallback = null,
ErrorCallbackHandler errorCallback = null,
ScheduleMicrotaskHandler scheduleMicrotask = null,
CreateTimerHandler createTimer = null,
CreatePeriodicTimerHandler createPeriodicTimer = null,
PrintHandler print = null,
ForkHandler fork = null)
{
return(new ZoneSpecification(
handleUncaughtError: handleUncaughtError ?? other.handleUncaughtError,
run: run ?? other.run,
runUnary: runUnary ?? other.runUnary,
runBinary: runBinary ?? other.runBinary,
registerCallback: registerCallback ?? other.registerCallback,
registerUnaryCallback:
registerUnaryCallback ?? other.registerUnaryCallback,
registerBinaryCallback:
registerBinaryCallback ?? other.registerBinaryCallback,
errorCallback: errorCallback ?? other.errorCallback,
scheduleMicrotask: scheduleMicrotask ?? other.scheduleMicrotask,
createTimer: createTimer ?? other.createTimer,
createPeriodicTimer: createPeriodicTimer ?? other.createPeriodicTimer,
print: print ?? other.print,
fork: fork ?? other.fork
));
}
public void AssignSystemsReferences()
{
quirkManager = FindObjectOfType <QuirkManager>();
quirkPickerUI = FindObjectOfType <QuirkPickerUI>();
screenFadeHandler = FindObjectOfType <ScreenFadeHandler>();
runHandler = FindObjectOfType <RunHandler>();
}
public object run(Zone zone, ZoneCallback f)
{
var implementation = _delegationTarget._run;
_Zone implZone = implementation.zone;
RunHandler handler = implementation.function;
return(handler(implZone, async_._parentDelegate(implZone), zone, f));
}
public override object run(ZoneCallback f)
{
var implementation = _run;
ZoneDelegate parentDelegate = async_._parentDelegate(implementation.zone);
RunHandler handler = implementation.function;
return(handler(implementation.zone, parentDelegate, this, f));
}
public void AddTimeOfDayInterrupt(string name, Time time, RunHandler OnRun)
{
if (TimeOfDayInterruptExists(name))
{
throw new Exception("Task already exists");
}
todTasks.Add(new TimeOfDayTask(name, time, OnRun));
}
public RunManager(RestClient client, Args args, string fullPathReportName)
{
_client = client;
_logger = client.Logger;
_args = args;
_fullPathReportName = fullPathReportName;
_runHandler = new RunHandlerFactory().Create(client, args.RunType, args.EntityId);
_pollHandler = new PollHandlerFactory().Create(client, args.RunType, args.EntityId);
}
private void Start()
{
unitSelection = FindObjectOfType <UnitSelection>();
handler = FindObjectOfType <RunHandler>();
if (unit == handler.curHero)
{
unitSelection.CreateDisplay(unit, this.GetComponent <Button>());
}
}
/// <summary>
/// 通知主线程操作已结束运行
/// </summary>
/// <param name="info">显示的信息</param>
private void EndRun(int nPatCount, string szCheckType)
{
if (m_parent == null || m_parent.IsDisposed)
{
return;
}
try
{
RunHandler handler = m_parent.EndStartRun;
m_parent.Invoke(handler, nPatCount, szCheckType);
}
catch
{
}
}
/// <summary>
/// 如果存在互斥体，则打开互斥窗体，否则调用 RunMethod 方法创建新的窗体
/// </summary>
/// <param name="runMethod">回调函数</param>
public static void ShowMutexOnly(RunHandler runMethod)
{
bool b;
var m = new Mutex(true, ApplicationName, out b);
if (b)
{
m.ReleaseMutex();
runMethod();
}
else
{
IntPtr hWnd = FindWindow(null, ApplicationName);
HandleRunningInstance(hWnd);
}
}
private void RunCallback(IAsyncResult result)
{
RunHandler rh = result.AsyncState as RunHandler;
try
{
rh.EndInvoke(result);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Deployment Framework for BizTalk: Exception", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
finally
{
SetFree();
}
}
public void AddCyclicInterrupt(string name, uint timeInterval, RunHandler OnRun)
{
if (CyclicInterruptExists(name))
{
throw new Exception("Task already exists");
}
if (!cyclicTasks.ContainsKey(timeInterval)) // this time interval doesn't exist, add it
{
CyclicTaskLocker locker = new CyclicTaskLocker();
cyclicTasks.Add(timeInterval, locker);
locker.timerId = GLib.Timeout.Add(timeInterval, locker.OnTaskTimeout);
}
//add the task to the time interval
cyclicTasks[timeInterval].tasks.Add(new CyclicTask(name, OnRun));
}
internal void ExecuteBuild(string exePath, string arguments)
{
if (SetBusy() == 1)
{
return;
}
OutputWindow ow = _applicationObject.ToolWindows.OutputWindow;
OutputWindowPane owP = GetOutputWindowPane();
owP.Clear();
owP.Activate();
ow.Parent.Activate();
RunHandler rh = new RunHandler(Run);
AsyncCallback callback = new AsyncCallback(RunCallback);
rh.BeginInvoke(exePath, arguments, callback, rh);
}
/// <summary>
/// 如果存在互斥体，则打开互斥窗体，否则调用 RunMethod 方法创建新的窗体
/// </summary>
/// <param name="RunMethod">回调函数</param>
/// <param name="args">需要向互斥窗体传递的参数</param>
public static void ShowMutexOnly(RunHandler RunMethod, string[] args)
{
bool b;
Mutex m = new Mutex(true, ApplicationName, out b);
if (b)
{
m.ReleaseMutex();
RunMethod(args);
}
else
{
IntPtr hWnd = FindWindow(null, ApplicationName);
if (hWnd != IntPtr.Zero)
{
if (args.Length > 0 && !string.IsNullOrEmpty(args[0]))
{
SendCopyData(hWnd, args[0]);
}
}
HandleRunningInstance(hWnd);
}
}
private void Awake()
{
FindObjectOfType <SoundManager>().Play("Door Open");
runHandler = FindObjectOfType <RunHandler>();
}
internal _RunNullaryZoneFunction(_Zone zone, RunHandler function)
{
this.zone = zone;
this.function = function;
}
public CyclicTask(string name, RunHandler OnRun)
{
this.name = name;
this.OnRun = OnRun;
}
public Command(RunHandler onRun)
{
Run = onRun;
}
public TimeOfDayTask(string name, Time time, RunHandler OnRun) : base(name, OnRun)
{
this.time = time;
}
public Bot()
{
runHandler = new RunHandler();
}
public RunnableRelay(RunHandler runHandler)
{
_runHandler = runHandler ?? throw new ArgumentNullException(nameof(runHandler));
}
