private static bool Equal(EventHandler?key, Delegate?otherKey)
{
return(ReferenceEquals(key?.Target, otherKey?.Target) &&
ReferenceEquals(key?.GetMethodInfo(), otherKey?.GetMethodInfo()));
}
public static void FastStart(this EventHandler?Handler, object Sender, EventArgs e) => Handler?.Invoke(Sender, e);
private static int GetHashCode(EventHandler?key)
{
return(key is null
? _implementationDelegateType.GetHashCode()
: HashCode.Combine(key.Target, key.GetMethodInfo()));
}
public static void SafeInvoke(this EventHandler?handler, object?sender) => SafeInvoke(handler, sender, EventArgs.Empty);
/// <inheritdoc/>
public void RaisePlaylistChanged()
{
EventHandler?handler = PlaylistChanged;
handler?.Invoke(this, null);
}
internal ClosableStream(Stream stream, EventHandler?onClose) : base(stream)
{
_onClose = onClose;
}
/// <summary>
/// Starts the job.
/// </summary>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public async Task RunAsync(CancellationToken cancellationToken)
{
JobState = JobState.Running;
if (CancellationToken.CanBeCanceled)
{
CancellationTokenSource?cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, CancellationToken);
cancellationToken = cts.Token;
cts.Dispose();
cts = null;
}
JobStage = JobStage.Downloading;
Exception? exception = null;
bool canceled = false;
EventHandler?handler = JobStarted;
handler?.Invoke(this, null);
DownloadContainer? downloadContainer = null;
List <TargetResult> completedTargets = new List <TargetResult>(_targets.Length);
List <SongTarget> pendingTargets = new List <SongTarget>(_targets.Length);
foreach (SongTarget?target in _targets)
{
SongState songState = await target.CheckSongExistsAsync(Song).ConfigureAwait(false);
if (songState != SongState.Wanted)
{
completedTargets.Add(new TargetResult(target, songState, true, null));
}
else
{
pendingTargets.Add(target);
}
}
try
{
cancellationToken.ThrowIfCancellationRequested();
if (string.IsNullOrEmpty(Song.Key) && Song.Hash != null && Song.Hash.Length > 0)
{
SongInfoResponse?result = await WebUtils.SongInfoManager.GetSongByHashAsync(Song.Hash, cancellationToken).ConfigureAwait(false);
if (result.Success)
{
Song.Key = result.Song?.Key;
}
}
if (pendingTargets.Count > 0)
{
_downloadJob.JobProgressChanged += _downloadJob_JobProgressChanged;
DownloadResult = await _downloadJob.RunAsync(cancellationToken).ConfigureAwait(false);
downloadContainer = DownloadResult.DownloadContainer;
if (DownloadResult.Exception != null)
{
throw DownloadResult.Exception;
}
if (downloadContainer != null)
{
_stageIndex = 1;
ReportProgress(JobProgress.CreateDownloadCompletion(CurrentProgress, DownloadResult));
JobStage = JobStage.TransferringToTargets;
// Report progress on the targets that do not want the song.
foreach (TargetResult?targetResult in completedTargets)
{
_stageIndex++;
ReportProgress(JobProgress.CreateTargetCompletion(CurrentProgress, targetResult));
}
// Transfer to targets that do want the song.
completedTargets.AddRange(await TransferToTargets(pendingTargets, downloadContainer, cancellationToken).ConfigureAwait(false));
}
else
{
Logger.log?.Warn($"DownloadResult has no exception, but returned a null DownloadContainer.");
}
}
else
{
DownloadResult = new DownloadResult(null, DownloadResultStatus.Skipped, 0);
_stageIndex = 1;
_downloadJob_JobProgressChanged(this, new DownloadJobProgressChangedEventArgs(DownloadJobStatus.Finished));
JobStage = JobStage.TransferringToTargets;
foreach (TargetResult?targetResult in completedTargets)
{
_stageIndex++;
ReportProgress(JobProgress.CreateTargetCompletion(CurrentProgress, targetResult));
}
}
TargetResult[] failedTargets = completedTargets.Where(t => !t.Success).ToArray();
if (failedTargets.Length > 0)
{
Exception?firstException = failedTargets.FirstOrDefault(t => t.Exception != null)?.Exception;
if (firstException != null)
{
throw firstException;
}
}
TargetResults = completedTargets.ToArray();
}
catch (OperationCanceledException ex)
{
if (TargetResults == null && completedTargets.Count > 0)
{
TargetResults = completedTargets.ToArray();
}
else
{
TargetResults = Array.Empty <TargetResult>();
}
canceled = true;
exception = ex;
ReportProgress(JobProgress.CreateFromFault(JobProgressType.Cancellation, JobStage, CurrentProgress));
JobState = JobState.Cancelled;
}
catch (Exception ex)
{
if (TargetResults == null && completedTargets.Count > 0)
{
TargetResults = completedTargets.ToArray();
}
else
{
TargetResults = Array.Empty <TargetResult>();
}
exception = ex;
JobState = JobState.Error;
ReportProgress(JobProgress.CreateFromFault(JobProgressType.Error, JobStage, CurrentProgress));
}
finally
{
JobStage = JobStage.Finishing;
try
{
downloadContainer?.Dispose();
}
catch { }
if (DownloadResult == null)
{
// TODO: What was this for?
}
FinishJob(canceled, exception);
JobFinishedAsyncCallback?asyncCallback = JobFinishedAsyncCallback;
if (asyncCallback != null)
{
await asyncCallback(Result).ConfigureAwait(false);
}
}
}
private static void Slide(FrameworkElement parentContainer, FrameworkElement ctrl, int ms, bool slideIn, EventHandler?onCompleted = null)
{
var storyboard = new Storyboard();
var duration = TimeSpan.FromMilliseconds(ms);
var height = ctrl.ActualHeight;
var animation = new ThicknessAnimation
{
Duration = new Duration(duration),
FillBehavior = FillBehavior.Stop
};
if (slideIn)
{
animation.To = ctrl.Margin;
animation.From =
new Thickness(ctrl.Margin.Left, ctrl.Margin.Top + height, ctrl.Margin.Right, ctrl.Margin.Bottom);
}
else
{
animation.From = ctrl.Margin;
animation.To =
new Thickness(ctrl.Margin.Left, ctrl.Margin.Top + height, ctrl.Margin.Right, ctrl.Margin.Bottom);
}
Storyboard.SetTargetName(animation, ctrl.Name);
Storyboard.SetTargetProperty(animation, new PropertyPath(FrameworkElement.MarginProperty));
storyboard.Children.Add(animation);
storyboard.Children.Add(CreateFadeAnimation(ctrl, ms, slideIn, onCompleted));
storyboard.Begin(parentContainer);
}
public static void DropDown(FrameworkElement parentContainer, FrameworkElement ctrl, int ms, EventHandler?onCompleted = null)
{
var storyboard = new Storyboard();
var duration = TimeSpan.FromMilliseconds(ms);
var height = ctrl.ActualHeight;
var animation = new ThicknessAnimation
{
Duration = new Duration(duration),
FillBehavior = FillBehavior.Stop,
From = new Thickness(ctrl.Margin.Left, ctrl.Margin.Top - height, ctrl.Margin.Right, ctrl.Margin.Bottom),
To = new Thickness(ctrl.Margin.Left, ctrl.Margin.Top, ctrl.Margin.Right, ctrl.Margin.Bottom)
};
Storyboard.SetTargetName(animation, ctrl.Name);
Storyboard.SetTargetProperty(animation, new PropertyPath(FrameworkElement.MarginProperty));
storyboard.Children.Add(animation);
storyboard.Children.Add(CreateFadeAnimation(ctrl, ms, true, onCompleted));
storyboard.Begin(parentContainer);
}
private static void Fade(FrameworkElement parentContainer, FrameworkElement ctrl, int ms, bool fadeIn, EventHandler?onCompleted = null)
{
var storyboard = new Storyboard();
storyboard.Children.Add(CreateFadeAnimation(ctrl, ms, fadeIn, onCompleted));
storyboard.Begin(parentContainer);
}
private static void Fade(FrameworkElement parentContainer, FrameworkElement?[] ctrls, int ms, bool fadeIn, EventHandler?onCompleted = null)
{
var storyboard = new Storyboard();
foreach (var ctrl in ctrls)
{
if (ctrl != null)
{
storyboard.Children.Add(CreateFadeAnimation(ctrl, ms, fadeIn));
}
}
if (onCompleted != null)
{
storyboard.Completed += onCompleted;
}
storyboard.Begin(parentContainer);
}
private static DoubleAnimation CreateFadeAnimation(FrameworkElement ctrl, int ms, bool fadeIn, EventHandler?onCompleted = null)
{
var duration = TimeSpan.FromMilliseconds(ms);
var animation = new DoubleAnimation
{
From = fadeIn ? 0.0 : 1.0,
To = fadeIn ? 1.0 : 0.0,
Duration = new Duration(duration)
};
Storyboard.SetTargetName(animation, ctrl.Name);
Storyboard.SetTargetProperty(animation, new PropertyPath(UIElement.OpacityProperty));
if (onCompleted != null)
{
animation.Completed += onCompleted;
}
return(animation);
}
private const int SUPPORTED = 0x01; // tagOLECMDF.OLECMDF_SUPPORTED
/// <summary>
/// Initializes a new instance of <see cref='System.ComponentModel.Design.MenuCommand'/>.
/// </summary>
public MenuCommand(EventHandler?handler, CommandID?command)
{
_execHandler = handler;
CommandID = command;
_status = SUPPORTED | ENABLED;
}
public static Task InvokeAsync(this EventHandler?handler, object sender, EventArgs e) => handler is null ? Task.CompletedTask : Task.Run(() => handler(sender, e));
/// <summary>
/// Maps handler for detachment.
/// </summary>
/// <param name="handler">Handler to map.</param>
/// <returns>Mapped handler</returns>
public TImplementationDelegate?TryMapForDetachment(EventHandler?handler)
{
if (handler == null || !_lookup.TryGetValue(handler, out var ctx))
{
return(default);
public static Storyboard Flash(FrameworkElement parentContainer, FrameworkElement ctrl, EventHandler?onCompleted = null)
{
var anim = CreateFadeAnimation(ctrl, FadeMs, true, onCompleted);
anim.AutoReverse = true;
anim.RepeatBehavior = RepeatBehavior.Forever;
var storyboard = new Storyboard();
storyboard.Children.Add(anim);
storyboard.Begin(parentContainer, true);
return(storyboard);
}
private static OleMenuCommand CreateMenuCommand([NotNull] IMenuCommandService mcs, int cmdId, EventHandler?invokeHandler)
{
var menuCommandId = new CommandID(GuidList.guidResXManager_VSIXCmdSet, cmdId);
var menuCommand = new OleMenuCommand(invokeHandler, menuCommandId);
mcs.AddCommand(menuCommand);
return(menuCommand);
}
public static void FlashIn(FrameworkElement parentContainer, FrameworkElement ctrl, EventHandler?onCompleted = null)
{
var storyboard = new Storyboard();
var anim = CreateFadeAnimation(ctrl, 350, false, onCompleted);
anim.AutoReverse = true;
anim.RepeatBehavior = new RepeatBehavior(3.0);
storyboard.Children.Add(anim);
storyboard.Begin(parentContainer);
}
public static void Reset()
{
EventHandlerCount = 0;
event1 = null;
}
public static void SlideOut(FrameworkElement parentContainer, FrameworkElement ctrl, int ms = 500, EventHandler?onCompleted = null)
{
Slide(parentContainer, ctrl, ms, false, onCompleted);
}
public static void SafeInvoke(this EventHandler?handler) => SafeInvoke(handler, null, EventArgs.Empty);
public static void FadeIn(FrameworkElement parentContainer, FrameworkElement[] ctrls, EventHandler?onCompleted = null)
{
Fade(parentContainer, ctrls, FadeMs, true, onCompleted);
}
public static void SafeInvoke(this EventHandler?handler, EventArgs e) => SafeInvoke(handler, null, e);
public static void FadeOut(FrameworkElement parentContainer, FrameworkElement ctrl, EventHandler?onCompleted = null)
{
Fade(parentContainer, ctrl, FadeMs, false, onCompleted);
}
public static void Raise(this EventHandler?handler, object sender)
{
handler?.Invoke(sender, EventArgs.Empty);
}
public static IAsyncResult?StartAsync(this EventHandler?Handler, object Sender, EventArgs e, AsyncCallback?CallBack = null, object?State = null) => Handler is null ? null : ((Action)(() => Handler.Invoke(Sender, e))).BeginInvoke(CallBack, State);
