protected override async Task PushNext(OrderChange obj)
{
var ch = obj.Clone();
await base.PushNext(obj);
var e = new OrderChangeEventArgs(ch);
switch (ch.Type)
{
case OrderEventType.Canceled:
Canceled?.Invoke(this, e);
break;
case OrderEventType.Filled:
Filled?.Invoke(this, e);
break;
case OrderEventType.Match:
Match?.Invoke(this, e);
break;
case OrderEventType.Open:
Open?.Invoke(this, e);
break;
case OrderEventType.Update:
Update?.Invoke(this, e);
break;
}
}
// ダウンロード完了
private void OnDownloadCompleted(Task <DownloadOperation> prevTask)
{
if (prevTask.IsFaulted)
{
Debug.WriteLine("キャッシュ失敗");
Failed?.Invoke(this, EventArgs.Empty);
return;
}
Debug.WriteLine("キャッシュ完了");
if (prevTask.Result != null)
{
var op = DownloadOperation;
if (op.Progress.Status == BackgroundTransferStatus.Completed)
{
if (op.Progress.TotalBytesToReceive == op.Progress.BytesReceived)
{
Debug.WriteLine("キャッシュ済み: " + op.ResultFile.Name);
Completed?.Invoke(this, EventArgs.Empty);
}
else
{
Debug.WriteLine("キャッシュキャンセル: " + op.ResultFile.Name);
Canceled?.Invoke(this, EventArgs.Empty);
}
}
else
{
Debug.WriteLine($"キャッシュ失敗: {op.ResultFile.Name} ");
Failed?.Invoke(this, EventArgs.Empty);
}
}
}
private void BtnCancel_Click(object sender, RoutedEventArgs e)
{
Canceled?.Invoke(this, e);
var btnCancel = sender as Button;
btnCancel.IsEnabled = false;
}
void OnPayloadReceived(object sender, Misc.PayloadReceivedEventArgs e)
{
var msg = e.Payload;
if (msg.EventType == "TIMER")
{
if (msg.Event == "CALL_START")
{
Started?.Invoke(this, new EventArgs());
}
if (msg.Event == "CALL_START_PAUSE")
{
Paused?.Invoke(this, new EventArgs());
}
if (msg.Event == "CALL_END_PAUSE")
{
Unpaused?.Invoke(this, new EventArgs());
}
if (msg.Event == "CALL_END")
{
Stopped?.Invoke(this, new EventArgs());
}
if (msg.Event == "CALL_CANCEL")
{
Canceled?.Invoke(this, new EventArgs());
}
}
}
public CustomDialog()
{
InitializeComponent();
// Background pressed
var tgr = new TapGestureRecognizer {
NumberOfTapsRequired = 1
};
tgr.Tapped += async(sender, args) =>
{
if (this.CloseWhenBackgroundIsClicked)
{
await PopupNavigation.Instance.PopAsync();
}
};
var views = new View[] { rlBackground, rlBackground2, rlBackground3, rlBackground4 };
foreach (var view in views)
{
view.GestureRecognizers.Add(tgr);
}
button.Clicked += async(sender, args) =>
{
await PopupNavigation.Instance.PopAsync();
Canceled?.Invoke(this, new EventArgs());
};
}
//private:
void ThreadProc()
{
try
{
bool done = DoWork();
State = JobState_t.Finished;
if (done)
{
Succeeded?.Invoke(this);
}
else
{
Canceled?.Invoke(this);
}
}
catch (Exception ex)
{
State = JobState_t.Finished;
Aborted?.Invoke(this, ex);
}
Aborted = null;
Canceled = Succeeded = null;
}
void OnClosing(object sender, ClosingEventArgs e)
{
lock (_lock)
{
// allow the dialog to close if the form is closed
if (_isClosed)
{
return;
}
// do not close if cannot or aborted
if (!CanCancel || AbortCanceling())
{
e.Ignore = true;
return;
}
// flag
_isCanceled = true;
// abort
if (_jobThread != null)
{
Pfz.Threading.SafeAbort.Abort(_jobThread, 4000, 2000, 1000, true);
}
// notify
Canceled?.Invoke(this, null);
}
}
internal void OnCanceled(object sender, ListingProgressArgs args)
{
ErrorMessages.Add(string.Format("Listing canceled: {0}", args.Exception.Message));
if (Canceled != null)
{
Canceled.Invoke(sender, args);
}
}
private void _viewModel_Canceled(string message)
{
if (!string.IsNullOrEmpty(message))
{
MessageBox.Show(message);
}
Canceled?.Invoke(message);
}
public CollectionRenameView()
{
InitializeComponent();
textBox_newCollectionName.TextChanged += (s, a) => CollectionNameChanged?.Invoke(this, EventArgs.Empty);
button_rename.Click += (s, a) => Submited?.Invoke(this, EventArgs.Empty);
button_cancel.Click += (s, a) => Canceled?.Invoke(this, EventArgs.Empty);
}
void OnDismissed(object sender, EventArgs e)
{
if (!IsAccepted)
{
Canceled?.Invoke(this, EventArgs.Empty);
}
Unrealize();
}
public void FireCanceledEvent(object source)
{
if (!canceledEventFired)
{
Canceled?.Invoke(source, new EventArgs.AsyncTaskEventArgs(this));
canceledEventFired = true;
}
}
private void OnCancelClicked(object sender, EventArgs e)
{
OnCancel();
TaskPaneArgs args = new TaskPaneArgs();
Canceled?.Invoke(this, args);
Visible = args.KeepOpen;
}
private void PART_NegativeButton_Click(object sender, RoutedEventArgs e)
{
WrappedDialog.Invoke(() =>
{
IsCanceled = true;
Canceled?.Invoke(this, EventArgs.Empty);
WrappedDialog.PART_NegativeButton.IsEnabled = false;
});
}
public override void ViewDidDisappear(bool animated)
{
base.ViewDidDisappear(animated);
if ((IsBeingDismissed || IsMovingFromParentViewController) && !_finishedPickingAssets)
{
Canceled?.Invoke(this, EventArgs.Empty);
}
}
private void FinishCommand_Execute()
{
if (!IsCanceled)
{
TryRunApplication();
}
Canceled?.Invoke();
}
public void Dismiss(object sender, EventArgs args)
{
// Explicitly unregister observers because we cannot predict when the GC cleans up
Unregister();
Canceled?.Invoke(this, EventArgs.Empty);
PresentingViewController.DismissViewController(true, null);
}
private void Abort()
{
if (WrappedDialog.IsCancelable)
{
WrappedDialog.PART_NegativeButton.IsEnabled = false;
IsCanceled = true;
Canceled?.Invoke(this, EventArgs.Empty);
}
}
internal async void Cancel(CoreDispatcher uiDispatcher)
{
using (var releaser = await _Lock.LockAsync())
{
_IsRunning = false;
_IsLastTaskCompleted = false;
}
Canceled?.Invoke(this, this);
}
public void Cancel()
{
var tsk = TokenSource;
if (tsk != null && !tsk.IsCancellationRequested)
{
tsk.Cancel();
Canceled?.Invoke(this);
}
}
internal void OnCanceled(object sender, TransferFileProgressArgs args)
{
RemoveActiveTransfer(args.FilePath);
ErrorMessages.Add(string.Format("{0} canceled: {1}", args.FilePath, args.Exception.Message));
if (Canceled != null)
{
Canceled.Invoke(sender, args);
}
if (Monitor != null)
{
Monitor.TransferCanceled(this, args);
}
}
public void Cancel()
{
int refund = paidCost.ManaValue;
if (castingState == CastingState.CardCast)
{
Canceled?.Invoke(new CastingEventArgs(stagedCard, refund));
}
else if (castingState == CastingState.Ability)
{
Canceled?.Invoke(new CastingEventArgs(stagedCard, stagedAbility, refund));
}
cleanup();
}
/// <inheritdoc/>
protected override void OnClosing(CancelEventArgs e)
{
e.Cancel = true;
if (_shouldSave)
{
Saved?.Invoke(this, EventArgs.Empty);
}
else
{
Canceled?.Invoke(this, EventArgs.Empty);
}
_shouldSave = false;
Hide();
}
public void Cancel()
{
var notify = false;
lock (lockHandle)
{
if (!IsCanceled)
{
IsCanceled = true;
notify = true;
}
}
if (notify)
{
Canceled?.Invoke(this, EventArgs.Empty);
}
}
/// <inheritdoc/>
protected override void OnClosing(CancelEventArgs e)
{
// Hide instead of closing the window
e.Cancel = true;
if (_shouldSave)
{
this.Publish(EditMessage.AcceptEdits);
Saved?.Invoke(this, EventArgs.Empty);
}
else
{
this.Publish(EditMessage.CancelEdits);
Canceled?.Invoke(this, EventArgs.Empty);
}
Hide();
}
protected sealed override void ExecuteTask(CancellationToken token)
{
try
{
SynchronizedInvoke(token);
}
catch (Exception ex)
{
if (ex.IsExceptionType <OperationCanceledException>())
{
Canceled?.Invoke(this, new EventArgs());
}
throw;
}
finally
{
_handle.Set();
}
}
//private:
void ThreadProc()
{
State = State_t.Running;
try
{
DoWork();
State = State_t.Finished;
Succeeded?.Invoke(this);
}
catch (ThreadAbortException)
{
Thread.ResetAbort();
State = State_t.Finished;
Canceled?.Invoke(this);
}
catch (Exception ex)
{
State = State_t.Finished;
Aborted?.Invoke(this, ex);
}
}
private void CancelButton_Click(object sender, RoutedEventArgs e)
{
Canceled?.Invoke(this, EventArgs.Empty);
}
private void OnButton_CancelOnClick(object s, EventArgs a)
{
ActiveControl = textBox_newCollectionName;
Canceled?.Invoke(this, EventArgs.Empty);
}
private void OnCanceled(EventArgs e)
{
Canceled?.Invoke(this, e);
}
