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);
}
});
}