private void BtnSwitchView_Click(object sender, RoutedEventArgs e)
{
try
{
AppSettings.DisplaySeriesSimple = false;
// check if this control is part of the series container
DependencyObject parentObject = VisualTreeHelper.GetParent(this);
while (parentObject != null)
{
parentObject = VisualTreeHelper.GetParent(parentObject);
AnimeSeriesContainerControl containerCtrl = parentObject as AnimeSeriesContainerControl;
if (containerCtrl != null)
{
// show the full view
VM_AnimeSeries_User ser = DataContext as VM_AnimeSeries_User;
if (ser == null)
{
return;
}
AnimeSeries seriesControl = new AnimeSeries();
seriesControl.DataContext = ser;
containerCtrl.DataContext = seriesControl;
return;
}
}
}
catch (Exception ex)
{
Utils.ShowErrorMessage(ex);
}
}
void cRating_OnRatingValueChangedEvent(RatingValueEventArgs ev)
{
VM_AnimeSeries_User ser = DataContext as VM_AnimeSeries_User;
if (ser == null)
{
return;
}
try
{
decimal rating = (decimal)ev.RatingValue;
int voteType = 1;
if (ser.AniDBAnime.AniDBAnime.FinishedAiring)
{
voteType = 2;
}
VM_ShokoServer.Instance.VoteAnime(ser.AniDB_ID, rating, voteType);
// refresh the data
VM_MainListHelper.Instance.UpdateHeirarchy(ser);
}
catch (Exception ex)
{
Utils.ShowErrorMessage(ex);
}
}
private void CommandBinding_UseThis(object sender, ExecutedRoutedEventArgs e)
{
Window parentWindow = GetWindow(this);
object obj = e.Parameter;
if (obj == null)
{
return;
}
try
{
if (obj.GetType() == typeof(VM_AnimeSeries_User))
{
Cursor = Cursors.Wait;
VM_AnimeSeries_User ser = obj as VM_AnimeSeries_User;
SelectedSeriesID = ser.AnimeSeriesID;
DialogResult = true;
Close();
}
}
catch (Exception ex)
{
Utils.ShowErrorMessage(ex);
}
}
public static bool DialogSelectSeries(ref VM_AnimeSeries_User ser, List <VM_AnimeSeries_User> seriesList)
{
//show the selection dialog
GUIDialogMenu dlg = (GUIDialogMenu)GUIWindowManager.GetWindow((int)GUIWindow.Window.WINDOW_DIALOG_MENU);
if (dlg == null)
{
return(false);
}
dlg.Reset();
dlg.SetHeading(Translation.SelectSeries);
int index = 0;
foreach (VM_AnimeSeries_User serTemp in seriesList)
{
dlg.Add(serTemp.SeriesName);
index++;
}
dlg.DoModal(GUIWindowManager.ActiveWindow);
if (dlg.SelectedLabel < 0)
{
return(false);
}
ser = seriesList[dlg.SelectedLabel];
return(true);
}
void cRating_OnRatingValueChangedEvent(RatingValueEventArgs ev)
{
VM_AnimeSeries_User ser = DataContext as VM_AnimeSeries_User;
if (ser == null)
{
return;
}
try
{
decimal rating = (decimal)ev.RatingValue;
int voteType = 1;
if (cboVoteType.SelectedItem.ToString() == Shoko.Commons.Properties.Resources.VoteTypeAnimeTemporary)
{
voteType = 2;
}
if (cboVoteType.SelectedItem.ToString() == Shoko.Commons.Properties.Resources.VoteTypeAnimePermanent)
{
voteType = 1;
}
VM_ShokoServer.Instance.VoteAnime(ser.AniDB_ID, rating, voteType);
// refresh the data
VM_MainListHelper.Instance.UpdateHeirarchy(ser);
}
catch (Exception ex)
{
Utils.ShowErrorMessage(ex);
}
}
void lbSeries_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
try
{
if (lbSeries.Items.Count == 0)
{
return;
}
if (lbSeries.SelectedItem == null)
{
return;
}
VM_AnimeSeries_User series = lbSeries.SelectedItem as VM_AnimeSeries_User;
List <VM_AnimeEpisode_User> eps = series.AllEpisodes.OrderBy(a => a.EpisodeType).ThenBy(a => a.EpisodeNumber).ToList();
cboEpisodes.ItemsSource = eps;
if (cboEpisodes.Items.Count > 0)
{
cboEpisodes.SelectedIndex = 0;
}
SetConfirmDetails();
}
catch (Exception ex)
{
Utils.ShowErrorMessage(ex);
}
}
public static bool EvaluateSeriesTextSearch(VM_AnimeSeries_User series, string filterText, SeriesSearchType searchType = SeriesSearchType.TitleOnly)
{
filterText = filterText.Trim();
if (string.IsNullOrEmpty(filterText))
{
return(true);
}
if (series == null)
{
return(false);
}
if (IsDigitsOnly(filterText))
{
return(Convert.ToInt32(filterText) == series.AniDBAnime.AniDBAnime.AnimeID);
}
if (!string.IsNullOrEmpty(series.SeriesNameOverride) && series.SeriesNameOverride.FuzzyMatches(filterText))
{
return(true);
}
return(EvaluateAnimeTextSearch(series.AniDBAnime, filterText, searchType));
}
void refreshDataWorker_DoWork(object sender, DoWorkEventArgs e)
{
List <object> tempComments = new List <object>();
try
{
VM_AnimeSeries_User animeSeries = (VM_AnimeSeries_User)e.Argument;
if (animeSeries == null)
{
return;
}
// get comments from Trakt
foreach (VM_Trakt_CommentUser contract in VM_ShokoServer.Instance.ShokoServices.GetTraktCommentsForAnime(animeSeries.AniDB_ID).Cast <VM_Trakt_CommentUser>())
{
tempComments.Add(contract);
}
// get comments from AniDB
// get recommendations from AniDB
foreach (VM_AniDB_Recommendation rec in VM_ShokoServer.Instance.ShokoServices.GetAniDBRecommendations(animeSeries.AniDB_ID).Cast <VM_AniDB_Recommendation>())
{
tempComments.Add(rec);
}
}
catch (Exception ex)
{
Utils.ShowErrorMessage(ex);
}
e.Result = tempComments;
}
void cboEpisodeTypeFilter_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
//return;
ComboBox cbo = (ComboBox)sender;
object obj = cbo.SelectedItem;
if (obj == null)
{
return;
}
try
{
VM_AnimeEpisodeType epType = obj as VM_AnimeEpisodeType;
VM_AnimeSeries_User animeSeries = (VM_AnimeSeries_User)DataContext;
if (animeSeries == null)
{
return;
}
episodeType = epType.EpisodeType;
RefreshEpisodes();
}
catch (Exception ex)
{
Utils.ShowErrorMessage(ex);
}
}
void RateSeriesForm_DataContextChanged(object sender, DependencyPropertyChangedEventArgs e)
{
VM_AnimeSeries_User ser = DataContext as VM_AnimeSeries_User;
if (ser == null)
{
return;
}
Thread.CurrentThread.CurrentUICulture = CultureInfo.GetCultureInfo(AppSettings.Culture);
cboVoteType.Items.Clear();
cboVoteType.Items.Add(Shoko.Commons.Properties.Resources.VoteTypeAnimeTemporary);
if (ser.AniDBAnime.AniDBAnime.FinishedAiring)
{
cboVoteType.Items.Add(Shoko.Commons.Properties.Resources.VoteTypeAnimePermanent);
}
if (ser.AniDBAnime.AniDBAnime.FinishedAiring && ser.AllFilesWatched)
{
cboVoteType.SelectedIndex = 1;
}
else
{
cboVoteType.SelectedIndex = 0;
}
TraktLinkExists = ser.AniDBAnime.AniDBAnime != null && ser.AniDBAnime.AniDBAnime.AniDB_AnimeCrossRefs != null && ser.AniDBAnime.AniDBAnime.AniDB_AnimeCrossRefs.TraktCrossRefExists;
}
public void UpdateAnime(int animeID)
{
Application.Current?.Dispatcher.Invoke(() =>
{
try
{
VM_AniDB_Anime anime = (VM_AniDB_Anime)VM_ShokoServer.Instance.ShokoServices.GetAnime(animeID);
if (anime != null)
{
AllAnimeDictionary[anime.AnimeID] = anime;
// update the series
VM_AnimeSeries_User ser = AllSeriesDictionary.Values.FirstOrDefault(a => a.AniDB_ID == anime.AnimeID);
if (ser != null)
{
VM_MainListHelper.Instance.UpdateAll();
AllSeriesDictionary[ser.AnimeSeriesID] = ser;
}
}
}
catch (Exception ex)
{
Utils.ShowErrorMessage(ex);
}
});
}
void commentsWorker_DoWork(object sender, DoWorkEventArgs e)
{
VM_AnimeSeries_User ser = e.Argument as VM_AnimeSeries_User;
List <VM_Trakt_CommentUser> tempComments = new List <VM_Trakt_CommentUser>();
try
{
Application.Current.Dispatcher.Invoke(System.Windows.Threading.DispatcherPriority.Normal, (Action) delegate()
{
Comments.Clear();
});
// get comments from trakt
List <VM_Trakt_CommentUser> rawComments = VM_ShokoServer.Instance.ShokoServices.GetTraktCommentsForAnime(ser.AniDB_ID).CastList <VM_Trakt_CommentUser>();
Application.Current.Dispatcher.Invoke(System.Windows.Threading.DispatcherPriority.Normal, (Action) delegate()
{
rawComments.ForEach(a => Comments.Add(a));
});
// get recommendations from AniDB
List <VM_AniDB_Recommendation> rawRecs = VM_ShokoServer.Instance.ShokoServices.GetAniDBRecommendations(ser.AniDB_ID).CastList <VM_AniDB_Recommendation>();
Application.Current.Dispatcher.Invoke(System.Windows.Threading.DispatcherPriority.Normal, (Action) delegate()
{
rawRecs.ForEach(a => Comments.Add(a));
});
}
catch (Exception ex)
{
logger.Error(ex, ex.ToString());
}
}
void AnimeSeriesSimplifiedControl_DataContextChanged(object sender, DependencyPropertyChangedEventArgs e)
{
VM_AnimeSeries_User ser = DataContext as VM_AnimeSeries_User;
if (ser == null)
{
return;
}
ucExternalLinks.DataContext = ser;
try
{
PosterWidth = 180;
if (ser.AniDBAnime.AniDBAnime.UsePosterOnSeries)
{
string imgName = ser.AniDBAnime.AniDBAnime.FanartPathThenPosterPath;
if (File.Exists(imgName))
{
BitmapDecoder decoder = BitmapDecoder.Create(new Uri(imgName), BitmapCreateOptions.None, BitmapCacheOption.None);
BitmapFrame frame = decoder.Frames[0];
PosterWidth = (double)250 * ((double)frame.PixelWidth / (double)frame.PixelHeight);
}
}
}
catch (Exception ex)
{
logger.Error(ex, ex.ToString());
}
//RefreshData();
}
private void SetWatchedStatusOnSeries(bool watchedStatus, int maxEpisodeNumber)
{
try
{
VM_AnimeSeries_User animeSeries = (VM_AnimeSeries_User)DataContext;
if (animeSeries == null)
{
return;
}
Cursor = Cursors.Wait;
VM_AnimeEpisodeType epType = cboEpisodeTypeFilter.SelectedItem as VM_AnimeEpisodeType;
VM_ShokoServer.Instance.ShokoServices.SetWatchedStatusOnSeries(animeSeries.AnimeSeriesID, watchedStatus, maxEpisodeNumber,
(int)epType.EpisodeType, VM_ShokoServer.Instance.CurrentUser.JMMUserID);
VM_MainListHelper.Instance.UpdateHeirarchy(animeSeries);
RefreshEpisodes();
Cursor = Cursors.Arrow;
Window parentWindow = Window.GetWindow(this);
Utils.PromptToRateSeries(animeSeries, parentWindow);
}
catch (Exception ex)
{
Cursor = Cursors.Arrow;
Utils.ShowErrorMessage("SetWatchedStatusOnSeries: " + ex.Message, ex);
}
}
public async void SearchAnime(object argument)
{
try
{
runningTask?.Cancel();
}
catch {}
CancellationTokenSource tokenSource = new CancellationTokenSource();
runningTask = tokenSource;
//use listbox with dummy instead
VM_AnimeSeries_User dummy = new VM_AnimeSeries_User();
dummy.SeriesNameOverride = "Loading...";
AllSeries.Add(dummy);
btnAddSeries.IsEnabled = false;
cboEpisodes.IsEnabled = false;
cboMultiType.IsEnabled = false;
txtSeriesSearch.IsEnabled = false;
lbSeries.IsEnabled = false;
List <VM_AnimeSeries_User> series = null;
try
{
series = await Task.Run(() => SearchAnime(tokenSource, argument));
}
catch (TaskCanceledException)
{
// ignored
}
bool cancelled = runningTask.IsCancellationRequested;
runningTask = null;
if (cancelled)
{
return;
}
// update
if (series != null)
{
AllSeries.Clear();
series.ForEach(a => AllSeries.Add(a));
if (AllSeries.Count >= 1)
{
lbSeries.SelectedIndex = 0;
}
}
txtSeriesSearch.IsEnabled = true;
btnAddSeries.IsEnabled = true;
cboEpisodes.IsEnabled = true;
cboMultiType.IsEnabled = true;
lbSeries.IsEnabled = true;
}
private bool SeriesSearchFilter(object obj)
{
VM_AnimeSeries_User servm = obj as VM_AnimeSeries_User;
if (servm == null)
{
return(true);
}
return(GroupSearchFilterHelper.EvaluateSeriesTextSearch(servm, txtSeriesSearch.Text.Replace("'", "`")));
}
private void ShowFanart()
{
GUIControl.ClearControl(GetID, m_Facade.GetID);
VM_AnimeSeries_User ser = ShokoServerHelper.GetSeries(MainWindow.GlobalSeriesID);
if (ser != null)
{
if (ser.CrossRefAniDBTvDBV2 != null && ser.CrossRefAniDBTvDBV2.Count > 0)
{
AnimeID = ser.CrossRefAniDBTvDBV2[0].AnimeID;
}
}
if (ser == null)
{
return;
}
BaseConfig.MyAnimeLog.Write("ShowFanart for {0}", AnimeID);
foreach (FanartContainer fanart in ser.Anime.AniDB_AnimeCrossRefs.AllFanarts)
{
if (!File.Exists(fanart.FullImagePath))
{
continue;
}
GUIListItem item = new GUIListItem();
item.IconImage = item.IconImageBig = fanart.FullThumbnailPath;
item.TVTag = fanart;
item.OnItemSelected += onFacadeItemSelected;
m_Facade.Add(item);
}
if (m_Facade.Count > 0)
{
m_Facade.SelectedListItemIndex = 0;
// Work around for Filmstrip not allowing to programmatically select item
if (m_Facade.CurrentLayout == GUIFacadeControl.Layout.Filmstrip)
{
}
FanartContainer selectedFanart = m_Facade.SelectedListItem.TVTag as FanartContainer;
if (selectedFanart != null)
{
setFanartPreviewBackground(selectedFanart);
}
GUIControl.FocusControl(GetID, 50);
}
}
private void LoadInfo()
{
if (MainWindow.GlobalSeriesID > 0)
{
serMain = ShokoServerHelper.GetSeries(MainWindow.GlobalSeriesID);
if (serMain != null)
{
mainAnime = serMain.Anime;
}
}
}
void refreshCommentsRecsWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
VM_AnimeSeries_User animeSeries = (VM_AnimeSeries_User)DataContext;
if (animeSeries == null)
{
return;
}
commentsWorker.RunWorkerAsync(animeSeries);
}
public Fanart(object fanartObject)
{
this.fileName = "";
List <string> allFanarts = new List <string>();
// check for a default fanart
if (fanartObject.GetType() == typeof(VM_AnimeGroup_User))
{
VM_AnimeGroup_User grp = fanartObject as VM_AnimeGroup_User;
if (grp.DefaultAnimeSeriesID.HasValue)
{
VM_AnimeSeries_User ser = grp.DefaultSeries;
if (ser != null)
{
VM_AniDB_Anime anime = ser.Anime;
allFanarts.AddRange(GetFanartFilenames(anime));
}
}
else
{
// get all the series for this group
foreach (VM_AnimeSeries_User ser in grp.AllSeries)
{
VM_AniDB_Anime anime = ser.Anime;
allFanarts.AddRange(GetFanartFilenames(anime));
}
}
}
else if (fanartObject.GetType() == typeof(VM_AnimeSeries_User))
{
VM_AnimeSeries_User ser = fanartObject as VM_AnimeSeries_User;
VM_AniDB_Anime anime = ser.Anime;
allFanarts.AddRange(GetFanartFilenames(anime));
}
else if (fanartObject.GetType() == typeof(VM_AniDB_Anime))
{
VM_AniDB_Anime anime = fanartObject as VM_AniDB_Anime;
allFanarts.AddRange(GetFanartFilenames(anime));
}
string randomFanart = "";
if (allFanarts.Count > 0)
{
randomFanart = allFanarts[fanartRandom.Next(0, allFanarts.Count)];
}
if (!String.IsNullOrEmpty(randomFanart))
{
fileName = randomFanart;
}
}
public TraktSeriesData(VM_AnimeSeries_User ser)
{
AnimeSeriesID = ser.AnimeSeriesID;
AnimeID = ser.AniDB_ID;
SeriesName = ser.SeriesName;
Status = "";
UserTraktLinks = new ObservableCollection <VM_CrossRef_AniDB_TraktV2>();
CommTraktLinks = new ObservableCollection <VM_CrossRef_AniDB_TraktV2>();
SetHasTraktLinkImage();
}
public void UpdateHeirarchy(VM_AnimeSeries_User ser)
{
try
{
UpdateAll();
UpdateAboveGroups(ser);
}
catch (Exception ex)
{
Utils.ShowErrorMessage(ex);
}
}
void btnRefreshComments_Click(object sender, RoutedEventArgs e)
{
VM_AnimeSeries_User animeSeries = (VM_AnimeSeries_User)DataContext;
if (animeSeries == null)
{
return;
}
IsLoadingComments = true;
refreshCommentsRecsWorker.RunWorkerAsync(animeSeries);
}
private void RefreshUnwatchedEpisodes()
{
VM_AnimeSeries_User ser = DataContext as VM_AnimeSeries_User;
if (ser == null)
{
return;
}
if (!episodesWorker.IsBusy)
{
episodesWorker.RunWorkerAsync(ser);
}
}
void recsWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
VM_AnimeSeries_User ser = DataContext as VM_AnimeSeries_User;
if (ser == null)
{
return;
}
if (!charWorker.IsBusy)
{
charWorker.RunWorkerAsync(ser);
}
}
public static void SetWatchedStatusOnSeries(bool watchedStatus, int maxEpisodeNumber, int animeSeriesID)
{
VM_AnimeSeries_User series = GetSeries(animeSeriesID);
if (series == null)
{
return;
}
foreach (VM_AnimeEpisodeType epType in series.EpisodeTypes)
{
SetWatchedStatusOnSeries(watchedStatus, maxEpisodeNumber, animeSeriesID, epType.EpisodeType);
}
}
void charWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
VM_AnimeSeries_User ser = DataContext as VM_AnimeSeries_User;
if (ser == null)
{
return;
}
if (!commentsWorker.IsBusy)
{
IsLoadingComments = true;
commentsWorker.RunWorkerAsync(ser);
}
}
void episodesWorker_DoWork(object sender, DoWorkEventArgs e)
{
try
{
VM_AnimeSeries_User ser = e.Argument as VM_AnimeSeries_User;
List <VM_AnimeEpisode_User> rawEps = VM_ShokoServer.Instance.ShokoServices.GetAllUnwatchedEpisodes(ser.AnimeSeriesID,
VM_ShokoServer.Instance.CurrentUser.JMMUserID).CastList <VM_AnimeEpisode_User>();
// find the last watched episode
VM_AnimeEpisode_User rawLastEp = (VM_AnimeEpisode_User)VM_ShokoServer.Instance.ShokoServices.GetLastWatchedEpisodeForSeries(ser.AnimeSeriesID,
VM_ShokoServer.Instance.CurrentUser.JMMUserID);
if (rawLastEp != null)
{
rawLastEp.SetTvDBInfo();
//if (VM_ShokoServer.Instance.Trakt_IsEnabled)
// ep.SetTraktInfo();
rawLastEp.EpisodeOrder = 0;
Application.Current.Dispatcher.Invoke(System.Windows.Threading.DispatcherPriority.Normal, (Action) delegate()
{
UnwatchedEpisodes.Add(rawLastEp);
});
}
int i = 0;
foreach (VM_AnimeEpisode_User raw in rawEps)
{
i++;
raw.SetTvDBInfo();
//if (i == 1 && VM_ShokoServer.Instance.Trakt_IsEnabled) ep.SetTraktInfo();
raw.EpisodeOrder = i;
Application.Current.Dispatcher.Invoke(System.Windows.Threading.DispatcherPriority.Normal, (Action) delegate()
{
UnwatchedEpisodes.Add(raw);
});
if (i == 5)
{
break;
}
}
}
catch (Exception ex)
{
logger.Error(ex, ex.ToString());
}
}
void recsWorker_DoWork(object sender, DoWorkEventArgs e)
{
try
{
VM_AnimeSeries_User ser = e.Argument as VM_AnimeSeries_User;
Application.Current.Dispatcher.Invoke(System.Windows.Threading.DispatcherPriority.Normal, (Action) delegate()
{
Recommendations.Clear();
});
List <VM_AniDB_Anime_Similar> tempList = VM_ShokoServer.Instance.ShokoServices.GetSimilarAnimeLinks(ser.AniDB_ID,
VM_ShokoServer.Instance.CurrentUser.JMMUserID).Cast <VM_AniDB_Anime_Similar>().OrderByDescending(a => a.AnimeID).ToList();
foreach (VM_AniDB_Anime_Similar sim in tempList)
{
if (!sim.AnimeInfoExists)
{
string result = VM_ShokoServer.Instance.ShokoServices.UpdateAnimeData(sim.SimilarAnimeID);
if (string.IsNullOrEmpty(result))
{
sim.PopulateAnime((VM_AniDB_Anime)VM_ShokoServer.Instance.ShokoServices.GetAnime(sim.SimilarAnimeID));
}
}
Application.Current.Dispatcher.Invoke(System.Windows.Threading.DispatcherPriority.Normal, (Action) delegate()
{
Recommendations.Add(new RecommendationTile()
{
Details = "",
AnimeName = sim.DisplayName,
Picture = sim.PosterPath,
AnimeSeries = sim.AnimeSeries,
TileSize = "Large",
Height = 100,
Source = "AniDB",
AnimeID = sim.AnimeID,
URL = sim.AniDB_SiteURL,
SimilarAnimeID = sim.SimilarAnimeID,
HasSeries = sim.LocalSeriesExists
});
});
}
}
catch (Exception ex)
{
logger.Error(ex, ex.ToString());
}
}
void torrentDetailsWorker_DoWork(object sender, DoWorkEventArgs e)
{
DetailsContainer details = e.Argument as DetailsContainer;
if (details == null)
{
return;
}
if (details.SearchCritera != null)
{
if (details.SearchCritera.SearchType == DownloadSearchType.Episode)
{
VM_AnimeEpisode_User ep = details.SearchCritera.Episode as VM_AnimeEpisode_User;
VM_AnimeSeries_User ser = VM_MainListHelper.Instance.GetSeries(ep.AnimeSeriesID);
if (ser != null)
{
e.Result = ser;
return;
}
}
if (details.SearchCritera.SearchType == DownloadSearchType.Series)
{
VM_AniDB_Anime anime = details.SearchCritera.Anime as VM_AniDB_Anime;
VM_AnimeSeries_User ser = VM_MainListHelper.Instance.GetSeriesForAnime(anime.AnimeID);
if (ser != null)
{
e.Result = ser;
return;
}
}
}
// try and find the series
foreach (VM_AniDB_Anime anime in VM_AniDB_Anime.BestLevenshteinDistanceMatchesCache(details.TorLink.ClosestAnimeMatchString, 10))
{
// get the series for the anime
VM_AnimeSeries_User ser = VM_MainListHelper.Instance.GetSeriesForAnime(anime.AnimeID);
if (ser != null)
{
e.Result = ser;
return;
}
}
e.Result = null;
}
