void PlayNextEpisodeControlV2_DataContextChanged(object sender, DependencyPropertyChangedEventArgs e)
{
try
{
VM_AnimeEpisode_User ep = DataContext as VM_AnimeEpisode_User;
if (ep == null)
{
EpisodeExists = false;
EpisodeMissing = true;
}
else
{
EpisodeExists = true;
EpisodeMissing = false;
if (ep.ShowEpisodeOverviewInSummary)
{
TruncatedOverview = true;
FullOverview = false;
HideOverview = false;
}
else
{
TruncatedOverview = false;
FullOverview = false;
HideOverview = true;
}
}
}
catch (Exception ex)
{
Utils.ShowErrorMessage(ex);
}
}
public override DataTemplate SelectTemplate(object item, DependencyObject container)
{
FrameworkElement element = container as FrameworkElement;
if (element != null && item != null)
{
if (item.GetType() == typeof(VM_AnimeEpisode_User))
{
VM_AnimeEpisode_User ep = item as VM_AnimeEpisode_User;
if (ep.EpisodeOrder == 0)
{
return(element.FindResource("AnimeEpisodePrevious") as DataTemplate);
}
if (ep.EpisodeOrder == 1)
{
return(element.FindResource("AnimeEpisodeCurrent") as DataTemplate);
}
return(element.FindResource("AnimeEpisodeOther") as DataTemplate);
}
}
return(null);
}
private void CommandBinding_PlayAllUnwatchedEpisode(object sender, ExecutedRoutedEventArgs e)
{
Window parentWindow = Window.GetWindow(this);
object obj = e.Parameter;
if (obj == null)
{
return;
}
try
{
if (obj.GetType() == typeof(VM_AnimeEpisode_User))
{
VM_AnimeEpisode_User ep = obj as VM_AnimeEpisode_User;
MainWindow.videoHandler.PlayAllUnwatchedEpisodes(ep.AnimeSeriesID);
}
}
catch (Exception ex)
{
Utils.ShowErrorMessage(ex);
}
}
void PlaybackOperationEnded(bool countAsWatched, VM_AnimeEpisode_User ep)
{
try
{
if (ep == null)
{
return;
}
if (ep != null)
{
ep.IncrementEpisodeStats(Shoko.Models.Enums.StatCountType.Stopped);
}
//save watched status
if (countAsWatched || ep.IsWatched())
{
//MPTVSeriesLog.Write("This episode counts as watched");
if (countAsWatched)
{
BaseConfig.MyAnimeLog.Write("Marking episode as watched: " + ep.EpisodeNumberAndNameWithType);
MarkEpisodeAsWatched(ep);
}
}
traktScrobbleEnabled = false;
TraktScrobble(ScrobblePlayingStatus.Stop);
SetGUIProperties(true); // clear GUI Properties
}
catch (Exception e)
{
BaseConfig.MyAnimeLog.Write("Error in VideoHandler.PlaybackOperationEnded: {0}", e.ToString());
}
}
void btnUpdateEpisode_Click(object sender, RoutedEventArgs e)
{
VM_AnimeEpisode_User ep = DataContext as VM_AnimeEpisode_User;
Window wdw = Window.GetWindow(this);
Cursor = Cursors.Wait;
try
{
string res = VM_ShokoServer.Instance.ShokoServices.UpdateEpisodeData(ep.AniDB_EpisodeID);
if (res.Length > 0)
{
Cursor = Cursors.Arrow;
Utils.ShowErrorMessage(res);
return;
}
}
catch (Exception ex)
{
Utils.ShowErrorMessage(ex);
}
finally
{
Cursor = Cursors.Arrow;
}
}
private void ShowNextEpisode()
{
VM_AnimeGroup_User grp = DataContext as VM_AnimeGroup_User;
if (grp == null)
{
return;
}
if (grp.AnimeGroupID == 0)
{
ucNextEpisode.EpisodeExists = false;
ucNextEpisode.EpisodeMissing = true;
ucNextEpisode.DataContext = null;
return;
}
VM_AnimeEpisode_User ep = (VM_AnimeEpisode_User)VM_ShokoServer.Instance.ShokoServices.GetNextUnwatchedEpisodeForGroup(grp.AnimeGroupID, VM_ShokoServer.Instance.CurrentUser.JMMUserID);
if (ep != null)
{
ep.SetTvDBInfo();
ucNextEpisode.DataContext = ep;
}
else
{
ucNextEpisode.EpisodeExists = false;
ucNextEpisode.EpisodeMissing = true;
ucNextEpisode.DataContext = null;
}
}
private void CommandBinding_PlayEpisode(object sender, ExecutedRoutedEventArgs e)
{
Window parentWindow = Window.GetWindow(this);
try
{
VM_AnimeEpisode_User ep = DataContext as VM_AnimeEpisode_User;
if (ep.FilesForEpisode.Count > 0)
{
bool force = true;
if (MainWindow.videoHandler.DefaultPlayer.Player.ToString() !=
Enum.GetName(typeof(VideoPlayer), VideoPlayer.WindowsDefault))
{
if (ep.FilesForEpisode[0].VideoLocal_ResumePosition > 0)
{
AskResumeVideo ask = new AskResumeVideo(ep.FilesForEpisode[0].VideoLocal_ResumePosition);
ask.Owner = Window.GetWindow(this);
if (ask.ShowDialog() == true)
{
force = false;
}
}
}
MainWindow.videoHandler.PlayVideo(ep.FilesForEpisode[0], force);
}
}
catch (Exception ex)
{
Utils.ShowErrorMessage(ex);
}
}
protected override void OnClicked(int controlId, GUIControl control, Action.ActionType actionType)
{
if (MA3WindowManager.HandleWindowChangeButton(control))
{
return;
}
if (btnRefresh != null && control == btnRefresh)
{
btnRefresh.IsFocused = false;
m_Facade.Focus = true;
LoadData();
}
if (control == m_Facade)
{
// show the files if we are looking at a torrent
GUIListItem item = m_Facade.SelectedListItem;
if (item == null || item.TVTag == null)
{
return;
}
if (item.TVTag.GetType() == typeof(VM_AnimeEpisode_User))
{
VM_AnimeEpisode_User ep = item.TVTag as VM_AnimeEpisode_User;
if (ep != null)
{
MainWindow.vidHandler.ResumeOrPlay(ep);
}
}
}
base.OnClicked(controlId, control, actionType);
}
public void DisplayFiles()
{
try
{
VM_AnimeEpisode_User ep = DataContext as VM_AnimeEpisode_User;
if (ep != null)
{
ep.RefreshFilesForEpisode();
lbFiles.ItemsSource = ep.FilesForEpisode;
if (!ep.HasFiles)
{
List <CL_AniDB_GroupStatus> relGroups = ep.ReleaseGroups;
if (relGroups.Count > 0)
{
string grpList = "";
foreach (CL_AniDB_GroupStatus rg in relGroups)
{
if (grpList.Length > 0)
{
grpList += ", ";
}
grpList += rg.GroupName;
}
tbFileDetailsGroups.Text = Shoko.Commons.Properties.Resources.GroupsAvailableFrom + " " + grpList;
}
}
}
}
catch (Exception ex)
{
Utils.ShowErrorMessage(ex);
}
}
public void Init(VM_AnimeEpisode_User ep, VM_AniDB_Anime anime)
{
AnimeID = anime.AnimeID;
Anime = anime;
AnimeEpisode = ep;
List <int> uids = new List <int>();
cboSeries.Items.Clear();
foreach (VM_CrossRef_AniDB_TvDBV2 xref in Anime.TvSummary.CrossRefTvDBV2)
{
if (!uids.Contains(xref.TvDBID))
{
cboSeries.Items.Add(xref);
}
uids.Add(xref.TvDBID);
}
cboSeries.SelectionChanged += new SelectionChangedEventHandler(cboSeries_SelectionChanged);
if (cboSeries.Items.Count > 0)
{
cboSeries.SelectedIndex = 0;
}
}
private void CommandBinding_DeleteFile(object sender, ExecutedRoutedEventArgs e)
{
Window parentWindow = Window.GetWindow(this);
object obj = e.Parameter;
if (obj == null)
{
return;
}
try
{
if (obj.GetType() == typeof(VM_VideoDetailed))
{
VM_VideoDetailed vid = obj as VM_VideoDetailed;
AskDeleteFile dlg = new AskDeleteFile(string.Format(Shoko.Commons.Properties.Resources.DeleteFile_Title, vid.GetFileName()), Shoko.Commons.Properties.Resources.MultipleFiles_ConfirmDelete + "\r\n\r\n" + Shoko.Commons.Properties.Resources.DeleteFile_Confirm, vid.Places);
dlg.Owner = Window.GetWindow(this);
bool?res = dlg.ShowDialog();
if (res.HasValue && res.Value)
{
string tresult = string.Empty;
Cursor = Cursors.Wait;
foreach (CL_VideoLocal_Place lv in dlg.Selected)
{
string result =
VM_ShokoServer.Instance.ShokoServices.DeleteVideoLocalPlaceAndFile(
lv.VideoLocal_Place_ID);
if (result.Length > 0)
{
tresult += result + "\r\n";
}
}
if (!string.IsNullOrEmpty(tresult))
{
MessageBox.Show(tresult, Shoko.Commons.Properties.Resources.Error, MessageBoxButton.OK,
MessageBoxImage.Error);
}
VM_AnimeEpisode_User ep = DataContext as VM_AnimeEpisode_User;
if (ep != null)
{
VM_MainListHelper.Instance.UpdateHeirarchy(ep);
ep.LocalFileCount--;
}
DisplayFiles();
}
}
}
catch (Exception ex)
{
Utils.ShowErrorMessage(ex);
}
finally
{
Cursor = Cursors.Arrow;
}
}
void searchWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
try
{
List <TorrentLink> links = e.Result as List <TorrentLink>;
TorrentCount = links.Count;
foreach (TorrentLink link in links)
{
TorrentLinks.Add(link);
}
ViewTorrentLinks.Refresh();
List <CL_GroupVideoQuality> vidQualListTemp = new List <CL_GroupVideoQuality>();
if (CurrentSearchCriteria.SearchType == DownloadSearchType.Episode)
{
VM_AnimeEpisode_User ep = CurrentSearchCriteria.Episode as VM_AnimeEpisode_User;
if (ep.AniDB_Anime == null)
{
ep.RefreshAnime();
}
if (ep.AniDB_Anime != null)
{
List <CL_GroupVideoQuality> summ = VM_ShokoServer.Instance.ShokoServices.GetGroupVideoQualitySummary(ep.AniDB_Anime.AnimeID).CastList <CL_GroupVideoQuality>();
foreach (CL_GroupVideoQuality vidQual in summ)
{
vidQualListTemp.Add(vidQual);
}
}
}
if (CurrentSearchCriteria.SearchType == DownloadSearchType.Series)
{
VM_AniDB_Anime anime = CurrentSearchCriteria.Anime as VM_AniDB_Anime;
if (anime != null)
{
List <CL_GroupVideoQuality> summ = VM_ShokoServer.Instance.ShokoServices.GetGroupVideoQualitySummary(anime.AnimeID).CastList <CL_GroupVideoQuality>();
foreach (CL_GroupVideoQuality vidQual in summ)
{
vidQualListTemp.Add(vidQual);
}
}
}
ShowSubGroupSuggestions(vidQualListTemp);
TorrentSearchStatus = string.Format(Shoko.Commons.Properties.Resources.Downloads_Results, links.Count);
}
catch (Exception ex)
{
Utils.ShowErrorMessage(ex);
}
finally
{
Cursor = Cursors.Arrow;
IsEnabled = true;
}
}
public static String GetEpisodeImageAsFileName(VM_AnimeEpisode_User ep)
{
string imgFileName = ep.EpisodeImageLocation;
BaseConfig.MyAnimeLog.Write("GetEpisodeImageAsFileName:: {0} : {1}", imgFileName, ep);
return(imgFileName);
}
private void SetVisibility()
{
VM_AnimeEpisode_User ep = DataContext as VM_AnimeEpisode_User;
if (ep != null)
{
ShowEpisodeImageInSummary = IsCollapsed && ep.ShowEpisodeImageInSummary;
ShowEpisodeOverviewInSummary = IsCollapsed && ep.ShowEpisodeOverviewInSummary;
ShowEpisodeImageInExpanded = IsExpanded && ep.ShowEpisodeImageInExpanded;
ShowEpisodeOverviewInExpanded = IsExpanded && ep.ShowEpisodeOverviewInExpanded;
}
}
public VM_AnimeSeries_User GetSeriesForEpisode(VM_AnimeEpisode_User ep)
{
try
{
return(AllSeriesDictionary.SureGet(ep.AnimeSeriesID));
}
catch (Exception ex)
{
Utils.ShowErrorMessage(ex);
}
return(null);
}
void btnMarkAllPreviousWatched_Click(object sender, RoutedEventArgs e)
{
if (lbEpisodes.SelectedItem != null)
{
VM_AnimeEpisode_User ep = lbEpisodes.SelectedItem as VM_AnimeEpisode_User;
if (ep == null)
{
return;
}
SetWatchedStatusOnSeries(true, ep.EpisodeNumber);
}
}
/*
* public VM_AnimeEpisode_User GetEpisodeForVideo(VM_VideoDetailed vid, EpisodeList epList)
* {
* // get the episodes that this file applies to
*
*
* try
* {
* List<JMMServerBinary.Contract_AnimeEpisode> eps = VM_ShokoServer.Instance.ShokoServices.GetEpisodesForFile(vid.VideoLocalID,
* VM_ShokoServer.Instance.CurrentUser.JMMUserID.Value);
*
* foreach (JMMServerBinary.Contract_AnimeEpisode epcontract in eps)
* {
* foreach (object epObj in epList.lbEpisodes.ItemsSource)
* {
* VM_AnimeEpisode_User epItem = epObj as VM_AnimeEpisode_User;
* if (epItem.AnimeEpisodeID == vid.AnimeEpisodeID)
* return epItem;
* }
* }
* }
* catch (Exception ex)
* {
* Utils.ShowErrorMessage(ex);
* }
*
* return null;
* }
*/
public void RefreshHeirarchy(VM_AnimeEpisode_User ep)
{
try
{
// update the episode first
VM_AnimeEpisode_User contract = (VM_AnimeEpisode_User)VM_ShokoServer.Instance.ShokoServices.GetEpisode(ep.AnimeEpisodeID, VM_ShokoServer.Instance.CurrentUser.JMMUserID);
UpdateHeirarchy(contract);
}
catch (Exception ex)
{
Utils.ShowErrorMessage(ex);
}
}
private void onFacadeItemSelected(GUIListItem item, GUIControl parent)
{
//BaseConfig.MyAnimeLog.Write("Facade Item Selected");
// if this is not a message from the facade, exit
if (parent != m_Facade && parent != m_Facade.FilmstripLayout)
{
return;
}
VM_AnimeEpisode_User ep = m_Facade.SelectedListItem.TVTag as VM_AnimeEpisode_User;
SetEpisode(ep);
}
private void CommandBinding_ToggleWatchedStatus(object sender, ExecutedRoutedEventArgs e)
{
object obj = e.Parameter;
if (obj == null)
{
return;
}
Cursor = Cursors.Wait;
IsEnabled = false;
bool newStatus = false;
try
{
if (obj.GetType() == typeof(VM_VideoDetailed))
{
VM_VideoDetailed vid = obj as VM_VideoDetailed;
newStatus = !vid.Watched;
VM_ShokoServer.Instance.ShokoServices.ToggleWatchedStatusOnVideo(vid.VideoLocalID, newStatus, VM_ShokoServer.Instance.CurrentUser.JMMUserID);
VM_MainListHelper.Instance.UpdateHeirarchy(vid);
}
if (obj.GetType() == typeof(VM_AnimeEpisode_User))
{
VM_AnimeEpisode_User ep = obj as VM_AnimeEpisode_User;
newStatus = !ep.Watched;
CL_Response <CL_AnimeEpisode_User> response = VM_ShokoServer.Instance.ShokoServices.ToggleWatchedStatusOnEpisode(ep.AnimeEpisodeID,
newStatus, VM_ShokoServer.Instance.CurrentUser.JMMUserID);
if (!string.IsNullOrEmpty(response.ErrorMessage))
{
MessageBox.Show(response.ErrorMessage, Shoko.Commons.Properties.Resources.Error, MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
VM_MainListHelper.Instance.UpdateHeirarchy((VM_AnimeEpisode_User)response.Result);
}
}
catch (Exception ex)
{
Utils.ShowErrorMessage(ex);
}
finally
{
Cursor = Cursors.Arrow;
IsEnabled = true;
}
}
public bool ResumeOrPlay(VM_VideoLocal fileToPlay)
{
try
{
curEpisode = null;
if (fileToPlay.IsLocalOrStreaming() == null)
{
Utils.DialogMsg("Error", "File could not be found!");
return(false);
}
current = fileToPlay;
BaseConfig.MyAnimeLog.Write("Getting time stopped for : {0}", fileToPlay.FileName);
BaseConfig.MyAnimeLog.Write("Time stopped for : {0} - {1}", fileToPlay.FileName, fileToPlay.ResumePosition / 1000);
#region Ask user to Resume
_timeMovieStopped = (int)(fileToPlay.ResumePosition / 1000);
if (_timeMovieStopped > 0)
{
GUIDialogYesNo dlgYesNo = (GUIDialogYesNo)GUIWindowManager.GetWindow((int)GUIWindow.Window.WINDOW_DIALOG_YES_NO);
if (null != dlgYesNo)
{
dlgYesNo.SetHeading(GUILocalizeStrings.Get(900)); //resume movie?
dlgYesNo.SetLine(1, fileToPlay.FileName);
dlgYesNo.SetLine(2, GUILocalizeStrings.Get(936) + " " + MediaPortal.Util.Utils.SecondsToHMSString(TimeSpan.FromMilliseconds(fileToPlay.ResumePosition)));
dlgYesNo.SetDefaultToYes(true);
dlgYesNo.DoModal(GUIWindowManager.ActiveWindow);
if (!dlgYesNo.IsConfirmed) // reset resume data in DB
{
_timeMovieStopped = 0;
}
}
}
#endregion
Play(_timeMovieStopped, fileToPlay.DefaultAudioLanguage, fileToPlay.DefaultSubtitleLanguage);
return(true);
}
catch (Exception ex)
{
BaseConfig.MyAnimeLog.Write("Error inResumeOrPlay : {0}", ex.ToString());
}
return(false);
}
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 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;
}
private void UpdateGroupAndSeriesForEpisode(VM_AnimeEpisode_User ep)
{
try
{
UpdateAll();
VM_AnimeSeries_User ser = AllSeriesDictionary.SureGet(ep.AnimeSeriesID);
if (ser != null)
{
UpdateAboveGroups(ser);
}
}
catch (Exception ex)
{
Utils.ShowErrorMessage(ex);
}
}
// ASync method to avoid mediaportal video treatment sleep
public void loadPlayingPresetASync(VM_AnimeEpisode_User curEpisode, string fileName)
{
// Create an instance of the FFDShowHelper class.
FFDShowHelper ffdshowHelper = new FFDShowHelper();
// Create the delegate.
AsyncloadPlayingPresetCaller caller = loadPlayingPreset;
// Initiate the asychronous call.
IAsyncResult result = caller.BeginInvoke(curEpisode, fileName, null, null);
Thread.Sleep(0);
debug("Main thread " + Thread.CurrentThread.ManagedThreadId + " does some work.");
// Call EndInvoke to wait for the asynchronous call to complete,
// and to retrieve the results.
// string returnValue = caller.EndInvoke(result);
// caller.EndInvoke(result);
}
void lbVideos_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
// get detailed video, episode and series info
ccDetail.Content = null;
ccSeriesDetail.Content = null;
if (lbVideos.SelectedItems.Count == 0)
{
return;
}
if (lbVideos.SelectedItem == null)
{
return;
}
VM_VideoLocal vid = lbVideos.SelectedItem as VM_VideoLocal;
displayingVidID = vid.VideoLocalID;
EnableDisableControls(false);
try
{
Cursor = Cursors.Wait;
ccDetail.Content = vid;
// get the episode(s)
VM_AnimeEpisode_User ep = (VM_AnimeEpisode_User)VM_ShokoServer.Instance.ShokoServices.GetEpisodesForFile(vid.VideoLocalID, VM_ShokoServer.Instance.CurrentUser.JMMUserID).FirstOrDefault();
if (ep != null)
{
ccSeriesDetail.Content = ep;
}
Cursor = Cursors.Arrow;
}
catch (Exception ex)
{
Utils.ShowErrorMessage(ex);
}
finally
{
Cursor = Cursors.Arrow;
EnableDisableControls(true);
}
}
public VM_PlaylistItem(int playlistID, PlaylistItemType itemType, object playlistItem)
{
PlaylistID = playlistID;
ItemType = itemType;
PlaylistItem = playlistItem;
if (ItemType == PlaylistItemType.AnimeSeries)
{
Series = PlaylistItem as VM_AnimeSeries_User;
}
if (ItemType == PlaylistItemType.Episode)
{
Episode = (VM_AnimeEpisode_User)PlaylistItem;
if (VM_MainListHelper.Instance.AllSeriesDictionary.ContainsKey(Episode.AnimeSeriesID))
{
Series = VM_MainListHelper.Instance.AllSeriesDictionary[Episode.AnimeSeriesID];
}
}
}
public void DisplayFiles()
{
try
{
VM_AnimeEpisode_User ep = DataContext as VM_AnimeEpisode_User;
if (ep != null)
{
ep.RefreshFilesForEpisode();
ep.RefreshAnime();
fileSummary.DataContext = null;
fileSummary.DataContext = ep.AniDB_Anime;
lbFiles.ItemsSource = ep.FilesForEpisode;
}
}
catch (Exception ex)
{
Utils.ShowErrorMessage(ex);
}
}
void btnTvDBLinkAdd_Click(object sender, RoutedEventArgs e)
{
try
{
// get the current tvdb link
VM_AnimeEpisode_User ep = DataContext as VM_AnimeEpisode_User;
ep.RefreshAnime();
if (ep.AniDB_Anime == null || ep.AniDB_Anime.TvSummary == null || ep.AniDB_Anime.TvSummary.CrossRefTvDBV2 == null ||
ep.AniDB_Anime.TvSummary.CrossRefTvDBV2.Count == 0)
{
Utils.ShowErrorMessage(Shoko.Commons.Properties.Resources.EpisodeDetail_TvDBLink);
return;
}
Window wdw = Window.GetWindow(this);
Cursor = Cursors.Wait;
SelectTvDBEpisodeForm frm = new SelectTvDBEpisodeForm();
frm.Owner = wdw;
frm.Init(ep, ep.AniDB_Anime);
bool?result = frm.ShowDialog();
if (result.Value)
{
// update info
CL_AnimeEpisode_User contract = VM_ShokoServer.Instance.ShokoServices.GetEpisode(
ep.AnimeEpisodeID, VM_ShokoServer.Instance.CurrentUser.JMMUserID);
if (contract != null)
{
ep.RefreshAnime(true);
ep.Populate(contract);
ep.SetTvDBInfo();
}
}
Cursor = Cursors.Arrow;
}
catch (Exception ex)
{
Utils.ShowErrorMessage(ex);
}
}
private void CommandBinding_DeleteLink(object sender, ExecutedRoutedEventArgs e)
{
Window parentWindow = Window.GetWindow(this);
object obj = e.Parameter;
if (obj == null)
{
return;
}
try
{
if (obj.GetType() == typeof(VM_AnimeEpisode_User))
{
VM_AnimeEpisode_User ep = obj as VM_AnimeEpisode_User;
VM_VideoLocal vid = DataContext as VM_VideoLocal;
if (ep == null || vid == null)
{
MessageBox.Show("ep or vid is null. This is not okay, so report it.", Shoko.Commons.Properties.Resources.Error, MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
string res = VM_ShokoServer.Instance.ShokoServices.RemoveAssociationOnFile(vid.VideoLocalID, ep.AniDB_EpisodeID);
if (res.Length > 0)
{
MessageBox.Show(res, Shoko.Commons.Properties.Resources.Error, MessageBoxButton.OK, MessageBoxImage.Error);
}
else
{
VM_MainListHelper.Instance.UpdateHeirarchy(ep);
DisplayEpisodes();
}
}
}
catch (Exception ex)
{
Utils.ShowErrorMessage(ex);
}
}
private void CommandBinding_DeleteLink(object sender, ExecutedRoutedEventArgs e)
{
Window parentWindow = Window.GetWindow(this);
object obj = e.Parameter;
if (obj == null)
{
return;
}
try
{
if (obj.GetType() == typeof(VM_VideoDetailed))
{
VM_VideoDetailed vid = obj as VM_VideoDetailed;
VM_AnimeEpisode_User ep = DataContext as VM_AnimeEpisode_User;
//VM_AnimeEpisode_User ep = VM_MainListHelper.Instance.GetEpisodeForVideo(vid, ((MainWindow)parentWindow).epListMain);
string res = VM_ShokoServer.Instance.ShokoServices.RemoveAssociationOnFile(vid.VideoLocalID, ep.AniDB_EpisodeID);
if (res.Length > 0)
{
MessageBox.Show(res, Shoko.Commons.Properties.Resources.Error, MessageBoxButton.OK, MessageBoxImage.Error);
}
else
{
if (ep != null)
{
VM_MainListHelper.Instance.RefreshHeirarchy(ep);
DisplayFiles();
}
}
}
}
catch (Exception ex)
{
Utils.ShowErrorMessage(ex);
}
}
