private void LoadData()
{
relations.Clear();
mainAnime = null;
serMain = null;
serMain = JMMServerHelper.GetSeries(MainWindow.GlobalSeriesID);
if (serMain != null)
{
mainAnime = serMain.AniDB_Anime;
}
if (mainAnime == null)
{
return;
}
try
{
relations = mainAnime.RelatedAnimeLinks;
}
catch (Exception ex)
{
BaseConfig.MyAnimeLog.Write(ex.ToString());
}
}
void workerRefreshUnlinkedFiles_DoWork(object sender, DoWorkEventArgs e)
{
List <VideoLocalVM> unlinkedVideos = JMMServerHelper.GetUnlinkedVideos();
List <GUIListItem> listItems = new List <GUIListItem>();
GUIListItem itm = null;
foreach (VideoLocalVM locFile in unlinkedVideos)
{
string fileNameFull = Path.GetFileName(locFile.FullPath);
string fileName = fileNameFull;
if (File.Exists(fileNameFull))
{
FileInfo fi = new FileInfo(fileNameFull);
fileName = fi.Name;
}
itm = new GUIListItem(fileName);
itm.TVTag = locFile;
listItems.Add(itm);
}
e.Result = listItems;
}
private void ShowPosters()
{
GUIControl.ClearControl(this.GetID, m_Facade.GetID);
List <PosterContainer> allPosters = new List <PosterContainer>();
string displayname = "";
AnimeSeriesVM ser = JMMServerHelper.GetSeries(MainWindow.GlobalSeriesID);
if (ser != null)
{
displayname = ser.SeriesName;
if (ser.CrossRef_AniDB_TvDBV2 != null && ser.CrossRef_AniDB_TvDBV2.Count > 0)
{
AnimeID = ser.CrossRef_AniDB_TvDBV2[0].AnimeID;
}
}
BaseConfig.MyAnimeLog.Write("ShowPosters for {0} - {1}", displayname, AnimeID);
foreach (PosterContainer pstr in ser.AniDB_Anime.AniDB_AnimeCrossRefs.AllPosters)
{
if (!File.Exists(pstr.FullImagePath))
{
continue;
}
allPosters.Add(pstr);
}
GUIListItem item = null;
foreach (PosterContainer poster in allPosters)
{
item = new GUIListItem();
item.IconImage = item.IconImageBig = poster.FullImagePath;
item.TVTag = poster;
item.OnItemSelected += new GUIListItem.ItemSelectedHandler(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)
{
}
PosterContainer selectedPoster = m_Facade.SelectedListItem.TVTag as PosterContainer;
if (selectedPoster != null)
{
SetPosterProperties(selectedPoster);
}
GUIControl.FocusControl(GetID, 50);
}
}
private void ShowFanart()
{
GUIControl.ClearControl(this.GetID, m_Facade.GetID);
List <FanartContainer> allFanart = new List <FanartContainer>();
AnimeSeriesVM ser = JMMServerHelper.GetSeries(MainWindow.GlobalSeriesID);
if (ser != null)
{
if (ser.CrossRef_AniDB_TvDBV2 != null && ser.CrossRef_AniDB_TvDBV2.Count > 0)
{
AnimeID = ser.CrossRef_AniDB_TvDBV2[0].AnimeID;
}
}
if (ser == null)
{
return;
}
BaseConfig.MyAnimeLog.Write("ShowFanart for {0}", AnimeID);
GUIListItem item = null;
foreach (FanartContainer fanart in ser.AniDB_Anime.AniDB_AnimeCrossRefs.AllFanarts)
{
if (!File.Exists(fanart.FullImagePath))
{
continue;
}
item = new GUIListItem();
item.IconImage = item.IconImageBig = fanart.FullThumbnailPath;
item.TVTag = fanart;
item.OnItemSelected += new GUIListItem.ItemSelectedHandler(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 = JMMServerHelper.GetSeries(MainWindow.GlobalSeriesID);
if (serMain != null)
{
MainAnime = serMain.AniDB_Anime;
}
}
}
private void ShowWideBanners()
{
GUIControl.ClearControl(this.GetID, m_Facade.GetID);
AnimeSeriesVM ser = JMMServerHelper.GetSeries(MainWindow.GlobalSeriesID);
if (ser != null)
{
if (ser.CrossRef_AniDB_TvDBV2 != null && ser.CrossRef_AniDB_TvDBV2.Count > 0)
{
AnimeID = ser.CrossRef_AniDB_TvDBV2[0].AnimeID;
}
}
if (ser != null)
{
List <TvDB_ImageWideBannerVM> tvDBWideBanners = ser.AniDB_Anime.AniDB_AnimeCrossRefs.TvDBImageWideBanners;
GUIListItem item = null;
foreach (TvDB_ImageWideBannerVM banner in tvDBWideBanners)
{
item = new GUIListItem();
item.IconImage = item.IconImageBig = banner.FullImagePath;
item.TVTag = banner;
item.OnItemSelected += new GUIListItem.ItemSelectedHandler(onFacadeItemSelected);
m_Facade.Add(item);
}
if (m_Facade.Count > 0)
{
m_Facade.SelectedListItemIndex = 0;
TvDB_ImageWideBannerVM selectedBanner = m_Facade.SelectedListItem.TVTag as TvDB_ImageWideBannerVM;
if (selectedBanner != null)
{
SetWideBannerProperties(selectedBanner);
}
GUIControl.FocusControl(GetID, 50);
}
}
}
private void ShowEpisodeDetails(AnimeEpisodeVM ep)
{
dummyEpisodeSearch.Visible = false;
AnimeSeriesVM series = JMMServerHelper.GetSeries(ep.AnimeSeriesID);
if (series != null && series.AniDB_Anime != null)
{
SetGUIProperty(GuiProperty.SubGroup_AnimeName, series.AniDB_Anime.FormattedTitle);
SetGUIProperty(GuiProperty.SubGroup_EpisodeName, ep.EpisodeNumberAndName);
List<GroupVideoQualityVM> videoQualityRecords = new List<GroupVideoQualityVM>();
List<JMMServerBinary.Contract_GroupVideoQuality> summ = new List<Contract_GroupVideoQuality>(JMMServerVM.Instance.clientBinaryHTTP.GetGroupVideoQualitySummary(series.AniDB_Anime.AnimeID));
foreach (JMMServerBinary.Contract_GroupVideoQuality contract in summ)
{
GroupVideoQualityVM vidQual = new GroupVideoQualityVM(contract);
videoQualityRecords.Add(vidQual);
}
// apply sorting
if (videoQualityRecords.Count > 0)
{
List<SortPropOrFieldAndDirection> sortlist = new List<SortPropOrFieldAndDirection>();
sortlist.Add(new SortPropOrFieldAndDirection("FileCountNormal", true, SortType.eInteger));
videoQualityRecords = Sorting.MultiSort<GroupVideoQualityVM>(videoQualityRecords, sortlist);
string fileDetails = "";
foreach (GroupVideoQualityVM gvq in videoQualityRecords)
fileDetails += string.Format("{0}({1}/{2}/{3}bit) - {4} Files ({5})", gvq.GroupNameShort, gvq.Resolution, gvq.VideoSource, gvq.VideoBitDepth, gvq.FileCountNormal, gvq.NormalEpisodeNumberSummary)
+ Environment.NewLine;
SetGUIProperty(GuiProperty.SubGroup_FileDetails, fileDetails);
}
else
{
ClearGUIProperty(GuiProperty.SubGroup_FileDetails);
}
dummyEpisodeSearch.Visible = true;
}
}
protected override void OnShowContextMenu()
{
GUIListItem currentitem = this.m_Facade.SelectedListItem;
if (currentitem == null)
{
return;
}
if (currentitem.TVTag.GetType() == typeof(AnimeEpisodeVM))
{
AnimeEpisodeVM ep = currentitem.TVTag as AnimeEpisodeVM;
if (ep != null)
{
GUIDialogMenu dlg = (GUIDialogMenu)GUIWindowManager.GetWindow((int)GUIWindow.Window.WINDOW_DIALOG_MENU);
if (dlg == null)
{
return;
}
dlg.Reset();
dlg.SetHeading(ep.EpisodeNumberAndName);
dlg.Add("Mark as Watched");
dlg.Add("Play Previous Episode");
dlg.Add("Go To Episode List");
dlg.Add("View Series Info");
dlg.DoModal(GUIWindowManager.ActiveWindow);
switch (dlg.SelectedLabel)
{
case 0:
ep.ToggleWatchedStatus(true);
LoadData();
break;
case 1:
if (ep.AnimeSeries == null)
{
return;
}
JMMServerBinary.Contract_AnimeEpisode contract = JMMServerVM.Instance.clientBinaryHTTP.GetPreviousEpisodeForUnwatched(ep.AnimeSeries.AnimeSeriesID.Value,
JMMServerVM.Instance.CurrentUser.JMMUserID);
if (contract == null)
{
Utils.DialogMsg("Error", "Previous episode not found");
return;
}
AnimeEpisodeVM epPrev = new AnimeEpisodeVM(contract);
MainWindow.vidHandler.ResumeOrPlay(epPrev);
break;
case 2:
if (ep.AnimeSeries == null)
{
return;
}
MainWindow.curGroupFilter = GroupFilterHelper.AllGroupsFilter;
// find the group for this series
AnimeGroupVM grp = JMMServerHelper.GetGroup(ep.AnimeSeries.AnimeGroupID);
if (grp == null)
{
BaseConfig.MyAnimeLog.Write("Group not found");
return;
}
MainWindow.curAnimeGroup = grp;
MainWindow.curAnimeGroupViewed = grp;
MainWindow.curAnimeSeries = ep.AnimeSeries;
bool foundEpType = false;
foreach (AnimeEpisodeTypeVM anEpType in ep.AnimeSeries.EpisodeTypesToDisplay)
{
if (anEpType.EpisodeType == enEpisodeType.Episode)
{
MainWindow.curAnimeEpisodeType = anEpType;
foundEpType = true;
break;
}
}
if (!foundEpType)
{
return;
}
MainWindow.listLevel = Listlevel.Episode;
GUIWindowManager.ActivateWindow(Constants.WindowIDs.MAIN, false);
break;
case 3:
if (ep.AnimeSeries == null)
{
return;
}
MainWindow.GlobalSeriesID = ep.AnimeSeries.AnimeSeriesID.Value;
GUIWindowManager.ActivateWindow(Constants.WindowIDs.ANIMEINFO, false);
break;
}
}
}
}
protected override void OnShowContextMenu()
{
try
{
GUIListItem currentitem = this.m_Facade.SelectedListItem;
if (currentitem == null || !(currentitem.TVTag is TvDB_ImageWideBannerVM))
{
return;
}
TvDB_ImageWideBannerVM selectedBanner = currentitem.TVTag as TvDB_ImageWideBannerVM;
IDialogbox dlg = (IDialogbox)GUIWindowManager.GetWindow((int)GUIWindow.Window.WINDOW_DIALOG_MENU);
if (dlg == null)
{
return;
}
dlg.Reset();
dlg.SetHeading("Wide Banner");
bool isDisabled = false;
bool isDefault = false;
isDisabled = selectedBanner.Enabled == 0 ? true : false;
GUIListItem pItem;
if (isDisabled)
{
pItem = new GUIListItem("Enable"); dlg.Add(pItem);
}
else
{
pItem = new GUIListItem("Disable"); dlg.Add(pItem);
}
if (!isDisabled)
{
if (!selectedBanner.IsImageDefault)
{
pItem = new GUIListItem("Set as Default"); dlg.Add(pItem);
}
if (selectedBanner.IsImageDefault)
{
pItem = new GUIListItem("Remove as Default"); dlg.Add(pItem);
}
}
// lets show it
dlg.DoModal(GUIWindowManager.ActiveWindow);
if (dlg.SelectedId == 1) // enabled/disable
{
bool endis = isDisabled;
JMMServerHelper.EnableDisableWideBanner(endis, selectedBanner, AnimeID);
ShowWideBanners();
return;
}
if (dlg.SelectedId == 2)
{
bool isdef = !selectedBanner.IsImageDefault;
JMMServerHelper.SetDefaultWideBanner(isdef, selectedBanner, AnimeID);
ShowWideBanners();
return;
}
}
catch (Exception ex)
{
BaseConfig.MyAnimeLog.Write("Exception in Wide Banner Chooser Context Menu: " + ex.Message);
return;
}
}
public List <string> GetParms()
{
List <string> parms = new List <string>();
if (searchType == DownloadSearchType.Episode)
{
AnimeEpisodeVM ep = searchParameter as AnimeEpisodeVM;
AnimeSeriesVM series = JMMServerHelper.GetSeries(ep.AnimeSeriesID);
if (series == null)
{
return(parms);
}
AniDB_AnimeVM anime = series.AniDB_Anime;
if (anime == null)
{
return(parms);
}
// only use the first 2 words of the anime's title
string[] titles = anime.MainTitle.Split(' ');
int i = 0;
foreach (string s in titles)
{
i++;
parms.Add(s.Trim());
if (i == 2)
{
break;
}
}
parms.Add(ep.EpisodeNumber.ToString().PadLeft(2, '0'));
}
if (searchType == DownloadSearchType.Series)
{
AniDB_AnimeVM anime = searchParameter as AniDB_AnimeVM;
// only use the first 2 words of the anime's title
string[] titles = anime.MainTitle.Split(' ');
int i = 0;
foreach (string s in titles)
{
i++;
parms.Add(s.Trim());
if (i == 2)
{
break;
}
}
}
if (searchType == DownloadSearchType.Manual)
{
string[] titles = searchParameter.ToString().Split(' ');
foreach (string s in titles)
{
parms.Add(s.Trim());
}
}
return(parms);
}
private void ProcessImageDownloadRequest(ImageDownloadRequest req)
{
try
{
string fileName = GetFileName(req, false);
string entityID = GetEntityID(req);
bool downloadImage = true;
bool fileExists = File.Exists(fileName);
if (fileExists)
{
if (!req.ForceDownload)
{
downloadImage = false;
}
else
{
downloadImage = true;
}
}
else
{
downloadImage = true;
}
if (downloadImage)
{
string tempName = Path.Combine(Utils.GetImagesTempFolder(), Path.GetFileName(fileName));
if (File.Exists(tempName))
{
File.Delete(tempName);
}
OnImageDownloadEvent(new ImageDownloadEventArgs("", req, ImageDownloadEventType.Started));
if (fileExists)
{
File.Delete(fileName);
}
byte[] imageArray = null;
try
{
imageArray = JMMServerHelper.GetImage(entityID, req.ImageType, false);
}
catch { }
if (imageArray == null)
{
imagesToDownload.Remove(req);
OnQueueUpdateEvent(new QueueUpdateEventArgs(this.QueueCount));
return;
}
File.WriteAllBytes(tempName, imageArray);
// move the file to it's final location
string fullPath = Path.GetDirectoryName(fileName);
if (!Directory.Exists(fullPath))
{
Directory.CreateDirectory(fullPath);
}
// move the file to it's final location
File.Move(tempName, fileName);
}
OnImageDownloadEvent(new ImageDownloadEventArgs("", req, ImageDownloadEventType.Complete));
// if the file is a tvdb fanart also get the thumbnail
if (req.ImageType == ImageEntityType.TvDB_FanArt)
{
fileName = GetFileName(req, true);
entityID = GetEntityID(req);
downloadImage = true;
fileExists = File.Exists(fileName);
if (fileExists)
{
if (!req.ForceDownload)
{
downloadImage = false;
}
else
{
downloadImage = true;
}
}
else
{
downloadImage = true;
}
if (downloadImage)
{
string tempName = Path.Combine(Utils.GetImagesTempFolder(), Path.GetFileName(fileName));
if (File.Exists(tempName))
{
File.Delete(tempName);
}
OnImageDownloadEvent(new ImageDownloadEventArgs("", req, ImageDownloadEventType.Started));
if (fileExists)
{
File.Delete(fileName);
}
byte[] imageArray = null;
try
{
imageArray = JMMServerVM.Instance.imageClient.GetImage(entityID, (int)req.ImageType, true);
}
catch { }
if (imageArray == null)
{
imagesToDownload.Remove(req);
OnQueueUpdateEvent(new QueueUpdateEventArgs(this.QueueCount));
return;
}
File.WriteAllBytes(tempName, imageArray);
// move the file to it's final location
string fullPath = Path.GetDirectoryName(fileName);
if (!Directory.Exists(fullPath))
{
Directory.CreateDirectory(fullPath);
}
// move the file to it's final location
File.Move(tempName, fileName);
}
}
imagesToDownload.Remove(req);
OnQueueUpdateEvent(new QueueUpdateEventArgs(this.QueueCount));
//OnGotShowInfoEvent(new GotShowInfoEventArgs(req.animeID));
}
catch (Exception ex)
{
imagesToDownload.Remove(req);
OnQueueUpdateEvent(new QueueUpdateEventArgs(this.QueueCount));
BaseConfig.MyAnimeLog.Write(ex.ToString());
}
}
private void LoadData()
{
dummyAnyAnimeForMonth.Visible = false;
monthNow = new DateTime(MainWindow.CurrentCalendarYear, MainWindow.CurrentCalendarMonth, 1);
monthMinusOne = monthNow.AddMonths(-1);
monthMinusTwo = monthNow.AddMonths(-2);
monthMinusThree = monthNow.AddMonths(-3);
monthPlusOne = monthNow.AddMonths(1);
monthPlusTwo = monthNow.AddMonths(2);
monthPlusThree = monthNow.AddMonths(3);
setGUIProperty("Calendar.CurrentMonth", monthNow.ToString("MMM"));
setGUIProperty("Calendar.CurrentYear", monthNow.ToString("yyyy"));
setGUIProperty("Calendar.MinusOneMonth", monthMinusOne.ToString("MMM"));
setGUIProperty("Calendar.MinusOneYear", monthMinusOne.ToString("yyyy"));
setGUIProperty("Calendar.MinusTwoMonth", monthMinusTwo.ToString("MMM"));
setGUIProperty("Calendar.MinusTwoYear", monthMinusTwo.ToString("yyyy"));
setGUIProperty("Calendar.MinusThreeMonth", monthMinusThree.ToString("MMM"));
setGUIProperty("Calendar.MinusThreeYear", monthMinusThree.ToString("yyyy"));
setGUIProperty("Calendar.PlusOneMonth", monthPlusOne.ToString("MMM"));
setGUIProperty("Calendar.PlusOneYear", monthPlusOne.ToString("yyyy"));
setGUIProperty("Calendar.PlusTwoMonth", monthPlusTwo.ToString("MMM"));
setGUIProperty("Calendar.PlusTwoYear", monthPlusTwo.ToString("yyyy"));
setGUIProperty("Calendar.PlusThreeMonth", monthPlusThree.ToString("MMM"));
setGUIProperty("Calendar.PlusThreeYear", monthPlusThree.ToString("yyyy"));
// find the anime for this month
colAnime = JMMServerHelper.GetAnimeForMonthYear(monthNow.Month, monthNow.Year);
if (colAnime.Count > 0)
{
dummyAnyAnimeForMonth.Visible = true;
}
// now sort the groups by air date
List <SortPropOrFieldAndDirection> sortCriteria = new List <SortPropOrFieldAndDirection>();
sortCriteria.Add(new SortPropOrFieldAndDirection("AirDate", false, SortType.eDateTime));
colAnime = Sorting.MultiSort <AniDB_AnimeVM>(colAnime, sortCriteria);
//BaseConfig.MyAnimeLog.Write(monthNow.ToString("MMM yyyy").ToUpper());
GUIControl.ClearControl(this.GetID, m_Facade.GetID);
m_Facade.CurrentLayout = GUIFacadeControl.Layout.Filmstrip;
int selIndex = 0;
int pos = 0;
foreach (AniDB_AnimeVM anime in colAnime)
{
//BaseConfig.MyAnimeLog.Write(anime.ToString());
string imagePath = GUIGraphicsContext.Skin + @"\Media\MyAnime3\anime3_question_poster.png";
if (anime.DefaultPosterPath.Trim().Length > 0)
{
if (File.Exists(anime.DefaultPosterPath))
{
imagePath = anime.DefaultPosterPath;
}
}
if (anime.AnimeID == MainWindow.GlobalSeriesID)
{
selIndex = pos;
}
pos++;
GUIListItem item = new GUIListItem();
item.IconImage = item.IconImageBig = imagePath;
item.TVTag = anime;
item.OnItemSelected += new GUIListItem.ItemSelectedHandler(onFacadeItemSelected);
m_Facade.Add(item);
}
if (m_Facade.Count > 0)
{
//BaseConfig.MyAnimeLog.Write("selIndex: {0}", selIndex.ToString());
int currentIndex = m_Facade.SelectedListItemIndex;
if (selIndex >= 0 && selIndex < m_Facade.Count && selIndex != currentIndex)
{
int increment = (currentIndex < selIndex) ? 1 : -1;
MediaPortal.GUI.Library.Action.ActionType actionType = (currentIndex < selIndex) ? MediaPortal.GUI.Library.Action.ActionType.ACTION_MOVE_RIGHT : MediaPortal.GUI.Library.Action.ActionType.ACTION_MOVE_LEFT;
for (int i = currentIndex; i != selIndex; i += increment)
{
m_Facade.OnAction(new MediaPortal.GUI.Library.Action(actionType, 0, 0));
}
}
m_Facade.SelectedListItemIndex = selIndex;
AniDB_AnimeVM anime = m_Facade.SelectedListItem.TVTag as AniDB_AnimeVM;
if (anime != null)
{
SetAnime(anime);
}
}
// set the focus button
btnCurrentPlusOne.Focus = false;
switch (MainWindow.CurrentCalendarButton)
{
case 3: btnCurrentMinusOne.Focus = true; break;
case 4: btnCurrentPlusOne.Focus = true; break;
}
}
private void ShowCharacters()
{
GUIControl.ClearControl(this.GetID, m_Facade.GetID);
if (dummyMainCharExists != null)
{
dummyMainCharExists.Visible = false;
}
if (dummyMainActorExists != null)
{
dummyMainActorExists.Visible = false;
}
if (dummySeriesExists != null)
{
dummySeriesExists.Visible = false;
}
clearGUIProperty("Title");
clearGUIProperty("Character.Name");
clearGUIProperty("Character.KanjiName");
clearGUIProperty("Actor.Name");
clearGUIProperty("Actor.KanjiName");
clearGUIProperty("Character.CharacterCount");
BaseConfig.MyAnimeLog.Write("CharWindow.GlobalSeriesID = {0}", MainWindow.GlobalSeriesID.ToString());
charList.Clear();
mainAnime = null;
serMain = null;
serMain = JMMServerHelper.GetSeries(MainWindow.GlobalSeriesID);
if (serMain != null)
{
mainAnime = serMain.AniDB_Anime;
}
else
{
return;
}
if (mainAnime == null)
{
return;
}
setGUIProperty("Character.Main.Title", mainAnime.FormattedTitle);
charList = mainAnime.Characters;
if (dummyCharactersExist != null)
{
if (charList.Count > 0)
{
dummyCharactersExist.Visible = true;
}
else
{
dummyCharactersExist.Visible = false;
}
}
setGUIProperty("Character.CharacterCount", charList.Count.ToString());
setGUIProperty("Title", serMain.SeriesName);
string imagePathNoPicture = GUIGraphicsContext.Skin + @"\Media\MyAnime3\anime3_blankchar.png";
foreach (AniDB_CharacterVM aniChar in charList)
{
string imagePath = imagePathNoPicture;
if (!string.IsNullOrEmpty(aniChar.PosterPath) && File.Exists(aniChar.PosterPath))
{
imagePath = aniChar.PosterPath;
}
GUIListItem item = new GUIListItem("");
item.IconImage = item.IconImageBig = imagePath;
item.TVTag = aniChar;
item.OnItemSelected += new GUIListItem.ItemSelectedHandler(onFacadeItemSelected);
m_Facade.Add(item);
}
if (m_Facade.Count > 0)
{
m_Facade.SelectedListItemIndex = 0;
AniDB_CharacterVM aniChar = m_Facade.SelectedListItem.TVTag as AniDB_CharacterVM;
if (aniChar != null)
{
SetCharacterProperties(aniChar);
}
}
}
public static List <GroupFilterVM> GetGroupFiltersForPredefined(GroupFilterVM pre)
{
List <GroupFilterVM> gfs = new List <GroupFilterVM>();
if (pre.GroupFilterID.Value == Constants.StaticGF.Predefined_Years)
{
List <int> years = new List <int>();
List <JMMServerBinary.Contract_AnimeSeries> contracts = JMMServerVM.Instance.clientBinaryHTTP.GetAllSeries(JMMServerVM.Instance.CurrentUser.JMMUserID);
foreach (JMMServerBinary.Contract_AnimeSeries serContract in contracts)
{
AnimeSeriesVM ser = new AnimeSeriesVM(serContract);
int startYear = 0;
if (!ser.Stat_AirDate_Min.HasValue)
{
continue;
}
startYear = ser.Stat_AirDate_Min.Value.Year;
int endYear = DateTime.Now.AddYears(1).Year;
if (ser.Stat_AirDate_Max.HasValue)
{
endYear = ser.Stat_AirDate_Max.Value.Year;
}
for (int i = startYear; i <= endYear; i++)
{
if (!years.Contains(i))
{
years.Add(i);
}
}
}
years.Sort();
foreach (int yr in years)
{
GroupFilterVM gf = new GroupFilterVM();
gf.GroupFilterID = Constants.StaticGF.Predefined_Years_Child;
gf.FilterConditions = new List <GroupFilterConditionVM>();
gf.ApplyToSeries = 0;
gf.BaseCondition = 1;
gf.GroupFilterName = yr.ToString();
gf.PredefinedCriteria = yr.ToString();
gfs.Add(gf);
}
}
else if (pre.GroupFilterID.Value == Constants.StaticGF.Predefined_Categories)
{
List <string> categories = new List <string>();
List <AnimeGroupVM> grps = JMMServerHelper.GetAnimeGroupsForFilter(GroupFilterHelper.AllGroupsFilter);
foreach (AnimeGroupVM grp in grps)
{
foreach (string cat in grp.Categories)
{
if (!categories.Contains(cat) && !string.IsNullOrEmpty(cat))
{
categories.Add(cat);
}
}
}
categories.Sort();
foreach (string cat in categories)
{
GroupFilterVM gf = new GroupFilterVM();
gf.GroupFilterID = Constants.StaticGF.Predefined_Categories_Child;
gf.FilterConditions = new List <GroupFilterConditionVM>();
gf.ApplyToSeries = 0;
gf.BaseCondition = 1;
gf.GroupFilterName = cat;
gf.PredefinedCriteria = cat;
gfs.Add(gf);
}
}
return(gfs);
}
protected override void OnShowContextMenu()
{
try
{
GUIListItem currentitem = this.m_Facade.SelectedListItem;
if (currentitem == null || !(currentitem.TVTag is FanartContainer))
{
return;
}
FanartContainer selectedFanart = currentitem.TVTag as FanartContainer;
IDialogbox dlg = (IDialogbox)GUIWindowManager.GetWindow((int)GUIWindow.Window.WINDOW_DIALOG_MENU);
if (dlg == null)
{
return;
}
dlg.Reset();
dlg.SetHeading("Fanart");
GUIListItem pItem;
if (!selectedFanart.IsImageEnabled)
{
pItem = new GUIListItem("Enable");
dlg.Add(pItem);
}
else
{
pItem = new GUIListItem("Disable");
dlg.Add(pItem);
}
if (selectedFanart.IsImageEnabled)
{
if (selectedFanart.IsImageDefault)
{
pItem = new GUIListItem("Remove as Default");
dlg.Add(pItem);
}
else
{
pItem = new GUIListItem("Set as Default");
dlg.Add(pItem);
}
}
// lets show it
dlg.DoModal(GUIWindowManager.ActiveWindow);
if (dlg.SelectedId == 1) // enabled/disable
{
bool endis = !selectedFanart.IsImageEnabled;
JMMServerHelper.EnableDisableFanart(endis, selectedFanart, AnimeID);
ShowFanart();
return;
}
if (dlg.SelectedId == 2)
{
bool isdef = !selectedFanart.IsImageDefault;
JMMServerHelper.SetDefaultFanart(isdef, selectedFanart, AnimeID);
ShowFanart();
return;
}
}
catch (Exception ex)
{
BaseConfig.MyAnimeLog.Write("Exception in Fanart Chooser Context Menu: " + ex.Message + ex.StackTrace);
return;
}
}
public static List <TorrentLink> SearchTorrents(DownloadSearchCriteria search)
{
List <string> parms = search.GetParms();
List <TorrentLink> links = new List <TorrentLink>();
TorrentsAnimeSuki suki = new TorrentsAnimeSuki();
TorrentsBakaUpdates bakau = new TorrentsBakaUpdates();
List <string> episodeGroupParms = new List <string>();
// lets do something special for episodes
if (BaseConfig.Settings.TorrentPreferOwnGroups && search.SearchType == DownloadSearchType.Episode)
{
AnimeEpisodeVM ep = search.SearchParameter as AnimeEpisodeVM;
AnimeSeriesVM series = JMMServerHelper.GetSeries(ep.AnimeSeriesID);
if (series != null && series.AniDB_Anime != null)
{
List <GroupVideoQualityVM> videoQualityRecords = new List <GroupVideoQualityVM>();
List <JMMServerBinary.Contract_GroupVideoQuality> summ = JMMServerVM.Instance.clientBinaryHTTP.GetGroupVideoQualitySummary(series.AniDB_Anime.AnimeID);
foreach (JMMServerBinary.Contract_GroupVideoQuality contract in summ)
{
GroupVideoQualityVM vidQual = new GroupVideoQualityVM(contract);
videoQualityRecords.Add(vidQual);
}
// apply sorting
if (videoQualityRecords.Count > 0)
{
List <SortPropOrFieldAndDirection> sortlist = new List <SortPropOrFieldAndDirection>();
sortlist.Add(new SortPropOrFieldAndDirection("FileCountNormal", true, SortType.eInteger));
videoQualityRecords = Sorting.MultiSort <GroupVideoQualityVM>(videoQualityRecords, sortlist);
}
//only use the first 2
int i = 0;
foreach (GroupVideoQualityVM gvq in videoQualityRecords)
{
if (i == 2)
{
break;
}
if (!episodeGroupParms.Contains(gvq.GroupNameShort))
{
episodeGroupParms.Add(gvq.GroupNameShort);
i++;
}
}
}
}
// if searching by series and BakaBT is enabled, use that first
bool doneBakaBT = false;
if (BaseConfig.Settings.TorrentSources.Contains(MyAnimePlugin3.Constants.TorrentSourceNames.BakaBT) && search.SearchType == DownloadSearchType.Series)
{
doneBakaBT = true;
TorrentsBakaBT bakbt = new TorrentsBakaBT();
List <TorrentLink> bakbtLinks = bakbt.GetTorrents(parms);
links.AddRange(bakbtLinks);
}
bool doneAnimeBytes = false;
if (BaseConfig.Settings.TorrentSources.Contains(MyAnimePlugin3.Constants.TorrentSourceNames.AnimeBytes) && search.SearchType == DownloadSearchType.Series)
{
doneAnimeBytes = true;
TorrentsAnimeBytes abytes = new TorrentsAnimeBytes();
List <TorrentLink> abytesLinks = abytes.GetTorrents(parms);
links.AddRange(abytesLinks);
}
foreach (string src in BaseConfig.Settings.TorrentSources)
{
if (src == MyAnimePlugin3.Constants.TorrentSourceNames.BakaBT && !doneBakaBT)
{
TorrentsBakaBT bakbt = new TorrentsBakaBT();
List <TorrentLink> bakbtLinks = bakbt.GetTorrents(parms);
links.AddRange(bakbtLinks);
}
if (src == MyAnimePlugin3.Constants.TorrentSourceNames.BakaBT && !doneAnimeBytes)
{
TorrentsAnimeBytes abytes = new TorrentsAnimeBytes();
List <TorrentLink> abytesLinks = abytes.GetTorrents(parms);
links.AddRange(abytesLinks);
}
if (src == MyAnimePlugin3.Constants.TorrentSourceNames.Nyaa)
{
TorrentsNyaa nyaa = new TorrentsNyaa();
List <TorrentLink> ttLinks = null;
Dictionary <string, TorrentLink> dictLinks = new Dictionary <string, TorrentLink>();
foreach (string grp in episodeGroupParms)
{
List <string> tempParms = new List <string>();
foreach (string parmTemp in parms)
{
tempParms.Add(parmTemp);
}
tempParms.Insert(0, grp);
ttLinks = nyaa.GetTorrents(tempParms);
BaseConfig.MyAnimeLog.Write("Searching for: " + search.ToString() + "(" + grp + ")");
// only use the first 20
int x = 0;
foreach (TorrentLink link in ttLinks)
{
if (x == 20)
{
break;
}
dictLinks[link.TorrentDownloadLink] = link;
BaseConfig.MyAnimeLog.Write("Adding link: " + link.ToString());
}
}
BaseConfig.MyAnimeLog.Write("Searching for: " + search.ToString());
ttLinks = nyaa.GetTorrents(parms);
foreach (TorrentLink link in ttLinks)
{
dictLinks[link.TorrentDownloadLink] = link;
BaseConfig.MyAnimeLog.Write("Adding link: " + link.ToString());
}
links.AddRange(dictLinks.Values);
}
if (src == MyAnimePlugin3.Constants.TorrentSourceNames.AnimeSuki)
{
List <TorrentLink> sukiLinks = suki.GetTorrents(parms);
links.AddRange(sukiLinks);
}
if (src == MyAnimePlugin3.Constants.TorrentSourceNames.TT)
{
TorrentsTokyoToshokan tt = new TorrentsTokyoToshokan();
List <TorrentLink> ttLinks = null;
Dictionary <string, TorrentLink> dictLinks = new Dictionary <string, TorrentLink>();
foreach (string grp in episodeGroupParms)
{
List <string> tempParms = new List <string>();
foreach (string parmTemp in parms)
{
tempParms.Add(parmTemp);
}
tempParms.Insert(0, grp);
ttLinks = tt.GetTorrents(tempParms);
BaseConfig.MyAnimeLog.Write("Searching for: " + search.ToString() + "(" + grp + ")");
// only use the first 20
int x = 0;
foreach (TorrentLink link in ttLinks)
{
if (x == 20)
{
break;
}
dictLinks[link.TorrentDownloadLink] = link;
BaseConfig.MyAnimeLog.Write("Adding link: " + link.ToString());
}
}
BaseConfig.MyAnimeLog.Write("Searching for: " + search.ToString());
ttLinks = tt.GetTorrents(parms);
foreach (TorrentLink link in ttLinks)
{
dictLinks[link.TorrentDownloadLink] = link;
BaseConfig.MyAnimeLog.Write("Adding link: " + link.ToString());
}
links.AddRange(dictLinks.Values);
}
if (src == MyAnimePlugin3.Constants.TorrentSourceNames.BakaUpdates)
{
List <TorrentLink> bakauLinks = bakau.GetTorrents(parms);
links.AddRange(bakauLinks);
}
}
return(links);
}
protected override void OnClicked(int controlId, GUIControl control, MediaPortal.GUI.Library.Action.ActionType actionType)
{
if (MA3WindowManager.HandleWindowChangeButton(control))
{
return;
}
if (btnAddCategory != null && control == btnAddCategory)
{
string cat = Utils.PromptSelectCategory("");
if (!string.IsNullOrEmpty(cat))
{
if (!string.IsNullOrEmpty(MainWindow.RandomWindow_SeriesCategories))
{
MainWindow.RandomWindow_SeriesCategories += ", ";
}
MainWindow.RandomWindow_SeriesCategories += cat;
SetDisplayDetails();
}
}
if (btnEpisodeAddCategory != null && control == btnEpisodeAddCategory)
{
string cat = Utils.PromptSelectCategory("");
if (!string.IsNullOrEmpty(cat))
{
if (!string.IsNullOrEmpty(MainWindow.RandomWindow_EpisodeCategories))
{
MainWindow.RandomWindow_EpisodeCategories += ", ";
}
MainWindow.RandomWindow_EpisodeCategories += cat;
SetDisplayDetails();
}
}
if (btnClearcategories != null && control == btnClearcategories)
{
MainWindow.RandomWindow_SeriesCategories = "";
SetDisplayDetails();
}
if (btnEpisodeClearcategories != null && control == btnEpisodeClearcategories)
{
MainWindow.RandomWindow_EpisodeCategories = "";
SetDisplayDetails();
}
if (btnAllAnycategories != null && control == btnAllAnycategories)
{
MainWindow.RandomWindow_SeriesAllCategories = !MainWindow.RandomWindow_SeriesAllCategories;
SetDisplayDetails();
}
if (btnEpisodeAllAnycategories != null && control == btnEpisodeAllAnycategories)
{
MainWindow.RandomWindow_EpisodeAllCategories = !MainWindow.RandomWindow_EpisodeAllCategories;
SetDisplayDetails();
}
if (btnRandom != null && control == btnRandom)
{
if (togWatched != null)
{
MainWindow.RandomWindow_SeriesWatched = togWatched.Selected;
}
if (togUnwatched != null)
{
MainWindow.RandomWindow_SeriesUnwatched = togUnwatched.Selected;
}
if (togPartiallyWatched != null)
{
MainWindow.RandomWindow_SeriesPartiallyWatched = togPartiallyWatched.Selected;
}
if (togCompleteOnly != null)
{
MainWindow.RandomWindow_SeriesOnlyComplete = togCompleteOnly.Selected;
}
if (togEpisodeUnwatched != null)
{
MainWindow.RandomWindow_EpisodeUnwatched = togEpisodeUnwatched.Selected;
}
if (togEpisodeWatched != null)
{
MainWindow.RandomWindow_EpisodeWatched = togEpisodeWatched.Selected;
}
MainWindow.RandomWindow_CurrentEpisode = null;
MainWindow.RandomWindow_CurrentSeries = null;
this.btnRandom.IsFocused = true;
LoadData();
}
if (btnSwitchSeries != null && control == btnSwitchSeries)
{
this.btnSwitchSeries.IsFocused = false;
this.btnRandom.IsFocused = true;
MainWindow.RandomWindow_RandomType = RandomObjectType.Series;
LoadData();
}
if (btnSwitchEpisode != null && control == btnSwitchEpisode)
{
this.btnSwitchEpisode.IsFocused = false;
this.btnRandom.IsFocused = true;
MainWindow.RandomWindow_RandomType = RandomObjectType.Episode;
LoadData();
}
if (btnPlayEpisode != null && control == btnPlayEpisode)
{
if (MainWindow.RandomWindow_CurrentEpisode == null)
{
return;
}
MainWindow.vidHandler.ResumeOrPlay(MainWindow.RandomWindow_CurrentEpisode);
}
if (btnEpisodeList != null && control == btnEpisodeList)
{
if (MainWindow.RandomWindow_CurrentSeries == null)
{
return;
}
MainWindow.curGroupFilter = GroupFilterHelper.AllGroupsFilter;
// find the group for this series
AnimeGroupVM grp = JMMServerHelper.GetGroup(MainWindow.RandomWindow_CurrentSeries.AnimeGroupID);
if (grp == null)
{
BaseConfig.MyAnimeLog.Write("Group not found");
return;
}
MainWindow.curAnimeGroup = grp;
MainWindow.curAnimeGroupViewed = grp;
MainWindow.curAnimeSeries = MainWindow.RandomWindow_CurrentSeries;
bool foundEpType = false;
foreach (AnimeEpisodeTypeVM anEpType in MainWindow.RandomWindow_CurrentSeries.EpisodeTypesToDisplay)
{
if (anEpType.EpisodeType == enEpisodeType.Episode)
{
MainWindow.curAnimeEpisodeType = anEpType;
foundEpType = true;
break;
}
}
if (!foundEpType)
{
return;
}
MainWindow.listLevel = Listlevel.Episode;
GUIWindowManager.CloseCurrentWindow();
GUIWindowManager.ActivateWindow(Constants.WindowIDs.MAIN, false);
return;
}
base.OnClicked(controlId, control, actionType);
}
private void LoadGroups()
{
string mygroupsData = "";
string othergroupsData = "";
List <AniDBReleaseGroupVM> allGrps = JMMServerHelper.GetReleaseGroupsForAnime(MainAnime.AnimeID);
List <AniDBReleaseGroupVM> mygrps = new List <AniDBReleaseGroupVM>();
List <AniDBReleaseGroupVM> othergrps = new List <AniDBReleaseGroupVM>();
foreach (AniDBReleaseGroupVM grp in allGrps)
{
if (grp.UserCollecting)
{
mygrps.Add(grp);
}
else
{
othergrps.Add(grp);
}
}
if (mygrps.Count > 0)
{
// now sort the groups by file count
List <SortPropOrFieldAndDirection> sortCriteria = new List <SortPropOrFieldAndDirection>();
sortCriteria.Add(new SortPropOrFieldAndDirection("FileCount", true, SortType.eInteger));
mygrps = Sorting.MultiSort <AniDBReleaseGroupVM>(mygrps, sortCriteria);
foreach (AniDBReleaseGroupVM grp in mygrps)
{
mygroupsData += string.Format("{0} - ({1} Local Files)", grp.GroupName, grp.FileCount);
mygroupsData += Environment.NewLine;
}
}
else
{
mygroupsData = "-";
}
setGUIProperty("AnimeInfo.Groups.MyGroupsDescription", mygroupsData);
if (othergrps.Count > 0)
{
// now sort the groups by name
List <SortPropOrFieldAndDirection> sortCriteria = new List <SortPropOrFieldAndDirection>();
sortCriteria.Add(new SortPropOrFieldAndDirection("GroupName", false, SortType.eString));
othergrps = Sorting.MultiSort <AniDBReleaseGroupVM>(othergrps, sortCriteria);
foreach (AniDBReleaseGroupVM grp in othergrps)
{
othergroupsData += string.Format("{0} - Episode Range: {1}", grp.GroupName, grp.EpisodeRange);
othergroupsData += Environment.NewLine;
}
}
else
{
othergroupsData = "-";
}
setGUIProperty("AnimeInfo.Groups.OtherGroupsDescription", othergroupsData);
}
