/// <summary>
/// Renames a given replay and refreshes the list
/// </summary>
/// <param name="preview"></param>
/// <param name="newText"></param>
/// <returns></returns>
public async Task <string> RenameFile(ReplayPreview preview, string newText)
{
if (preview == null)
{
throw new ArgumentNullException(nameof(preview));
}
// Get the full replay object, it contains more information
var replay = FileResults[preview.Location];
// Ask the file manager to rename the replay
var error = _fileManager.RenameReplay(replay, newText);
// If the request returned nothing, it worked
if (error == null)
{
await ReloadReplayList().ConfigureAwait(false);
} // User entered nothing, change message
else if (error == "{EMPTY ERROR}")
{
error = Application.Current.TryFindResource("RenameFlyoutEmptyError") as string;
}
else if (error == "{NOT FOUND ERROR}")
{
error = Application.Current.TryFindResource("RenameFlyoutNotFoundError") as string;
}
// Return error
return(error);
}
/// <summary>
/// Renames a given replay and refreshes the list
/// </summary>
/// <param name="preview"></param>
/// <param name="newText"></param>
/// <returns></returns>
public string RenameFile(ReplayPreview preview, string newText)
{
if (preview == null)
{
throw new ArgumentNullException(nameof(preview));
}
// Get the full replay object, it contains more information
var replay = FileResults[preview.Location];
// Ask the file manager to rename the replay
var error = _fileManager.RenameReplay(replay, newText);
// User entered nothing, change message
if (error == "{EMPTY ERROR}")
{
error = Application.Current.TryFindResource("RenameFlyoutEmptyError") as string;
}
else if (error == "{NOT FOUND ERROR}")
{
error = Application.Current.TryFindResource("RenameFlyoutNotFoundError") as string;
}
else // Success
{
// Change the displayed data to the new name
preview.DisplayName = newText;
}
return(error);
}
public ReplayPreview CreateReplayPreview(FileResult file)
{
if (file == null)
{
throw new ArgumentNullException(nameof(file));
}
ReplayPreview previewModel = new ReplayPreview(file.ReplayFile,
file.FileInfo.CreationTime,
SettingsManager.Settings.PlayerMarkerStyle,
SettingsManager.Settings.RenameAction,
file.IsNewFile);
previewModel.IsSupported = SettingsManager.Executables.DoesVersionExist(previewModel.GameVersion);
foreach (var bluePlayer in previewModel.BluePreviewPlayers)
{
bluePlayer.Marker = KnownPlayers.FirstOrDefault(x => x.Name.Equals(bluePlayer.PlayerName, StringComparison.OrdinalIgnoreCase));
}
foreach (var redPlayer in previewModel.RedPreviewPlayers)
{
redPlayer.Marker = KnownPlayers.FirstOrDefault(x => x.Name.Equals(redPlayer.PlayerName, StringComparison.OrdinalIgnoreCase));
}
return(previewModel);
}
public MainWindow(RiZhi log, SettingsManager settingsManager, RequestManager requests, FileManager files, ReplayPlayer player)
{
InitializeComponent();
_log = log;
_settingsManager = settingsManager;
_requests = requests;
_files = files;
_player = player;
_lastSelection = null;
Dispatcher.UnhandledException += (object sender, DispatcherUnhandledExceptionEventArgs e) =>
{
_log.Error(e.Exception.ToString());
_log.WriteLog();
};
var context = new MainWindowViewModel(_files, _requests, _settingsManager, _player, _log);
this.DataContext = context;
// Decide to show welcome window
context.ShowWelcomeWindow();
context.ShowMissingReplayFoldersMessageBox();
}
public async Task DeleteReplayFile(ReplayPreview preview)
{
if (preview == null)
{
throw new ArgumentNullException(nameof(preview));
}
_fileManager.DeleteFile(FileResults[preview.Location]);
await ReloadReplayList().ConfigureAwait(false);
}
private async void ReplayListView_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
if (!(this.DataContext is MainWindowViewModel context))
{
return;
}
if (!(sender is System.Windows.Controls.ListView replayList))
{
return;
}
if (!(replayList.SelectedItem is ReplayPreview previewModel))
{
return;
}
// Deselect the last selected item
if (_lastSelection != null && _lastSelection.IsSelected)
{
_lastSelection.IsSelected = false;
}
previewModel.IsSelected = true;
_lastSelection = previewModel;
FileResult replayFile = context.FileResults[previewModel.Location];
ReplayDetail replayDetail = new ReplayDetail(replayFile, previewModel);
ReplayDetailControl detailControl = this.FindName("DetailView") as ReplayDetailControl;
detailControl.DataContext = replayDetail;
(detailControl.FindName("BlankContent") as Grid).Visibility = Visibility.Hidden;
(detailControl.FindName("ReplayContent") as Grid).Visibility = Visibility.Visible;
await(this.DataContext as MainWindowViewModel).LoadItemThumbnails(replayDetail).ConfigureAwait(true);
// See if tab control needs to update runes:
if ((detailControl.FindName("DetailTabControl") as TabControl).SelectedIndex == 1)
{
await context.LoadRuneThumbnails(replayDetail).ConfigureAwait(true);
}
}
public void ShowExportReplayDataWindow(ReplayPreview preview)
{
_log.Information($"Showing Export Dialog...");
if (preview == null)
{
throw new ArgumentNullException(nameof(preview));
}
var exportContext = new ExportContext()
{
Replays = new ReplayFile[] { FileResults[preview.Location].ReplayFile },
Markers = KnownPlayers.ToList()
};
var exportDialog = new ExportReplayDataWindow()
{
Top = App.Current.MainWindow.Top + 50,
Left = App.Current.MainWindow.Left + 50,
DataContext = exportContext,
};
exportDialog.ShowDialog();
}
public async Task <Process> PlayReplay(ReplayPreview preview)
{
_log.Information($"Playing replay...");
if (preview == null)
{
throw new ArgumentNullException(nameof(preview));
}
var process = await _player.PlayReplay(preview.Location).ConfigureAwait(true);
// if process is null, replay failed to play for whatever reason
if (process != null)
{
preview.IsPlaying = true;
// add event handler for when the replay stops
process.Exited += (object processSender, System.EventArgs processEventArgs) =>
{
preview.IsPlaying = false;
};
}
return(process);
}
public async Task LoadSinglePreviewPlayerThumbnails(ReplayPreview replay)
{
if (replay == null)
{
throw new ArgumentNullException(nameof(replay));
}
var dataVersion = await RequestManager.GetLatestDataDragonVersionAsync().ConfigureAwait(true);
var allPlayers = new List <PlayerPreview>();
allPlayers.AddRange(replay.BluePreviewPlayers);
allPlayers.AddRange(replay.RedPreviewPlayers);
_log.Information($"Processing {allPlayers.Count} champion thumbnail requests");
var allRequests = new List <dynamic>(allPlayers.Select(x =>
new
{
Player = x,
Request = new ChampionRequest()
{
ChampionName = x.ChampionName,
DataDragonVersion = dataVersion
}
}));
var allTasks = new List <Task>();
foreach (var request in allRequests)
{
Application.Current.Dispatcher.Invoke((Action) delegate
{
request.Player.OverlayIcon = ResourceTools.GetObjectFromResource <Geometry>("DownloadPathIcon");
});
allTasks.Add(Task.Run(async() =>
{
var response = await RequestManager.MakeRequestAsync(request.Request as RequestBase)
.ConfigureAwait(true);
if (response.IsFaulted)
{
_log.Warning($"Failed to load image for {(response.Request as ChampionRequest).ChampionName}");
Application.Current.Dispatcher.Invoke((Action) delegate
{
request.Player.OverlayIcon = ResourceTools.GetObjectFromResource <Geometry>("ErrorPathIcon");
});
}
if (response.FromCache)
{
Application.Current.Dispatcher.Invoke((Action) delegate
{
request.Player.OverlayIcon = null; // hide overlay icons, if any
request.Player.ImageSource = ResourceTools.GetImageSourceFromPath(response.ResponsePath);
});
}
else
{
Application.Current.Dispatcher.Invoke((Action) delegate
{
request.Player.OverlayIcon = null; // hide overlay icons, if any
request.Player.ImageSource = response.ResponseBytes.ToBitmapImage();
});
}
}));
}
await Task.WhenAll(allTasks).ConfigureAwait(true);
}
public void SelectReplayItem(ReplayPreview replay)
{
ReplayListView.SelectedItem = replay;
}
public void PlayReplay(ReplayPreview preview)
{
_log.Information($"Playing replay...");
if (preview == null)
{
throw new ArgumentNullException(nameof(preview));
}
var replay = FileResults[preview.Location];
var executables = SettingsManager.Executables.GetExecutablesByPatch(preview.GameVersion);
if (!executables.Any())
{
_log.Information($"No executables found to play replay");
// No executable found that can be used to play
MessageBox.Show
(
Application.Current.TryFindResource("ExecutableNotFoundErrorText") as String + " " + preview.GameVersion,
Application.Current.TryFindResource("ExecutableNotFoundErrorTitle") as String,
MessageBoxButton.OK,
MessageBoxImage.Error
);
return;
}
LeagueExecutable target;
if (executables.Count > 1)
{
_log.Information($"More than one possible executable, asking user...");
// More than one?????
target = ShowChooseReplayDialog(executables);
if (target == null)
{
return;
}
}
else
{
target = executables.First();
}
if (SettingsManager.Settings.PlayConfirmation)
{
_log.Information($"Asking user for confirmation");
// Show confirmation dialog
var msgResult = MessageBox.Show
(
Application.Current.TryFindResource("ReplayPlayConfirmationText") as String,
Application.Current.TryFindResource("ReplayPlayConfirmationText") as String,
MessageBoxButton.OKCancel,
MessageBoxImage.Question
);
if (msgResult != MessageBoxResult.OK)
{
return;
}
}
_log.Information($"Using {target.Name} to play replay {replay.FileInfo.Path}");
ReplayPlayer.Play(target, replay.FileInfo.Path);
}
public async Task LoadSinglePreviewPlayerThumbnails(ReplayPreview replay)
{
if (replay == null)
{
throw new ArgumentNullException(nameof(replay));
}
if (LatestDataDragonVersion == null)
{
LatestDataDragonVersion = await RequestManager.GetDataDragonVersionAsync(null).ConfigureAwait(true);
}
var dataVersion = LatestDataDragonVersion;
// Get the correct data version for the replay version
if (!SettingsManager.Settings.UseMostRecent)
{
dataVersion = await RequestManager.GetDataDragonVersionAsync(replay.GameVersion).ConfigureAwait(true);
}
var allPlayers = new List <PlayerPreview>();
allPlayers.AddRange(replay.BluePreviewPlayers);
allPlayers.AddRange(replay.RedPreviewPlayers);
_log.Information($"Processing {allPlayers.Count} champion thumbnail requests");
var allRequests = new List <dynamic>(allPlayers.Select(x =>
new
{
Player = x,
Request = new ChampionRequest()
{
ChampionName = x.ChampionName,
DataDragonVersion = dataVersion
}
}));
var allTasks = new List <Task>();
foreach (var request in allRequests)
{
Application.Current.Dispatcher.Invoke((Action) delegate
{
request.Player.ImageSource = ResourceTools.GetImageSourceFromResource("DownloadDrawingImage");
});
allTasks.Add(Task.Run(async() =>
{
var response = await RequestManager.MakeRequestAsync(request.Request as RequestBase)
.ConfigureAwait(true);
if (response.IsFaulted)
{
Application.Current.Dispatcher.Invoke((Action) delegate
{
request.Player.ImageSource = ResourceTools.GetImageSourceFromResource("ErrorDrawingImage");
});
}
Application.Current.Dispatcher.Invoke((Action) delegate
{
request.Player.ImageSource = ResourceTools.GetImageSourceFromPath(response.ResponsePath);
});
}));
}
await Task.WhenAll(allTasks).ConfigureAwait(true);
}
