/// <summary> /// Initializes a new instance of the <see cref="AsyncTimeoutTimer"/> class. /// </summary> public AsyncTimeoutTimer() { timer = new System.Timers.Timer(); timer.AutoReset = false; timer.SynchronizingObject = new GenericSynchronizingObject(); context = new CallbackContext(); }
void CmBilling_OnBillingResult(string result) { Util.Log("BillingResult=" + result); string[] results = result.Split('|'); int id = 0; if(!int.TryParse(results[0], out id)) { Util.LogError("Billing result Error: " + result); return; } CallbackContext context = new CallbackContext(); for(int i = 0; i < this.callbackContexts.Count; i ++) { if(this.callbackContexts[i].Parameter.ID == id) { context = this.callbackContexts[i]; this.callbackContexts.RemoveAt(i); break; } } if(CmBillingAndroid.BillingResult.SUCCESS == results[1]) { context.Callback(BuyResult.Success, context.Parameter); return; } context.Callback(BuyResult.Failure, context.Parameter); }
public void OnReturn(CallbackContext context) { if (context.phase != InputActionPhase.Started) { return; } Return(); }
public void OnDodge(CallbackContext context) { Debug.Log("OnDodge ok"); if (combat == null || inputBlock || !context.performed) { return; } combat.Dodge(context.ReadValue <float>()); }
public void OnMove(CallbackContext context) { if (motor == null || inputBlock) { return; } move = context.ReadValue <Vector2>(); motor.SetMoveDirection(move); }
public void OnJump(CallbackContext context) { isJumping = context.performed; jumpActionExecute = isGrounded && isJumping; if (jumpActionExecute) { jumpTime = maxJumpTime; } }
private void LookAtMousePosition(CallbackContext ctx) { Vector3 mousePos = ctx.ReadValue <Vector2>(); Vector3 direction = mousePos - Camera.main.WorldToScreenPoint(transform.position); float angle = Mathf.Atan2(direction.y, direction.x) * Mathf.Rad2Deg; transform.rotation = Quaternion.AngleAxis(angle - 90, Vector3.forward); }
// What happens for each input press // These functions are called by the input system with context to what has happened with the input public void Interact(CallbackContext context) { // Checks if the input has been pressed if (context.performed && playerMovement != null) { // If true then call Interact function playerCombat.Interact(); } }
public void OnMove(CallbackContext movementContext) { if (playerMovement != null) { // Takes the input from object this script is attached to (PlayerInputController) playerMovement.SetInputVector(movementContext.ReadValue <Vector2>()); playerCombat.SetInputAimVector(movementContext.ReadValue <Vector2>()); } }
internal void Callback(object state) { CallbackContext context = (CallbackContext)state; context.result = context.policyWrapper.CheckErrors(context.hostName, context.certificate, context.chain, context.sslPolicyErrors); }
protected virtual void InputFire(CallbackContext ctx) { if (!isReloading && Time.timeScale == 1 && !disableControls && firePoint && shellPrefab && timeSinceLastShot < Time.time) { HandleFireShot(); weaponSourceSound.Play(); timeSinceLastShot = Time.time + timeBetweenShots; } }
public void Aim(CallbackContext value) { Vector2 aimVal = value.ReadValue <Vector2>(); if (aimVal != Vector2.zero) { aim = aimVal; } }
public void OnPrimaryAttackInput(CallbackContext context) { if (context.started) { PrimaryAttackInput = true; _primaryInputStartTime = Time.time; PrimaryAttackClickCount = PrimaryAttackClickCount + 1 > _maxClickCount ? _startClickCount : PrimaryAttackClickCount + 1; } }
public void OnMove(CallbackContext ctx) { Vector2 direction = ctx.ReadValue <Vector2>(); Debug.Log("OnMove"); Debug.Log(direction); animator.SetFloat("vertical", direction.y); animator.SetFloat("horizontal", direction.x); }
private void OnTab(CallbackContext ctx) { if (m_hints == null || m_hints.Count < 1) { return; } m_input = m_hints[m_index].Split(new char[] { ' ' })[0]; m_cursorIndex = m_input.Length; }
public void EscapedInput(CallbackContext context) { if (!context.performed || !fader.visible) { return; } Hide(); }
internal void Callback(object state) { CallbackContext context = (CallbackContext)state; context.result = m_ValidationCallback(context.request, context.certificate, context.chain, context.sslPolicyErrors); }
/// <summary> /// Growl通知の発行を行うメソッド /// </summary> /// <param name="notification">通知用データ</param> /// <param name="context">コールバック処理をしたい場合に指定</param> public void RunNotification(Notification notification, CallbackContext context = null) { if (notification == null) { throw new ArgumentNullException("notification"); } Connector.Notify(notification, context); }
public void OnMove(CallbackContext context) { if (context.control.device.deviceId == inputDevice.deviceId) { Vector2 val = context.ReadValue <Vector2>(); if (Mathf.Abs(val.x) < 0.5f) { return; } if ((context.startTime - startTime) < 0.25f) { return; } switch (currentSlot) { case PlayerID.NP: if (val.x > 0) { if (joiner.TryJoin(PlayerID.Player2, inputDevice)) { ToggleState(PlayerID.Player2); startTime = context.startTime; } } else { if (joiner.TryJoin(PlayerID.Player1, inputDevice)) { ToggleState(PlayerID.Player1); startTime = context.startTime; } } break; case PlayerID.Player1: if (val.x > 0) { ToggleState(PlayerID.NP); startTime = context.startTime; joiner.RemovePlayer(inputDevice); } break; case PlayerID.Player2: if (val.x < 0) { ToggleState(PlayerID.NP); startTime = context.startTime; joiner.RemovePlayer(inputDevice); } break; } } }
public void NextDialogue(CallbackContext context) { if (!context.performed) { return; } currentStripIndex = currentStripIndex + 1 > currentStrip.dialogueList.Count - 1 ? 0 : currentStripIndex + 1; DisplayDialogue(currentStrip.dialogueList[currentStripIndex]); }
/// <summary> /// Handles WASD input and saves the input for FixedUpdate to handle /// </summary> /// <param name="context">Information on what was pushed by the player</param> internal void OnMove(CallbackContext context) { //Will not do anything if the window is not focused if (!Application.isFocused) { return; } m_InputDirection = context.canceled ? Vector3.zero : (Vector3)context.ReadValue <Vector2>(); }
public void SwitchCombatMode(CallbackContext context) { if (context.ReadValueAsButton() == true && context.performed == false) { if (hasGun) { ChangeCombatMode(!combatController.IsRanged); } } }
public void DoSwing(CallbackContext ctx) { switch (ctx.phase) { case InputActionPhase.Performed: case InputActionPhase.Canceled: rawSwing = -ctx.ReadValue <float>(); break; } }
public void DoToggleLight(CallbackContext ctx) { switch (ctx.phase) { case InputActionPhase.Performed: lightEnabled = !lightEnabled; lantern.gameObject.SetActive(lightEnabled); break; } }
/// <summary> /// 打开用户详情 /// </summary> /// <param name="callback"></param> public void HandleForUserDetails(CallbackContext callback) { if (!isActiveAndEnabled) { return; } UIGameUserDetails uiGameUserDetails = UIHandler.Instance.OpenUIAndCloseOther <UIGameUserDetails>(UIEnum.GameUserDetails); uiGameUserDetails.ui_ViewSynthesis.SetDataType(ItemsSynthesisTypeEnum.Self); }
public void OnLook(CallbackContext context) { if (movement == null) { return; } var look = context.ReadValue <Vector2>(); mouse.SetLook(look); }
public void OnMove(CallbackContext context) { if (movement == null) { return; } var move = context.ReadValue <Vector2>(); movement.SetMovement(move); }
private void MovePerformed(CallbackContext context) { var raw = context.ReadValue <Vector2>(); var m = InputFiltering.ApplyDeadzone(raw, innerDeadzone, outerDeadzone); var h = InputFiltering.ApplyDeadzone(raw.x0(), innerDeadzone, outerDeadzone); Movement = m.normalized; MovementHorizontal = h.normalized; }
private void OnJoinGame(CallbackContext ctx) { if (InputDeviceManager.AddPlayer(ctx.control.device)) { int playerNumber = InputDeviceManager.GetPlayerNumber(ctx.control.device); playerProps[playerNumber - 1].SetActive(true); playerTexts[playerNumber - 1].SetActive(false); Debug.Log("Player " + playerNumber + " joined game"); } }
private void OnMiddleMouseClick(CallbackContext ctx) { if (ctx.ReadValueAsButton()) { IsToolBarSelected = !IsToolBarSelected; toolController.selectedTool?.ShowToolInfo(); ShowToolBarHighlight(); //StartCoroutine(ResetColor(img)); } }
public void OnVisible(CallbackContext context) { if (game_state == 1) { if (player != null) { player.SetVisible(context.ReadValue <float>()); } } }
public void DoRun(CallbackContext ctx) { switch (ctx.phase) { case InputActionPhase.Performed: case InputActionPhase.Canceled: running = ctx.ReadValueAsButton(); break; } }
public void ActionBoundToDefaultSyncContext_Invoked_Executes() { using (CallbackContext context = new CallbackContext()) using (ManualResetEvent evt = new ManualResetEvent(false)) { var action = context.Bind(() => { evt.Set(); }, new SynchronizationContext(), false); action(); bool signalled = evt.WaitOne(100); Assert.IsTrue(signalled, "Action did not run"); } }
internal bool Invoke(string hostName, ServicePoint servicePoint, X509Certificate certificate, WebRequest request, X509Chain chain, SslPolicyErrors sslPolicyErrors) { PolicyWrapper policyWrapper = new PolicyWrapper(this.m_CertificatePolicy, servicePoint, request); if (this.m_Context == null) { return policyWrapper.CheckErrors(hostName, certificate, chain, sslPolicyErrors); } ExecutionContext executionContext = this.m_Context.CreateCopy(); CallbackContext state = new CallbackContext(policyWrapper, hostName, certificate, chain, sslPolicyErrors); ExecutionContext.Run(executionContext, new ContextCallback(this.Callback), state); return state.result; }
public void Action_InvokedAfterContextDispose_DoesNotExecute() { bool sawAction = false; Action action = null; using (CallbackContext context = new CallbackContext()) { action = context.Bind(() => { sawAction = true; }); } action(); Assert.IsFalse(sawAction, "Invalid action did execute"); }
public void BoundAsyncAction_Invoked_ExecutesSynchronized() { int sawActionThread = Thread.CurrentThread.ManagedThreadId; using (CallbackContext context = new CallbackContext()) using (ActionThread thread = new ActionThread()) { thread.Start(); // Capture the thread's SynchronizationContext SynchronizationContext actionThreadSyncContext = thread.DoGet(() => { return SynchronizationContext.Current; }); var action = context.AsyncBind(() => { sawActionThread = Thread.CurrentThread.ManagedThreadId; }, actionThreadSyncContext); action(); thread.Join(); Assert.AreEqual(thread.ManagedThreadId, sawActionThread, "Bound action was not synchronized"); } }
public void BoundAsyncAction_Invoked_DecrementsSyncContextOperationCount() { bool sawOperationCompleted = false; using (CallbackContext context = new CallbackContext()) using (ActionThread thread = new ActionThread()) { thread.Start(); // Capture the thread's SynchronizationContext SynchronizationContext actionThreadSyncContext = thread.DoGet(() => { return SynchronizationContext.Current; }); var syncContext = new LoggingSynchronizationContext(actionThreadSyncContext) { OnOperationCompleted = () => { sawOperationCompleted = true; } }; var action = context.AsyncBind(() => { }, syncContext, false); action(); thread.Join(); Assert.IsFalse(sawOperationCompleted, "Context decremented operation count"); } }
public void InvalidBoundSyncedFunc_Invoked_DoesNotExecute() { int sawActionThread = Thread.CurrentThread.ManagedThreadId; using (CallbackContext context = new CallbackContext()) using (ActionThread thread = new ActionThread()) { thread.Start(); // Capture the thread's SynchronizationContext and signal this thread when it's captured. SynchronizationContext actionThreadSyncContext = thread.DoGet(() => { return SynchronizationContext.Current; }); var action = context.Bind(() => { sawActionThread = Thread.CurrentThread.ManagedThreadId; return 13; }, actionThreadSyncContext, false); context.Reset(); int result = action(); Assert.AreEqual(Thread.CurrentThread.ManagedThreadId, sawActionThread, "Invalid action should not run"); } }
public void CallbackContext_AfterInvokingInvalidAction_IsInvalid() { using (CallbackContext context = new CallbackContext()) { var action = context.Bind(() => { }); context.Reset(); action(); Assert.IsTrue(context.Invalidated, "Bound action should be invalid"); } }
internal bool Invoke(string hostName, ServicePoint servicePoint, X509Certificate certificate, WebRequest request, X509Chain chain, SslPolicyErrors sslPolicyErrors) { PolicyWrapper policyWrapper = new PolicyWrapper(m_CertificatePolicy, servicePoint, (WebRequest) request); if (m_Context == null) { return policyWrapper.CheckErrors(hostName, certificate, chain, sslPolicyErrors); } else { ExecutionContext execContext = m_Context.CreateCopy(); CallbackContext callbackContext = new CallbackContext(policyWrapper, hostName, certificate, chain, sslPolicyErrors); ExecutionContext.Run(execContext, Callback, callbackContext); return callbackContext.result; } }
public void ValidAction_Invoked_Executes() { bool sawAction = false; using (CallbackContext context = new CallbackContext()) { var action = context.Bind(() => { sawAction = true; }); action(); Assert.IsTrue(sawAction, "Bound action did not execute"); } }
public void InvalidFunc_Invoked_DoesNotExecute() { bool sawAction = false; using (CallbackContext context = new CallbackContext()) { var action = context.Bind(() => { sawAction = true; return 13; }); context.Reset(); int result = action(); Assert.IsFalse(sawAction, "Invalid action did execute"); } }
public void CallbackContext_WithInvokedFunc_IsNotInvalid() { using (CallbackContext context = new CallbackContext()) { var action = context.Bind(() => { return 13; }); int result = action(); Assert.IsFalse(context.Invalidated, "Bound action should be valid"); } }
public void CallbackContext_WithInvokedAction_IsNotInvalid() { using (CallbackContext context = new CallbackContext()) { var action = context.Bind(() => { }); action(); Assert.IsFalse(context.Invalidated, "Bound action should be valid"); } }
public void CallbackContext_Reset_InvalidatesAllFuncs() { bool sawAction1 = false; bool sawAction2 = false; using (CallbackContext context = new CallbackContext()) { var action1 = context.Bind(() => { sawAction1 = true; return 13; }); var action2 = context.Bind(() => { sawAction2 = true; return 17; }); context.Reset(); int result1 = action1(); int result2 = action2(); Assert.IsFalse(sawAction1, "Invalid action did execute"); Assert.IsFalse(sawAction2, "Invalid action did execute"); } }
public void CallbackContext_ResetAfterBindingFunc_IsInvalid() { using (CallbackContext context = new CallbackContext()) { var action = context.Bind(() => { return 13; }); context.Reset(); Assert.IsTrue(context.Invalidated, "Bound action should be invalid"); } }
public void CallbackContext_BindingFuncWithDefaultSyncContext_ThrowsInvalidOperationException() { using (CallbackContext context = new CallbackContext()) { var action = context.Bind(() => { return 13; }, new SynchronizationContext()); } }
public void InvalidBoundSyncedFunc_Invoked_DoesSync() { bool sawSync = false; using (CallbackContext context = new CallbackContext()) using (ActionThread thread = new ActionThread()) { thread.Start(); // Capture the thread's SynchronizationContext and signal this thread when it's captured. SynchronizationContext actionThreadSyncContext = thread.DoGet(() => { return SynchronizationContext.Current; }); var syncContext = new LoggingSynchronizationContext(actionThreadSyncContext) { OnPost = () => { sawSync = true; }, OnSend = () => { sawSync = true; } }; var action = context.Bind(() => { return 13; }, syncContext, false); context.Reset(); int result = action(); Assert.IsTrue(sawSync, "Context did not use SyncContext for sync"); } }
public void InvalidBoundSyncedFunc_Invoked_ReturnsDefault() { using (CallbackContext context = new CallbackContext()) using (ActionThread thread = new ActionThread()) { thread.Start(); // Capture the thread's SynchronizationContext and signal this thread when it's captured. SynchronizationContext actionThreadSyncContext = thread.DoGet(() => { return SynchronizationContext.Current; }); var action = context.Bind(() => { return 13; }, actionThreadSyncContext, false); context.Reset(); int result = action(); Assert.AreEqual(0, result, "Invalid Func returned a non-default value"); } }
public void Func_InvokedAfterContextDispose_DoesNotExecute() { bool sawAction = false; Func<int> action = null; using (CallbackContext context = new CallbackContext()) { action = context.Bind(() => { sawAction = true; return 13; }); } int result = action(); Assert.IsFalse(sawAction, "Invalid action did execute"); }
public void InvalidFunc_Invoked_ReturnsDefault() { using (CallbackContext context = new CallbackContext()) { var action = context.Bind(() => { return 13; }); context.Reset(); int result = action(); Assert.AreEqual(default(int), result, "Invalid func had a non-default return value"); } }
public void Func_InvokedAfterContextDispose_ReturnsDefault() { Func<int> action = null; using (CallbackContext context = new CallbackContext()) { action = context.Bind(() => { return 13; }); } int result = action(); Assert.AreEqual(0, result, "Invalid func had a non-default return value"); }
public void BoundSyncedAction_Invoked_UsesSyncContext() { bool sawSync = false; using (CallbackContext context = new CallbackContext()) using (ActionThread thread = new ActionThread()) { thread.Start(); // Capture the thread's SynchronizationContext SynchronizationContext actionThreadSyncContext = thread.DoGet(() => { return SynchronizationContext.Current; }); var syncContext = new LoggingSynchronizationContext(actionThreadSyncContext) { OnPost = () => { sawSync = true; }, OnSend = () => { sawSync = true; } }; var action = context.Bind(() => { }, syncContext, false); action(); Assert.IsTrue(sawSync, "Context did not use SyncContext for sync"); } }
public void InvalidBoundObjectsyncedFunc_Invoked_DoesNotExecute() { int sawActionThread = Thread.CurrentThread.ManagedThreadId; using (CallbackContext context = new CallbackContext()) { var syncObject = new FakeFuncSynchronizingObject(true); var action = context.Bind(() => { sawActionThread = Thread.CurrentThread.ManagedThreadId; return 13; }, syncObject); context.Reset(); int result = action(); Assert.AreEqual(Thread.CurrentThread.ManagedThreadId, sawActionThread, "Bound action was executed"); } }
internal bool Invoke(object request, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors) { if (m_Context == null) { return m_ValidationCallback(request, certificate, chain, sslPolicyErrors); } else { ExecutionContext execContext = m_Context.CreateCopy(); CallbackContext callbackContext = new CallbackContext(request, certificate, chain, sslPolicyErrors); ExecutionContext.Run(execContext, Callback, callbackContext); return callbackContext.result; } }
public void InvalidBoundObjectsyncedFunc_Invoked_ReturnsDefault() { using (CallbackContext context = new CallbackContext()) { var syncObject = new FakeFuncSynchronizingObject(true); var action = context.Bind(() => { return 13; }, syncObject); context.Reset(); int result = action(); Assert.AreEqual(0, result, "Invalid func returned non-default value"); } }
private void TriggerCallback(CallbackContext context) { context.Error = _lastWriteError; ThreadPool.QueueUserWorkItem(obj => { var c = (CallbackContext)obj; c.Callback(c.Error, c.State); }, context); }
public void InvalidBoundObjectsyncedFunc_Invoked_SynchronizesWithSyncObject() { using (CallbackContext context = new CallbackContext()) { var syncObject = new FakeFuncSynchronizingObject(true); var action = context.Bind(() => { return 13; }, syncObject); context.Reset(); int result = action(); Assert.IsTrue(syncObject.sawInvoke, "Bound action did not run through synchronizing object"); } }
/// <summary> /// Initializes a new instance of the <see cref="Timer"/> class, binding to <see cref="SynchronizationContext.Current">SynchronizationContext.Current</see>. /// </summary> /// <example>The following code sample demonstrates how to construct a single-shot Timer, start it, and handle the <see cref="Elapsed"/> event: /// <code source="..\..\Source\Examples\DocumentationExamples\Timer\SingleShot.cs"/> /// </example> public Timer() { // Capture the synchronization context synchronizationContext = SynchronizationContext.Current; if (synchronizationContext == null) { synchronizationContext = new SynchronizationContext(); } // Verify that the synchronization context is synchronized SynchronizationContextRegister.Verify(synchronizationContext.GetType(), SynchronizationContextProperties.Synchronized); // Create the context for timer callbacks context = new CallbackContext(); }
public void BoundSyncedFunc_Invoked_IncrementsSyncContextOperationCount() { bool sawOperationStarted = false; using (CallbackContext context = new CallbackContext()) using (ActionThread thread = new ActionThread()) { thread.Start(); // Capture the thread's SynchronizationContext SynchronizationContext actionThreadSyncContext = thread.DoGet(() => { return SynchronizationContext.Current; }); var syncContext = new LoggingSynchronizationContext(actionThreadSyncContext) { OnOperationStarted = () => { sawOperationStarted = true; } }; var action = context.Bind(() => { return 13; }, syncContext, false); int result = action(); Assert.IsFalse(sawOperationStarted, "Context incremented operation count"); } }