public void prepareSkinAsync(string carId, string skinChecksum, string skinUrl, IJavascriptCallback callback) { ActionExtension.InvokeInMainThreadAsync(async() => { var car = await CarsManager.Instance.GetByIdAsync(carId); if (car == null) { callback?.ExecuteAsync($"Car with ID={carId} is missing"); return; } var cacheDirectory = FilesStorage.Instance.GetTemporaryDirectory("RaceU", "Skins", carId); var destinationFilename = Path.Combine(cacheDirectory, skinChecksum); if (File.Exists(destinationFilename)) { callback?.ExecuteAsync(null); return; } try { var data = await HttpClientHolder.Get().GetByteArrayAsync(skinUrl); await FileUtils.WriteAllBytesAsync(destinationFilename, data); } catch (Exception e) { callback?.ExecuteAsync($"Failed to download skin: {e.Message}"); return; } callback?.ExecuteAsync(null); }); }
private static bool OnPaste() { if (VisualExtension.IsInputFocused()) { return(false); } try { if (Clipboard.ContainsData(DataFormats.FileDrop)) { var data = Clipboard.GetFileDropList().OfType <string>().ToList(); ActionExtension.InvokeInMainThreadAsync(() => ProcessArguments(data, true)); return(true); } if (Clipboard.ContainsData(DataFormats.UnicodeText)) { var list = Clipboard.GetText().ToLines(); if (list.Length > 0 && list.All(x => !string.IsNullOrWhiteSpace(x))) { ActionExtension.InvokeInMainThreadAsync(() => ProcessArguments(list, true)); return(true); } } } catch (Exception e) { Logging.Warning(e); } return(false); }
public void JoinRequest(DiscordJoinRequest request, CancellationToken cancellation, Action <DiscordJoinRequestReply> callback) { ActionExtension.InvokeInMainThreadAsync(async() => { try { var dialog = new DiscordJoinRequestDialog(request); cancellation.Register(() => ActionExtension.InvokeInMainThreadAsync(() => { if (!dialog.IsLoaded) { dialog.Loaded += (s, e) => dialog.Close(); } else if (dialog.IsVisible) { try { dialog.Close(); } catch { // ignored } } })); switch (await dialog.ShowAndWaitAsync()) { case MessageBoxResult.Yes: callback(DiscordJoinRequestReply.Yes); break; case MessageBoxResult.No: callback(DiscordJoinRequestReply.No); break; } } catch (Exception e) { Logging.Warning(e); } }); }
public static void Reload() { _configs.Clear(); _featureSupported.Clear(); _installed.Reset(); ActionExtension.InvokeInMainThreadAsync(() => { Reloaded?.Invoke(null, EventArgs.Empty); }); }
private async Task UpdateList() { if (!_locallyLoaded) { ReloadLocalList(); } var list = await DownloadAndParseList(); if (list == null) { return; } ActionExtension.InvokeInMainThreadAsync(() => { foreach (var plugin in list) { if (plugin.IsObsolete || plugin.IsHidden && !SettingsHolder.Common.DeveloperMode) { continue; } var local = GetById(plugin.Id); if (local != null) { List.Remove(local); plugin.InstalledVersion = local.InstalledVersion; } List.Add(plugin); } ListUpdated?.Invoke(this, EventArgs.Empty); }); }
public void startOnlineRace(string ip, int port, int httpPort, string password, IJavascriptCallback callback = null) { if (_car == null) { throw new Exception("Car is not set"); } if (_track == null) { throw new Exception("Track is not set"); } ActionExtension.InvokeInMainThreadAsync(async() => { var result = await GameWrapper.StartAsync(new Game.StartProperties { BasicProperties = new Game.BasicProperties { CarId = _car.Id, TrackId = _track.MainTrackObject.Id, TrackConfigurationId = _track.LayoutId, CarSkinId = _carSkin?.Id ?? _car.SelectedSkin?.Id ?? "" }, ModeProperties = new Game.OnlineProperties { Guid = SteamIdHelper.Instance.Value, ServerIp = ip, ServerPort = port, ServerHttpPort = httpPort, RequestedCar = _car.Id, Password = password } }); callback?.ExecuteAsync(result?.IsNotCancelled); }).Ignore(); }
private void ApplyDynamicBackground([CanBeNull] string filename, double opacity = 0.5) { ActionExtension.InvokeInMainThreadAsync(() => { try { if (filename == null) { DisposeHelper.Dispose(ref _dynamicBackground); if (FancyBackgroundManager.Instance.Enabled) { FancyBackgroundManager.Instance.Recreate(this); } else { ClearValue(BackgroundContentProperty); } } else { var animatedBackground = Regex.IsMatch(filename, @"\.(?:avi|flv|gif|m(?:4[pv]|kv|ov|p[4g])|og[vg]|qt|webm|wmv)$", RegexOptions.IgnoreCase) ? filename : null; var staticBackground = animatedBackground == null ? filename : Regex.Replace(filename, @"\.\w+$", @".jpg"); _dynamicBackground?.Dispose(); BackgroundContent = _dynamicBackground = new DynamicBackground { Animated = animatedBackground, Static = staticBackground, Opacity = opacity }; } } catch (Exception e) { Logging.Error(e); } }); }
public static void MarkForFutherRemoval(string skinDirectory) { ActionExtension.InvokeInMainThreadAsync(() => { _pauseCleanUp = DateTime.Now + TimeSpan.FromMinutes(2d); ValuesStorage.Storage.SetStringList(_key, ValuesStorage.Storage.GetStringList(_key).Union(new[] { skinDirectory })); }); }
private static async Task <ArgumentHandleResult> ProcessGoogleSpreadsheetsLocale(string id, [CanBeNull] string locale, bool around) { if (string.IsNullOrWhiteSpace(id)) { throw new InformativeException(ToolsStrings.Common_IdIsMissing); } var url = around ? $@"{InternalUtils.MainApiDomain}/u/around?id={id}" : $@"https://docs.google.com/spreadsheets/d/{id}/export?format=xlsx&authuser=0"; await Task.Run(() => { if (File.Exists(LocaleHelper.GetGoogleSheetsFilename())) { FileUtils.Recycle(LocaleHelper.GetGoogleSheetsFilename()); FileUtils.TryToDelete(LocaleHelper.GetGoogleSheetsFilename()); } }); await LoadRemoteFileToNew(url, LocaleHelper.GetGoogleSheetsFilename()); SettingsHolder.Locale.LoadUnpacked = true; if (locale != null) { SettingsHolder.Locale.LocaleName = locale; } ActionExtension.InvokeInMainThreadAsync(() => { if (ModernDialog.ShowMessage(AppStrings.CustomLocalesUpdated_Message, AppStrings.CustomLocalesUpdated_Title, MessageBoxButton.YesNo) == MessageBoxResult.Yes) { WindowsHelper.RestartCurrentApplication(); } }); return(ArgumentHandleResult.Successful); }
private void OnPatchUpdaterPropertyChanged(object sender, PropertyChangedEventArgs e) { if (e.PropertyName == nameof(PatchUpdater.NothingAtAll)) { ActionExtension.InvokeInMainThreadAsync(() => UpdateContentTranslate(true)); } ActionExtension.InvokeInMainThreadAsync(() => Model.OnPatchUpdaterChanged(sender, e)); }
private void OnFrameLoadStart(object sender, FrameLoadStartEventArgs e) { if (e.Frame.IsMain) { ActionExtension.InvokeInMainThreadAsync(() => { Navigating?.Invoke(this, PageLoadingEventArgs.Indetermitate); }); } }
private void ApplyTexture(Action <IPaintShopRenderer> action) { ActionExtension.InvokeInMainThreadAsync(() => { var renderer = _renderer; if (renderer != null) { action(_renderer); } }); }
private async void Dispatch() { if (_dispatched) return; _dispatched = true; await Task.Delay(300); ActionExtension.InvokeInMainThreadAsync(() => { UpdateInternal?.Invoke(this, new EventArgs()); _dispatched = false; }); }
private void SetThemeDynamicBackgroundListener() { UpdateThemeDynamicBackground(); AppearanceManager.Current.PropertyChanged += (sender, args) => { if (args.PropertyName == nameof(AppearanceManager.CurrentThemeDictionary)) { ActionExtension.InvokeInMainThreadAsync(UpdateThemeDynamicBackground); } }; }
private void RaiseKeyDown(int value) { ActionExtension.InvokeInMainThreadAsync(() => { var e = new KeyboardEventArgs(value); PreviewKeyDown?.Invoke(this, e); if (!e.Handled) { KeyDown?.Invoke(this, e); } }); }
public void Set(TaskbarState state, double value) { ActionExtension.InvokeInMainThreadAsync(() => { if (state != _state || value != _value) { _state = state; _value = value; TaskbarService.Update(); } }); }
public void uploadCarSkinLiveryIconAsync(string carId, string skinId, string endpoint, IJavascriptCallback callback) { ActionExtension.InvokeInMainThreadAsync(async() => { var skin = await GetSkinAsync(carId, skinId, callback); if (skin == null) { return; } await UploadBinaryDataAsync(endpoint, () => FileUtils.ReadAllBytesAsync(skin.LiveryImage), callback); }); }
public void Report(AsyncProgressEntry value) { var now = DateTime.Now; if ((now - _lastReport).TotalMilliseconds < 20d) { return; } _lastReport = now; ActionExtension.InvokeInMainThreadAsync(() => { _callback.Invoke(TrimProgressMessage(value, _trimStart)); }); }
private static void TryToGetLanList(ItemAddCallback <ServerInformation> foundCallback, IEnumerable <int> ports, [CanBeNull] Progress progress, CancellationToken cancellation) { var addresses = GetBroadcastAddresses().ToList(); // ReSharper disable PossibleMultipleEnumeration if (progress != null) { progress.Total = ports.Count() * addresses.Count; progress.Current = 0; } var entries = addresses.SelectMany(x => ports.Select(y => new { BroadcastIp = x, Port = y })); // ReSharper enable PossibleMultipleEnumeration try { Parallel.ForEach(entries, new ParallelOptions { CancellationToken = cancellation, MaxDegreeOfParallelism = (Environment.ProcessorCount - 1).Clamp(1, 4) }, (entry, ipLoopState) => { cancellation.ThrowIfCancellationRequested(); var found = BroadcastPing(entry.BroadcastIp, entry.Port); if (found != null) { try { var information = TryToGetInformationDirect(found.Ip, found.Port); if (information == null) { return; } information.IsLan = true; ActionExtension.InvokeInMainThreadAsync(() => foundCallback(information)); } catch (Exception e) { Logging.Warning(e); } } if (progress != null) { Interlocked.Increment(ref progress.Current); } }); } catch (Exception e) when(e.IsCancelled()) { } }
public static void Reload() { _active = null; _configs.Clear(); _featureSupported.Clear(); _installed.Reset(); _audioDescriptionsSet = false; ActionExtension.InvokeInMainThreadAsync(() => { Reloaded?.Invoke(null, EventArgs.Empty); InvalidateFeatures(); GetExtraAudioLevels(); }); }
// RaceU API, v1 // ReSharper disable InconsistentNaming public void getCarSkinsAsync(string carId, IJavascriptCallback callback) { ActionExtension.InvokeInMainThreadAsync(async() => { var car = await CarsManager.Instance.GetByIdAsync(carId); if (car == null) { callback?.ExecuteAsync($"Car with ID={carId} is missing", null); return; } await car.SkinsManager.EnsureLoadedAsync(); callback?.ExecuteAsync(null, car.EnabledOnlySkins.Select(x => x.Id).ToArray()); }); }
private static void NotifyInner([NotNull] string message, [CanBeNull] string commentary, [CanBeNull] Exception exception, [CanBeNull] IEnumerable <NonfatalErrorSolution> solutions, bool show, string m, string p, int l) { if (exception is UserCancelledException) { return; } var i = exception as InformativeException; if (i != null) { message = i.Message; commentary = i.SolutionCommentary; exception = i.InnerException; } Logging.Write('•', $"{message}:\n{exception}", m, p, l); var entry = new NonfatalErrorEntry(message, commentary, exception, solutions ?? new NonfatalErrorSolution[0]); ActionExtension.InvokeInMainThreadAsync(() => { try { var active = _active; _active = true; if (show && !active && DateTime.Now - _previous > ErrorsTimeout) { ErrorMessage.Show(entry); } if (Instance.Errors.Count > ErrorsLimit) { Instance.Errors.RemoveAt(Instance.Errors.Count - 1); } Instance.Errors.Insert(0, entry); if (entry.Unseen) { Instance.UpdateUnseen(); } } catch (Exception e) { Logging.Error(e); } finally { _active = false; _previous = DateTime.Now; } }); }
public void Join(string secret) { ActionExtension.InvokeInMainThreadAsync(async() => { try { var j = JObject.Parse(Decrypt(secret, JoinKey)); var ip = (string)j["i"]; var port = (int)j["p"]; var password = (string)j["w"]; Logging.Debug($"{ip}:{port}"); await ArgumentsHandler.JoinInvitation(ip, port, password); } catch (Exception e) { NonfatalError.Notify("Can’t join invitation", e); } }); }
private void Player_StateChanged(object sender, xZune.Vlc.ObjectEventArgs <MediaState> e) { if (e.Value == MediaState.Playing && !_playing) { _playing = true; ActionExtension.InvokeInMainThreadAsync(() => { Started?.Invoke(this, EventArgs.Empty); }); } else if (e.Value == MediaState.Ended && _playing) { ActionExtension.InvokeInMainThreadAsync(() => { Ended?.Invoke(this, EventArgs.Empty); }); } }
/// <summary> /// Show a toast. /// </summary> /// <param name="title">Ex.: “Something Happened”</param> /// <param name="message">Ex.: “This and that. Without dot in the end”</param> /// <param name="icon">Uri to some icon</param> /// <param name="click">Click action</param> public static void Show(string title, string message, [NotNull] Uri icon, Action click = null) { ActionExtension.InvokeInMainThreadAsync(() => { if (!_winToasterIsNotAvailable && !OptionFallbackMode) { try { ShowWin8Toast(title, message, icon, click); return; } catch { Logging.Warning("Windows 8+ toasts aren’t available"); _winToasterIsNotAvailable = true; } } ShowFallback(title, message, click); }); }
internal override void PageInject(string url, Collection <string> toInject, Collection <KeyValuePair <string, string> > replacements) { ActionExtension.InvokeInMainThreadAsync(() => PageStart?.Invoke(this, EventArgs.Empty)); if (IsThemeBright // GetStyle() is called before PageInject(), so it’s a good way to know if browser supports // transparent background or not || StyleProvider?.TransparentBackgroundSupported == false) { replacements.Add(new KeyValuePair <string, string>(@"<body style=""background:none;"">", @"<body>")); } base.PageInject(url, toInject, replacements); toInject.Add(@"<script>!function(){ window.addEventListener('load', e => { window.external.SetDriverNames(JSON.stringify([].map.call(document.querySelectorAll('#shoutbox [data-username]'), i => i.getAttribute('data-username')))); }); }()</script>"); toInject.Add(GetSrsFix()); }
public override void Set(IniFile file) { ActionExtension.InvokeInMainThreadAsync(() => { var s = Stopwatch.StartNew(); try { var trackId = file["RACE"].GetNonEmpty("TRACK"); var configurationId = file["RACE"].GetNonEmpty("CONFIG_TRACK"); var track = TracksManager.Instance.GetLayoutById(trackId ?? string.Empty, configurationId); if (track == null) { return; } var outline = track.OutlineImage; var outlineCropped = Path.Combine(Path.GetDirectoryName(track.OutlineImage) ?? "", "outline_cropped.png"); if (!File.Exists(outline) || File.Exists(outlineCropped)) { return; } var image = BetterImage.LoadBitmapSource(outline); var size = new Size(256, 256); var result = new BetterImage { Width = 256, Height = 256, Source = image.ImageSource, CropTransparentAreas = true }; result.Measure(size); result.Arrange(new Rect(size)); result.ApplyTemplate(); result.UpdateLayout(); var bmp = new RenderTargetBitmap(256, 256, 96, 96, PixelFormats.Pbgra32); bmp.Render(result); File.WriteAllBytes(outlineCropped, bmp.ToBytes(ImageFormat.Png)); } catch (Exception e) { Logging.Error(e); } finally { Logging.Write($"Time taken: {s.Elapsed.TotalMilliseconds:F2} ms"); } }); }
/*public static bool SetText(string text) { * if (!OpenClipboard(IntPtr.Zero)) { * return false; * } * * var global = Marshal.StringToHGlobalUni(text); * SetClipboardData(CF_UNICODETEXT, global); * CloseClipboard(); * return true; * }*/ public static void SetText(string text) { ActionExtension.InvokeInMainThreadAsync(() => { Exception exception = null; for (var i = 0; i < 5; i++) { try { Clipboard.SetText(text); return; } catch (Exception e) { Thread.Sleep(10); exception = e; } } NonfatalError.NotifyBackground("Can’t copy text", "No access to clipboard.", exception); }); }
public static void OnDrop(object sender, DragEventArgs e) { if (!e.Data.GetDataPresent(DataFormats.FileDrop) && !e.Data.GetDataPresent(DataFormats.UnicodeText)) { return; } if (Application.Current?.Windows.OfType <Window>().SelectMany(VisualTreeHelperEx.FindVisualChildren <WebBlock>) .Any(x => x.IsMouseOver) == true) { return; } (sender as IInputElement)?.Focus(); var data = e.GetInputFiles().ToList(); ActionExtension.InvokeInMainThreadAsync(() => e.Handled ? Task.Delay(0) : ProcessArguments(data, true)); }
public void installCspBuildAsync(int build, IJavascriptCallback callback) { ActionExtension.InvokeInMainThreadAsync(async() => { var versionInfo = PatchUpdater.Instance.Versions.FirstOrDefault(x => x.Build == build); if (versionInfo == null) { callback?.ExecuteAsync($"Version {build} is missing", null); return; } if (await PatchUpdater.Instance.InstallAsync(versionInfo, CancellationToken.None)) { callback?.ExecuteAsync(null, PatchHelper.GetInstalledBuild().As(-1)); } else { callback?.ExecuteAsync("Failed to install an update", null); } }); }