/JMMClient/JMMClient/MainWindow.xaml.cs

Large files files are truncated, but you can click here to view the full file

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Windows;

using System.Windows.Controls;

using System.Windows.Data;

using System.Windows.Documents;

using System.Windows.Input;

using System.Windows.Media;

using System.Windows.Media.Imaging;

using System.Windows.Navigation;

using System.Windows.Shapes;

using System.ComponentModel;

using System.Diagnostics;

using System.Globalization;

using System.Threading;

using System.Resources;

using JMMClient.Properties;

using JMMClient.ViewModel;

using Infralution.Localization.Wpf;

using System.Configuration;

using JMMClient.ImageDownload;

using System.Windows.Threading;

using System.ServiceModel;

using JMMClient.Forms;

using System.IO;

using NLog;

using System.Collections.ObjectModel;

using JMMClient.UserControls;

using JMMClient.Downloads;

using JMMClient.Utilities;



namespace JMMClient

{

	/// <summary>

	/// Interaction logic for MainWindow.xaml

	/// </summary>

	public partial class MainWindow : Window

	{

		private static Logger logger = LogManager.GetCurrentClassLogger();



		public static readonly int TAB_MAIN_Dashboard = 0;

		public static readonly int TAB_MAIN_Collection = 1;

		public static readonly int TAB_MAIN_Playlists = 2;

		public static readonly int TAB_MAIN_Bookmarks = 3;

		public static readonly int TAB_MAIN_Server = 4;

		public static readonly int TAB_MAIN_FileManger = 5;

		public static readonly int TAB_MAIN_Settings = 6;

		public static readonly int TAB_MAIN_Pinned = 7;

		public static readonly int TAB_MAIN_Downloads = 8;

		public static readonly int TAB_MAIN_Search = 9;



		public static int CurrentMainTabIndex = TAB_MAIN_Dashboard;



		private static readonly int TAB_FileManger_Unrecognised = 0;

		private static readonly int TAB_FileManger_Ignored = 1;

		private static readonly int TAB_FileManger_ManuallyLinked = 2;

		private static readonly int TAB_FileManger_DuplicateFiles = 3;

		private static readonly int TAB_FileManger_MultipleFiles = 4;

		private static readonly int TAB_FileManger_MissingMyList = 5;

		private static readonly int TAB_FileManger_SeriesNoFiles = 6;

		private static readonly int TAB_FileManger_MissingEps = 7;

		private static readonly int TAB_FileManger_IgnoredAnime = 8;

		private static readonly int TAB_FileManger_Avdump = 9;

		private static readonly int TAB_FileManger_FileSearch = 10;

		private static readonly int TAB_FileManger_Rename = 11;

		private static readonly int TAB_FileManger_UpdateData = 12;

		private static readonly int TAB_FileManger_Rankings = 13;



		public static readonly int TAB_Settings_Essential = 0;

		public static readonly int TAB_Settings_AniDB = 1;

		public static readonly int TAB_Settings_TvDB = 2;

		public static readonly int TAB_Settings_WebCache = 3;

		public static readonly int TAB_Settings_Display = 4;



		private static System.Timers.Timer postStartTimer = null;



		private int lastFileManagerTab = TAB_FileManger_Unrecognised;



		public static GroupFilterVM groupFilterVM = null;

		public static List<UserCulture> userLanguages = new List<UserCulture>();

		public static ImageDownloader imageHelper = null;

		

		private AnimeGroupVM groupBeforeChanges = null;

		private GroupFilterVM groupFilterBeforeChanges = null;



		BackgroundWorker showChildWrappersWorker = new BackgroundWorker();

		BackgroundWorker refreshGroupsWorker = new BackgroundWorker();

		BackgroundWorker downloadImagesWorker = new BackgroundWorker();

		BackgroundWorker toggleStatusWorker = new BackgroundWorker();

		BackgroundWorker moveSeriesWorker = new BackgroundWorker();



		BackgroundWorker showDashboardWorker = new BackgroundWorker();



		public static VideoHandler videoHandler = new VideoHandler();



		public MainWindow()

		{

			try

			{

				InitializeComponent();

			}

            catch(Exception ex)

            {

                File.WriteAllText(@"C:\jmmerror.txt", ex.ToString());

            }



			try

			{

				UnhandledExceptionManager.AddHandler();



				//AppSettings.DebugSettingsToLog();



				lbGroupsSeries.MouseDoubleClick += new MouseButtonEventHandler(lbGroupsSeries_MouseDoubleClick);

				lbGroupsSeries.SelectionChanged += new SelectionChangedEventHandler(lbGroupsSeries_SelectionChanged);

				this.grdMain.LayoutUpdated += new EventHandler(grdMain_LayoutUpdated);

				this.LayoutUpdated += new EventHandler(MainWindow_LayoutUpdated);



				lbPlaylists.SelectionChanged += new SelectionChangedEventHandler(lbPlaylists_SelectionChanged);







				showChildWrappersWorker.DoWork += new DoWorkEventHandler(showChildWrappersWorker_DoWork);

				showChildWrappersWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(showChildWrappersWorker_RunWorkerCompleted);



				downloadImagesWorker.DoWork += new DoWorkEventHandler(downloadImagesWorker_DoWork);



				refreshGroupsWorker.DoWork += new DoWorkEventHandler(refreshGroupsWorker_DoWork);

				refreshGroupsWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(refreshGroupsWorker_RunWorkerCompleted);



				toggleStatusWorker.DoWork += new DoWorkEventHandler(toggleStatusWorker_DoWork);

				toggleStatusWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(toggleStatusWorker_RunWorkerCompleted);



				moveSeriesWorker.DoWork += new DoWorkEventHandler(moveSeriesWorker_DoWork);

				moveSeriesWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(moveSeriesWorker_RunWorkerCompleted);



				txtGroupSearch.TextChanged += new TextChangedEventHandler(txtGroupSearch_TextChanged);



				showDashboardWorker.DoWork += new DoWorkEventHandler(showDashboardWorker_DoWork);

				showDashboardWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(showDashboardWorker_RunWorkerCompleted);



				MainListHelperVM.Instance.ViewGroups.Filter = GroupSearchFilter;

				cboLanguages.SelectionChanged += new SelectionChangedEventHandler(cboLanguages_SelectionChanged);



				if (MainListHelperVM.Instance.SeriesSearchTextBox == null) MainListHelperVM.Instance.SeriesSearchTextBox = seriesSearch.txtSeriesSearch;



				//grdSplitEps.DragCompleted += new System.Windows.Controls.Primitives.DragCompletedEventHandler(grdSplitEps_DragCompleted);





				imageHelper = new ImageDownloader();

				imageHelper.Init();



				videoHandler.Init();

				//videoHandler.HandleFileChange(AppSettings.MPCFolder + "\\mpc-hc.ini");



				InitCulture();



				imageHelper.QueueUpdateEvent += new ImageDownloader.QueueUpdateEventHandler(imageHelper_QueueUpdateEvent);



				cboGroupSort.Items.Clear();

				foreach (string sType in GroupFilterHelper.GetAllSortTypes())

					cboGroupSort.Items.Add(sType);

				cboGroupSort.SelectedIndex = 0;

				btnToolbarSort.Click += new RoutedEventHandler(btnToolbarSort_Click);



				tabControl1.SelectionChanged += new SelectionChangedEventHandler(tabControl1_SelectionChanged);

				tabFileManager.SelectionChanged += new SelectionChangedEventHandler(tabFileManager_SelectionChanged);

				tabSettingsChild.SelectionChanged += new SelectionChangedEventHandler(tabSettingsChild_SelectionChanged);



				this.Loaded += new RoutedEventHandler(MainWindow_Loaded);

				this.StateChanged += new EventHandler(MainWindow_StateChanged);



				// Have commented this out because it is no good when Desktop and Server are sharing

				// the same base image path

				//DeleteAvatarImages();



				this.AddHandler(CloseableTabItem.CloseTabEvent, new RoutedEventHandler(this.CloseTab));



				btnUpdateMediaInfo.Click += new RoutedEventHandler(btnUpdateMediaInfo_Click);

				btnAbout.Click += new RoutedEventHandler(btnAbout_Click);

				btnClearHasherQueue.Click += new RoutedEventHandler(btnClearHasherQueue_Click);

				btnClearGeneralQueue.Click += new RoutedEventHandler(btnClearGeneralQueue_Click);

				btnClearServerImageQueue.Click += new RoutedEventHandler(btnClearServerImageQueue_Click);



				JMMServerVM.Instance.BaseImagePath = Utils.GetBaseImagesPath();



				// timer for automatic updates

				postStartTimer = new System.Timers.Timer();

				postStartTimer.AutoReset = false;

				postStartTimer.Interval = 5 * 1000; // 15 seconds

				postStartTimer.Elapsed += new System.Timers.ElapsedEventHandler(postStartTimer_Elapsed);



				btnSwitchUser.Click += new RoutedEventHandler(btnSwitchUser_Click);



				//videoHandler.HandleFileChange(@"C:\Program Files (x86)\Combined Community Codec Pack\MPC\mpc-hc.ini");



				MainWindow.videoHandler.VideoWatchedEvent += new VideoHandler.VideoWatchedEventHandler(videoHandler_VideoWatchedEvent);



				if (AppSettings.DashboardType == DashboardType.Normal)

					dash.Visibility = System.Windows.Visibility.Visible;

				else

					dashMetro.Visibility = System.Windows.Visibility.Visible;





				UserSettingsVM.Instance.SetDashMetro_Image_Width();

			}

			catch (Exception ex)

			{

				logger.ErrorException(ex.ToString(), ex);

			}

		}



		void btnSwitchUser_Click(object sender, RoutedEventArgs e)

		{

			// authenticate user

			if (JMMServerVM.Instance.ServerOnline)

			{

				if (JMMServerVM.Instance.AuthenticateUser())

				{

					MainListHelperVM.Instance.ClearData();

					MainListHelperVM.Instance.ShowChildWrappers(null);



					RecentAdditionsType addType = RecentAdditionsType.Episode;

					if (dash.cboDashRecentAdditionsType.SelectedIndex == 0) addType = RecentAdditionsType.Episode;

					if (dash.cboDashRecentAdditionsType.SelectedIndex == 1) addType = RecentAdditionsType.Series;



					RefreshOptions opt = new RefreshOptions();

					opt.TraktScrobbles = dash.togTraktScrobbles.IsChecked.Value;

					opt.TraktShouts = dash.togTraktShouts.IsChecked.Value;

					opt.RecentAdditionType = addType;

					opt.RefreshRecentAdditions = true;

					opt.RefreshContinueWatching = true;

					opt.RefreshOtherWidgets = true;

					showDashboardWorker.RunWorkerAsync(opt);



					tabControl1.SelectedIndex = TAB_MAIN_Dashboard;

				}

			}

		}



		void videoHandler_VideoWatchedEvent(VideoWatchedEventArgs ev)

		{

			if (tabControl1.SelectedIndex == TAB_MAIN_Collection || tabControl1.SelectedIndex == TAB_MAIN_Pinned)

			{

				



				//RefreshView();

			}

		}



		void btnClearServerImageQueue_Click(object sender, RoutedEventArgs e)

		{

			try

			{

				this.Cursor = Cursors.Wait;

				JMMServerVM.Instance.clientBinaryHTTP.ClearImagesQueue();

			}

			catch (Exception ex)

			{

				Utils.ShowErrorMessage(ex);

			}

			this.Cursor = Cursors.Arrow;

		}



		void btnClearGeneralQueue_Click(object sender, RoutedEventArgs e)

		{

			try

			{

				this.Cursor = Cursors.Wait;

				JMMServerVM.Instance.clientBinaryHTTP.ClearGeneralQueue();

			}

			catch (Exception ex)

			{

				Utils.ShowErrorMessage(ex);

			}

			this.Cursor = Cursors.Arrow;

		}



		void btnClearHasherQueue_Click(object sender, RoutedEventArgs e)

		{

			try

			{

				this.Cursor = Cursors.Wait;

				JMMServerVM.Instance.clientBinaryHTTP.ClearHasherQueue();

			}

			catch (Exception ex)

			{

				Utils.ShowErrorMessage(ex);

			}

			this.Cursor = Cursors.Arrow;

		}



		void btnAbout_Click(object sender, RoutedEventArgs e)

		{

			AboutForm frm = new AboutForm();

			frm.Owner = this;

			frm.ShowDialog();

		}



		



		void btnUpdateMediaInfo_Click(object sender, RoutedEventArgs e)

		{

			try

			{

				JMMServerVM.Instance.clientBinaryHTTP.RefreshAllMediaInfo();

				MessageBox.Show("Process is Running", "Success", MessageBoxButton.OK, MessageBoxImage.Information);

			}

			catch (Exception ex)

			{

				Utils.ShowErrorMessage(ex);

			}

		}



		private void DeleteAvatarImages()

		{

			try

			{

				string path = Utils.GetTraktImagePath_Avatars();

				if (!Directory.Exists(path)) return;



				string[] imageFiles = Directory.GetFiles(path, "*.jpg");

				foreach (string filename in imageFiles)

					File.Delete(filename);

			}

			catch { }

		}



		private void CloseTab(object source, RoutedEventArgs args)

		{

			System.Windows.Controls.TabItem tabItem = args.Source as System.Windows.Controls.TabItem;

			if (tabItem != null)

			{

				System.Windows.Controls.TabControl tabControl = tabItem.Parent as System.Windows.Controls.TabControl;

				if (tabControl != null)

					tabControl.Items.Remove(tabItem);

			}

		}

		



		void MainWindow_StateChanged(object sender, EventArgs e)

		{

			//if (this.WindowState == System.Windows.WindowState.Minimized) this.Hide();



			if (this.WindowState == System.Windows.WindowState.Normal || this.WindowState == System.Windows.WindowState.Maximized)

				AppSettings.DefaultWindowState = this.WindowState;

		}





		void MainWindow_Loaded(object sender, RoutedEventArgs e)

		{

			//this.WindowState = AppSettings.DefaultWindowState;



			if (AppSettings.WindowFullScreen)

				SetWindowFullscreen();

			else

				SetWindowNormal();



			Utils.ClearAutoUpdateCache();



			// validate settings

			JMMServerVM.Instance.Test();



			bool loggedIn = false;

			if (JMMServerVM.Instance.ServerOnline)

				loggedIn = JMMServerVM.Instance.LoginAsLastUser();



			if (!loggedIn)

			{

				// authenticate user

				if (JMMServerVM.Instance.ServerOnline && !JMMServerVM.Instance.AuthenticateUser())

				{

					this.Close();

					return;

				}

			}



			if (JMMServerVM.Instance.ServerOnline)

			{

				tabControl1.SelectedIndex = TAB_MAIN_Dashboard;

				DisplayMainTab(TAB_MAIN_Dashboard);

				DownloadAllImages();

			}

			else

				tabControl1.SelectedIndex = TAB_MAIN_Settings;





			System.Reflection.Assembly a = System.Reflection.Assembly.GetExecutingAssembly();

			if (a != null)

			{

				JMMServerVM.Instance.ApplicationVersion = Utils.GetApplicationVersion(a);

			}



			UTorrentHelperVM.Instance.ValidateCredentials();



			postStartTimer.Start();

		



		}



		void postStartTimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)

		{

			postStartTimer.Stop();



			UTorrentHelperVM.Instance.Init();



			System.Windows.Application.Current.Dispatcher.Invoke(System.Windows.Threading.DispatcherPriority.Normal, (Action)delegate()

			{

				automaticUpdater.ForceCheckForUpdate(true);

			});



			if (JMMServerVM.Instance.ServerOnline)

				DownloadAllImages();

		}

		



		void MainWindow_LayoutUpdated(object sender, EventArgs e)

		{

			// Why am I doing this?

			// Basically there is weird problem if you try and set the content control's width to the exact

			// ViewportWidth of the parent scroller.

			// On some resolutions, when you maximise the window it will cause UI glitches

			// By setting it slightly less than the max width, these problems go away

			try

			{

				//Debug.Print("Scroller width = {0}", Scroller.ActualWidth);

				//Debug.Print("Scroller ViewportWidth = {0}", Scroller.ViewportWidth);



				double tempWidth = ccDetail.ActualWidth - 8;

				double tempHeight = ccDetail.ActualHeight - 8;

				if (tempWidth > 0)

				{

					MainListHelperVM.Instance.MainScrollerWidth = tempWidth;

				}



				tempWidth = tabControl1.ActualWidth - 20;

				//tempWidth = tabControl1.ActualWidth - 300;

				if (tempWidth > 0)

					MainListHelperVM.Instance.FullScrollerWidth = tempWidth;



				tempHeight = tabControl1.ActualHeight - 50;

				if (tempHeight > 0)

					MainListHelperVM.Instance.FullScrollerHeight = tempHeight;





				tempWidth = ScrollerPlaylist.ViewportWidth - 8;

				if (tempWidth > 0)

					MainListHelperVM.Instance.PlaylistScrollerWidth = tempWidth;



				tempWidth = tabcDownloads.ActualWidth - 130;

				if (tempWidth > 0)

					MainListHelperVM.Instance.DownloadRecScrollerWidth = tempWidth;





			}

			catch (Exception ex)

			{

				logger.ErrorException(ex.ToString(), ex);

			}

			

		}



		void tabFileManager_SelectionChanged(object sender, SelectionChangedEventArgs e)

		{

			try

			{

				if (e.Source is System.Windows.Controls.TabControl)

				{

					System.Windows.Controls.TabControl tab = e.Source as System.Windows.Controls.TabControl;

					this.Cursor = Cursors.Wait;

					if (tab.SelectedIndex == TAB_FileManger_Unrecognised)

					{

						if (unRecVids.UnrecognisedFiles.Count == 0) unRecVids.RefreshUnrecognisedFiles();

						if (unRecVids.AllSeries.Count == 0) unRecVids.RefreshSeries();

						lastFileManagerTab = TAB_FileManger_Unrecognised;

					}



					if (tab.SelectedIndex == TAB_FileManger_Ignored)

					{

						if (ignoredFiles.IgnoredFilesCollection.Count == 0) ignoredFiles.RefreshIgnoredFiles();

						lastFileManagerTab = TAB_FileManger_Ignored;

					}



					if (tab.SelectedIndex == TAB_FileManger_ManuallyLinked)

					{

						if (linkedFiles.ManuallyLinkedFiles.Count == 0) linkedFiles.RefreshLinkedFiles();

						lastFileManagerTab = TAB_FileManger_ManuallyLinked;

					}



					if (tab.SelectedIndex == TAB_FileManger_DuplicateFiles)

					{

						if (duplicateFiles.DuplicateFilesCollection.Count == 0) duplicateFiles.RefreshDuplicateFiles();

						lastFileManagerTab = TAB_FileManger_DuplicateFiles;

					}

					if (tab.SelectedIndex == TAB_FileManger_MultipleFiles)

					{

						//if (multipleFiles.CurrentEpisodes.Count == 0) multipleFiles.RefreshMultipleFiles();

						lastFileManagerTab = TAB_FileManger_MultipleFiles;

					}



					if (tab.SelectedIndex == TAB_FileManger_Rename)

					{

						if (fileRenaming.RenameScripts.Count == 0) fileRenaming.RefreshScripts();

						lastFileManagerTab = TAB_FileManger_Rename;

					}



					if (tab.SelectedIndex == TAB_FileManger_Rankings)

					{

						if (rankings.AllAnime.Count == 0) rankings.Init();

						lastFileManagerTab = TAB_FileManger_Rankings;

					}

					this.Cursor = Cursors.Arrow;

				}

			}

			catch (Exception ex)

			{

				Utils.ShowErrorMessage(ex);

			}



		}



		void showDashboardWorker_DoWork(object sender, DoWorkEventArgs e)

		{

			RefreshOptions opt = e.Argument as RefreshOptions;



			DashboardVM.Instance.RefreshData(opt.TraktScrobbles, opt.TraktShouts, opt.RefreshContinueWatching, opt.RefreshRecentAdditions, 

				opt.RefreshOtherWidgets, opt.RecentAdditionType);

		}



		void showDashboardWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)

		{

			this.Cursor = Cursors.Arrow;

			tabControl1.IsEnabled = true;

		}



		private void DisplayMainTab(int tabIndex)

		{

			try

			{

				CurrentMainTabIndex = tabIndex;



				if (tabIndex == TAB_MAIN_Dashboard)

				{

					if (dash.Visibility == System.Windows.Visibility.Visible)

					{

						if (DashboardVM.Instance.EpsWatchNext_Recent.Count == 0 && DashboardVM.Instance.SeriesMissingEps.Count == 0

							&& DashboardVM.Instance.MiniCalendar.Count == 0 && DashboardVM.Instance.RecommendationsWatch.Count == 0

							&& DashboardVM.Instance.RecommendationsDownload.Count == 0)

						{

							tabControl1.IsEnabled = false;

							this.Cursor = Cursors.Wait;



							RecentAdditionsType addType = RecentAdditionsType.Episode;

							if (dash.cboDashRecentAdditionsType.SelectedIndex == 0) addType = RecentAdditionsType.Episode;

							if (dash.cboDashRecentAdditionsType.SelectedIndex == 1) addType = RecentAdditionsType.Series;



							RefreshOptions opt = new RefreshOptions();

							opt.TraktScrobbles = dash.togTraktScrobbles.IsChecked.Value;

							opt.TraktShouts = dash.togTraktShouts.IsChecked.Value;

							opt.RecentAdditionType = addType;

							opt.RefreshRecentAdditions = true;

							opt.RefreshContinueWatching = true;

							opt.RefreshOtherWidgets = true;

							showDashboardWorker.RunWorkerAsync(opt);



						}

					}

					else

					{

						if (DashboardMetroVM.Instance.ContinueWatching.Count == 0)

							dashMetro.RefreshAllData();

					}

				}



				if (tabIndex == TAB_MAIN_Collection)

				{

					if (MainListHelperVM.Instance.AllGroups.Count == 0)

					{

						MainListHelperVM.Instance.RefreshGroupsSeriesData();

					}



					if (MainListHelperVM.Instance.CurrentWrapper == null && lbGroupsSeries.Items.Count == 0)

					{

						MainListHelperVM.Instance.SearchTextBox = txtGroupSearch;

						MainListHelperVM.Instance.CurrentGroupFilter = MainListHelperVM.Instance.AllGroupFilter;

						MainListHelperVM.Instance.ShowChildWrappers(MainListHelperVM.Instance.CurrentWrapper);

						lbGroupsSeries.SelectedIndex = 0;

					}

				}





				if (tabIndex == TAB_MAIN_FileManger)

				{

					if (unRecVids.UnrecognisedFiles.Count == 0) unRecVids.RefreshUnrecognisedFiles();



				}



				if (tabIndex == TAB_MAIN_Playlists)

				{

					if (PlaylistHelperVM.Instance.Playlists == null || PlaylistHelperVM.Instance.Playlists.Count == 0) PlaylistHelperVM.Instance.RefreshData();

					if (lbPlaylists.Items.Count > 0 && lbPlaylists.SelectedIndex < 0)

						lbPlaylists.SelectedIndex = 0;



				}



				if (tabIndex == TAB_MAIN_Bookmarks)

				{

					if (MainListHelperVM.Instance.BookmarkedAnime == null || MainListHelperVM.Instance.BookmarkedAnime.Count == 0) MainListHelperVM.Instance.RefreshBookmarkedAnime();



					if (ucBookmarks.lbBookmarks.Items.Count > 0)

						ucBookmarks.lbBookmarks.SelectedIndex = 0;



				}



				if (tabIndex == TAB_MAIN_Search)

				{

					if (MainListHelperVM.Instance.AllSeries == null || MainListHelperVM.Instance.AllSeries.Count == 0) MainListHelperVM.Instance.RefreshGroupsSeriesData();

				}



				if (tabIndex == TAB_MAIN_Server)

				{

					if (JMMServerVM.Instance.ImportFolders.Count == 0) JMMServerVM.Instance.RefreshImportFolders();

				}



				if (tabIndex == TAB_MAIN_Settings)

				{

					if (JMMServerVM.Instance.ImportFolders.Count == 0) JMMServerVM.Instance.RefreshImportFolders();

					if (JMMServerVM.Instance.SelectedLanguages.Count == 0) JMMServerVM.Instance.RefreshNamingLanguages();

					if (JMMServerVM.Instance.AllUsers.Count == 0) JMMServerVM.Instance.RefreshAllUsers();

					if (JMMServerVM.Instance.AllCategories.Count == 0) JMMServerVM.Instance.RefreshAllCategories();

				}



				if (tabIndex == TAB_MAIN_Downloads)

				{

					if (UserSettingsVM.Instance.SelectedTorrentSources.Count == 0 || UserSettingsVM.Instance.UnselectedTorrentSources.Count == 0)

						UserSettingsVM.Instance.RefreshTorrentSources();

				}

			}

			catch (Exception ex)

			{

				Utils.ShowErrorMessage(ex);

				tabControl1.IsEnabled = true;

			}

		}



		void tabControl1_SelectionChanged(object sender, SelectionChangedEventArgs e)

		{

			try

			{

				SetColours();



				//if (!this.IsLoaded || !JMMServerVM.Instance.UserAuthenticated) return;

				if (!JMMServerVM.Instance.UserAuthenticated) return;





				TabControl tab = e.Source as TabControl;

				if (tab == null) return;



				if (!tab.Name.Equals("tabControl1", StringComparison.InvariantCultureIgnoreCase)) return;



				DisplayMainTab(tabControl1.SelectedIndex);



			}

			catch (Exception ex)

			{

				Utils.ShowErrorMessage(ex);

				tabControl1.IsEnabled = true;

			}

		}



		void tabSettingsChild_SelectionChanged(object sender, SelectionChangedEventArgs e)

		{

			try

			{

				if (e.Source is System.Windows.Controls.TabControl)

				{

					System.Windows.Controls.TabControl tab = e.Source as System.Windows.Controls.TabControl;

					if (tab.SelectedIndex == TAB_Settings_Display)

					{

						if (JMMServerVM.Instance.SelectedLanguages.Count == 0) JMMServerVM.Instance.RefreshNamingLanguages();

					}

					

				}

			}

			catch (Exception ex)

			{

				Utils.ShowErrorMessage(ex);

			}

		}



		void btnToolbarSort_Click(object sender, RoutedEventArgs e)

		{

			MainListHelperVM.Instance.ViewGroups.SortDescriptions.Clear();

			GroupFilterSorting sortType = GroupFilterHelper.GetEnumForText_Sorting(cboGroupSort.SelectedItem.ToString());

			MainListHelperVM.Instance.ViewGroups.SortDescriptions.Add(GroupFilterHelper.GetSortDescription(sortType, GroupFilterSortDirection.Asc));

		}



		



		void imageHelper_QueueUpdateEvent(QueueUpdateEventArgs ev)

		{

			try

			{

				this.Dispatcher.BeginInvoke(DispatcherPriority.Normal, new System.Windows.Forms.MethodInvoker(delegate()

				{

					tbImageDownloadQueueStatus.Text = ev.queueCount.ToString();

				}));

			}

			catch (Exception ex)

			{

				Utils.ShowErrorMessage(ex);

			}

		}





		void cboLanguages_SelectionChanged(object sender, SelectionChangedEventArgs e)

		{

			SetCulture();

		}



		private void InitCulture()

		{

			try

			{

				string currentCulture = AppSettings.Culture;



				cboLanguages.ItemsSource = UserCulture.SupportedLanguages;



				for (int i = 0; i < cboLanguages.Items.Count; i++)

				{

					UserCulture ul = cboLanguages.Items[i] as UserCulture;

					if (ul.Culture.Trim().ToUpper() == currentCulture.Trim().ToUpper())

					{

						cboLanguages.SelectedIndex = i;

						break;

					}



				}

				if (cboLanguages.SelectedIndex < 0)

					cboLanguages.SelectedIndex = 0;

			}

			catch (Exception ex)

			{

				Utils.ShowErrorMessage(ex);

			}



		}



		private void SetCulture()

		{

			if (cboLanguages.SelectedItem == null) return;

			UserCulture ul = cboLanguages.SelectedItem as UserCulture;



			try

			{

				CultureInfo ci = new CultureInfo(ul.Culture);

				CultureManager.UICulture = ci;



				AppSettings.Culture = ul.Culture;

			}

			catch (Exception ex)

			{

				Utils.ShowErrorMessage(ex);

			}



		}



		void txtGroupSearch_TextChanged(object sender, TextChangedEventArgs e)

		{

			try

			{

				SetDetailBinding(null);



				// move to all groups

				if (MainListHelperVM.Instance.CurrentWrapper == null)

					MainListHelperVM.Instance.ShowAllGroups();

				



				MainListHelperVM.Instance.ViewGroups.Refresh();

			}

			catch (Exception ex)

			{

				Utils.ShowErrorMessage(ex);

			}

		}



		private bool GroupSearchFilter(object obj)

		{

			MainListWrapper grp = obj as MainListWrapper;

			if (grp == null) return true;



			if (obj.GetType() != typeof(AnimeGroupVM) && obj.GetType() != typeof(AnimeSeriesVM))

				return true;



			// first evaluate the group filter

			// if the group doesn't match the group filter we won't continue

			if (obj.GetType() == typeof(AnimeGroupVM))

			{

				AnimeGroupVM grpvm = obj as AnimeGroupVM;

				//if (!GroupSearchFilterHelper.EvaluateGroupFilter(MainListHelperVM.Instance.CurrentGroupFilter, grpvm)) return false;



				return GroupSearchFilterHelper.EvaluateGroupTextSearch(grpvm, txtGroupSearch.Text);

			}



			if (obj.GetType() == typeof(AnimeSeriesVM))

			{

				AnimeSeriesVM ser = obj as AnimeSeriesVM;

				//if (!GroupSearchFilterHelper.EvaluateGroupFilter(MainListHelperVM.Instance.CurrentGroupFilter, ser)) return false;



				return GroupSearchFilterHelper.EvaluateSeriesTextSearch(ser, txtGroupSearch.Text);

			}



			return true;

		}



		void refreshGroupsWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)

		{

			showChildWrappersWorker.RunWorkerAsync(MainListHelperVM.Instance.CurrentWrapper);

		}



		void refreshGroupsWorker_DoWork(object sender, DoWorkEventArgs e)

		{

			try

			{

				MainListHelperVM.Instance.RefreshGroupsSeriesData();

				DownloadAllImages();

			}

			catch (Exception ex)

			{

				Utils.ShowErrorMessage(ex);

			}

		}



		void showChildWrappersWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)

		{

			try

			{

				EnableDisableGroupControls(true);

				if (lbGroupsSeries.Items.Count > 0)

				{

					HighlightMainListItem();

				}

				else

					SetDetailBinding(null);

			}

			catch (Exception ex)

			{

				Utils.ShowErrorMessage(ex);

			}

		}



		void showChildWrappersWorker_DoWork(object sender, DoWorkEventArgs e)

		{

			try

			{

				MainListHelperVM.Instance.ShowChildWrappers(e.Argument as MainListWrapper);

			}

			catch (Exception ex)

			{

				Utils.ShowErrorMessage(ex);

			}

		}



		void toggleStatusWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)

		{

			EnableDisableGroupControls(true);

			this.Cursor = Cursors.Arrow;

		}



		

		void toggleStatusWorker_DoWork(object sender, DoWorkEventArgs e)

		{

			try

			{

				object obj = e.Argument;

				AnimeSeriesVM ser = null;

				bool newStatus = false;



				if (obj.GetType() == typeof(VideoDetailedVM))

				{

					VideoDetailedVM vid = obj as VideoDetailedVM;

					newStatus = !vid.Watched;

					JMMServerVM.Instance.clientBinaryHTTP.ToggleWatchedStatusOnVideo(vid.VideoLocalID, newStatus, JMMServerVM.Instance.CurrentUser.JMMUserID.Value);



					MainListHelperVM.Instance.UpdateHeirarchy(vid);



					ser = MainListHelperVM.Instance.GetSeriesForVideo(vid.VideoLocalID);

				}



				if (obj.GetType() == typeof(AnimeEpisodeVM))

				{

					AnimeEpisodeVM ep = obj as AnimeEpisodeVM;

					newStatus = !ep.Watched;

					JMMServerBinary.Contract_ToggleWatchedStatusOnEpisode_Response response = JMMServerVM.Instance.clientBinaryHTTP.ToggleWatchedStatusOnEpisode(ep.AnimeEpisodeID,

						newStatus, JMMServerVM.Instance.CurrentUser.JMMUserID.Value);

					if (!string.IsNullOrEmpty(response.ErrorMessage))

					{

						MessageBox.Show(response.ErrorMessage, "Error", MessageBoxButton.OK, MessageBoxImage.Error);

						return;

					}



					MainListHelperVM.Instance.UpdateHeirarchy(response.AnimeEpisode);



					ser = MainListHelperVM.Instance.GetSeriesForEpisode(ep);

				}



				if (newStatus == true && ser != null)

				{

					Utils.PromptToRateSeries(ser, this);

				}

			}

			catch (Exception ex)

			{

				Utils.ShowErrorMessage(ex);

			}

		}



		void moveSeriesWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)

		{

			EnableDisableGroupControls(true);

			SetDetailBinding(null);

			MainListHelperVM.Instance.RefreshGroupsSeriesData();

			MainListHelperVM.Instance.ShowChildWrappers(MainListHelperVM.Instance.CurrentWrapper);

			this.Cursor = Cursors.Arrow;



			MainListHelperVM.Instance.ViewGroups.Refresh();

			showChildWrappersWorker.RunWorkerAsync(MainListHelperVM.Instance.CurrentWrapper);

		}



		void moveSeriesWorker_DoWork(object sender, DoWorkEventArgs e)

		{

			try

			{

				object obj = e.Argument;

				if (obj.GetType() != typeof(MoveSeriesDetails)) return;



				MoveSeriesDetails request = obj as MoveSeriesDetails;

				DateTime start = DateTime.Now;



				//request.UpdatedSeries.Save();

				JMMServerBinary.Contract_AnimeSeries_SaveResponse response = 

					JMMServerVM.Instance.clientBinaryHTTP.MoveSeries(request.UpdatedSeries.AnimeSeriesID.Value, request.UpdatedSeries.AnimeGroupID,

					JMMServerVM.Instance.CurrentUser.JMMUserID.Value);

				if (!string.IsNullOrEmpty(response.ErrorMessage))

				{

					this.Cursor = Cursors.Arrow;

					MessageBox.Show(response.ErrorMessage);

					return;

				}

				else

				{

					request.UpdatedSeries.Populate(response.AnimeSeries);

				}





				



				// update all the attached groups



				/*Dictionary<int, JMMServerBinary.Contract_AnimeGroup> grpsDict = new Dictionary<int, JMMServerBinary.Contract_AnimeGroup>();

				List<JMMServerBinary.Contract_AnimeGroup> grps = JMMServerVM.Instance.clientBinaryHTTP.GetAllGroupsAboveGroupInclusive(request.UpdatedSeries.AnimeGroupID,

					JMMServerVM.Instance.CurrentUser.JMMUserID.Value);

				List<JMMServerBinary.Contract_AnimeGroup> grpsOld = JMMServerVM.Instance.clientBinaryHTTP.GetAllGroupsAboveGroupInclusive(request.OldAnimeGroupID,

					JMMServerVM.Instance.CurrentUser.JMMUserID.Value);



				foreach (JMMServerBinary.Contract_AnimeGroup tempGrp in grps)

					grpsDict[tempGrp.AnimeGroupID] = tempGrp;



				foreach (JMMServerBinary.Contract_AnimeGroup tempGrp in grpsOld)

					grpsDict[tempGrp.AnimeGroupID] = tempGrp;

				

				foreach (AnimeGroupVM grp in MainListHelperVM.Instance.AllGroups)

				{

					if (grpsDict.ContainsKey(grp.AnimeGroupID.Value))

					{

						grp.Populate(grpsDict[grp.AnimeGroupID.Value]);

					}



				}

				TimeSpan ts = DateTime.Now - start;

				Console.Write(ts.TotalMilliseconds);*/





				

			}

			catch (Exception ex)

			{

				Utils.ShowErrorMessage(ex);

			}

		}



		private void DownloadAllImages()

		{

			//if (!downloadImagesWorker.IsBusy)

			//	downloadImagesWorker.RunWorkerAsync();

		}



		void downloadImagesWorker_DoWork(object sender, DoWorkEventArgs e)

		{

			// 1. Download posters from AniDB

			List<JMMServerBinary.Contract_AniDBAnime> contracts = JMMServerVM.Instance.clientBinaryHTTP.GetAllAnime();



			int i = 0;

			foreach (JMMServerBinary.Contract_AniDBAnime anime in contracts)

			{

				//Thread.Sleep(5); // don't use too many resources

				imageHelper.DownloadAniDBCover(new AniDB_AnimeVM(anime), false);

				i++;



				//if (i == 80) break;

			}



			// 2. Download posters from TvDB

			List<JMMServerBinary.Contract_TvDB_ImagePoster> posters = JMMServerVM.Instance.clientBinaryHTTP.GetAllTvDBPosters(null);

			foreach (JMMServerBinary.Contract_TvDB_ImagePoster poster in posters)

			{

				//Thread.Sleep(5); // don't use too many resources

				imageHelper.DownloadTvDBPoster(new TvDB_ImagePosterVM(poster), false);

			}



			// 2a. Download posters from MovieDB

			List<JMMServerBinary.Contract_MovieDB_Poster> moviePosters = JMMServerVM.Instance.clientBinaryHTTP.GetAllMovieDBPosters(null);

			foreach (JMMServerBinary.Contract_MovieDB_Poster poster in moviePosters)

			{

				//Thread.Sleep(5); // don't use too many resources

				imageHelper.DownloadMovieDBPoster(new MovieDB_PosterVM(poster), false);

			}



			// 3. Download wide banners from TvDB

			List<JMMServerBinary.Contract_TvDB_ImageWideBanner> banners = JMMServerVM.Instance.clientBinaryHTTP.GetAllTvDBWideBanners(null);

			foreach (JMMServerBinary.Contract_TvDB_ImageWideBanner banner in banners)

			{

				//Thread.Sleep(5); // don't use too many resources

				imageHelper.DownloadTvDBWideBanner(new TvDB_ImageWideBannerVM(banner), false);

			}



			// 4. Download fanart from TvDB

			List<JMMServerBinary.Contract_TvDB_ImageFanart> fanarts = JMMServerVM.Instance.clientBinaryHTTP.GetAllTvDBFanart(null);

			foreach (JMMServerBinary.Contract_TvDB_ImageFanart fanart in fanarts)

			{

				//Thread.Sleep(5); // don't use too many resources

				imageHelper.DownloadTvDBFanart(new TvDB_ImageFanartVM(fanart), false);

			}



			// 4a. Download fanart from MovieDB

			List<JMMServerBinary.Contract_MovieDB_Fanart> movieFanarts = JMMServerVM.Instance.clientBinaryHTTP.GetAllMovieDBFanart(null);

			foreach (JMMServerBinary.Contract_MovieDB_Fanart fanart in movieFanarts)

			{

				//Thread.Sleep(5); // don't use too many resources

				imageHelper.DownloadMovieDBFanart(new MovieDB_FanartVM(fanart), false);

			}



			// 5. Download episode images from TvDB

			List<JMMServerBinary.Contract_TvDB_Episode> eps = JMMServerVM.Instance.clientBinaryHTTP.GetAllTvDBEpisodes(null);

			foreach (JMMServerBinary.Contract_TvDB_Episode episode in eps)

			{

				//Thread.Sleep(5); // don't use too many resources

				imageHelper.DownloadTvDBEpisode(new TvDB_EpisodeVM(episode), false);

			}



			// 6. Download posters from Trakt

			List<JMMServerBinary.Contract_Trakt_ImagePoster> traktPosters = JMMServerVM.Instance.clientBinaryHTTP.GetAllTraktPosters(null);

			foreach (JMMServerBinary.Contract_Trakt_ImagePoster traktposter in traktPosters)

			{

				//Thread.Sleep(5); // don't use too many resources

				if (string.IsNullOrEmpty(traktposter.ImageURL)) continue;

				imageHelper.DownloadTraktPoster(new Trakt_ImagePosterVM(traktposter), false);

			}



			// 7. Download fanart from Trakt

			List<JMMServerBinary.Contract_Trakt_ImageFanart> traktFanarts = JMMServerVM.Instance.clientBinaryHTTP.GetAllTraktFanart(null);

			foreach (JMMServerBinary.Contract_Trakt_ImageFanart traktFanart in traktFanarts)

			{

				//Thread.Sleep(5); // don't use too many resources

				if (string.IsNullOrEmpty(traktFanart.ImageURL)) continue;

				imageHelper.DownloadTraktFanart(new Trakt_ImageFanartVM(traktFanart), false);

			}



			// 8. Download episode images from Trakt

			List<JMMServerBinary.Contract_Trakt_Episode> traktEpisodes = JMMServerVM.Instance.clientBinaryHTTP.GetAllTraktEpisodes(null);

			foreach (JMMServerBinary.Contract_Trakt_Episode traktEp in traktEpisodes)

			{

				//Thread.Sleep(5); // don't use too many resources

				if (string.IsNullOrEmpty(traktEp.EpisodeImage)) continue;



				// special case for trak episodes

				// Trakt will return the fanart image when no episode image exists, but we don't want this

				int pos = traktEp.EpisodeImage.IndexOf(@"episodes/");

				if (pos <= 0) continue;



				//logger.Trace("Episode image: {0} - {1}/{2}", traktEp.Trakt_ShowID, traktEp.Season, traktEp.EpisodeNumber);



				imageHelper.DownloadTraktEpisode(new Trakt_EpisodeVM(traktEp), false);

			}

		}



		private void RefreshView()

		{

			if (!JMMServerVM.Instance.ServerOnline) return;



			EnableDisableGroupControls(false);



			try

			{

				this.Cursor = Cursors.Wait;



				// we are look at all the group filters

				if (MainListHelperVM.Instance.CurrentWrapper == null)

				{

					MainListHelperVM.Instance.SearchTextBox = txtGroupSearch;

					MainListHelperVM.Instance.CurrentGroupFilter = MainListHelperVM.Instance.AllGroupFilter;



					//refreshGroupsWorker.RunWorkerAsync(null);



					MainListHelperVM.Instance.RefreshGroupsSeriesData();

					DownloadAllImages();



					MainListHelperVM.Instance.ShowChildWrappers(MainListHelperVM.Instance.CurrentWrapper);

				}



				// we are inside one of the group filters, groups or series

				if (MainListHelperVM.Instance.CurrentWrapper != null)

				{

					// refresh the groups and series data

					refreshGroupsWorker.RunWorkerAsync(null);



					// refresh the episodes

					if (lbGroupsSeries.SelectedItem is AnimeSeriesVM)

					{

						AnimeSeriesVM ser = lbGroupsSeries.SelectedItem as AnimeSeriesVM;

						ser.RefreshEpisodes();

					}

				}

			}

			catch (Exception ex)

			{

				Utils.ShowErrorMessage(ex);

				EnableDisableGroupControls(true);

			}

			finally

			{

				this.Cursor = Cursors.Arrow;

				EnableDisableGroupControls(true);

			}

		}



		



		#region Command Bindings



		private void CommandBinding_EditTraktCredentials(object sender, ExecutedRoutedEventArgs e)

		{

			tabControl1.SelectedIndex = TAB_MAIN_Settings;

			tabSettingsChild.SelectedIndex = TAB_Settings_TvDB;

		}



		public void ShowPinnedFileAvDump(VideoLocalVM vid)

		{

			try

			{

				foreach (AVDumpVM dumpTemp in MainListHelperVM.Instance.AVDumpFiles)

				{

					if (dumpTemp.FullPath == vid.FullPath) return;

				}



				AVDumpVM dump = new AVDumpVM(vid);

				MainListHelperVM.Instance.AVDumpFiles.Add(dump);



				tabControl1.SelectedIndex = TAB_MAIN_FileManger;

				tabFileManager.SelectedIndex = TAB_FileManger_Avdump;



			}

			catch (Exception ex)

			{

				Utils.ShowErrorMessage(ex);

			}

		}



		public void ShowPinnedSeries(AnimeSeriesVM series)

		{

			this.Cursor = Cursors.Wait;



			CloseableTabItem cti = new CloseableTabItem();

			//TabItem cti = new TabItem();

			cti.Header = series.SeriesName;



			//AnimeSeries_Hulu seriesControl = new AnimeSeries_Hulu();

			AnimeSeries seriesControl = new AnimeSeries();

			seriesControl.DataContext = series;

			cti.Content = seriesControl;



			tabPinned.Items.Add(cti);



			tabControl1.SelectedIndex = TAB_MAIN_Pinned;

			tabPinned.SelectedIndex = tabPinned.Items.Count - 1;



			this.Cursor = Cursors.Arrow;

		}



		/*public void ToggleDashMetroStyle()

		{

			if (dash.Visibility == System.Windows.Visibility.Collapsed)

			{

				dash.Visibility = System.Windows.Visibility.Visible;

				dashMetro.Visibility = System.Windows.Visibility.Collapsed;

				DisplayMainTab(TAB_MAIN_Dashboard);

				AppSettings.DashboardType = DashboardType.Normal;

			}

			else

			{

				dash.Visibility = System.Windows.Visibility.Collapsed;

				dashMetro.Visibility = System.Windows.Visibility.Visible;

				DisplayMainTab(TAB_MAIN_Dashboard);

				AppSettings.DashboardType = DashboardType.Metro;

			}



			SetColours();

		}*/



		private void SetColours()

		{

			if (tabControl1.SelectedIndex == TAB_MAIN_Dashboard)

			{

				if (dash.Visibility == System.Windows.Visibility.Visible)

				{

					tabControl1.Background = new SolidColorBrush(Colors.Transparent);

				}

				else

				{

					var bc = new BrushConverter();

					tabControl1.Background = (Brush)bc.ConvertFrom("#F1F1F1");

					//tabControl1.Background = new SolidColorBrush(Colors.LightGray);

				}

			}

			else

				tabControl1.Background = new SolidColorBrush(Colors.Transparent);

		}



		public void ShowDashMetroView(MetroViews viewType, object data)

		{

			tileContinueWatching.Visibility = System.Windows.Visibility.Collapsed;

			dash.Visibility = System.Windows.Visibility.Collapsed;

			dashMetro.Visibility = System.Windows.Visibility.Collapsed;



			switch (viewType)

			{

				case MetroViews.MainNormal:

					dash.Visibility = System.Windows.Visibility.Visible;

					DisplayMainTab(TAB_MAIN_Dashboard);

					AppSettings.DashboardType = DashboardType.Normal;

					break;

				case MetroViews.MainMetro:

					dashMetro.Visibility = System.Windows.Visibility.Visible;

					DisplayMainTab(TAB_MAIN_Dashboard);

					AppSettings.DashboardType = DashboardType.Metro;

					break;

				case MetroViews.ContinueWatching:

					tileContinueWatching.Visibility = System.Windows.Visibility.Visible;

					tileContinueWatching.DataContext = data;

					break;

			}



			SetColours();

		}



		public void ShowDashMetroView(MetroViews viewType)

		{

			ShowDashMetroView(viewType, null);

		}



		private void CommandBinding_CreateSeriesFromAnime(object sender, ExecutedRoutedEventArgs e)

		{

			object obj = e.Parameter;

			if (obj == null) return;



			try

			{

				if (obj.GetType() == typeof(AniDB_AnimeVM) || obj.GetType() == typeof(AniDB_Anime_SimilarVM))

				{

					AniDB_AnimeVM anime = null;



					if (obj.GetType() == typeof(AniDB_AnimeVM))

						anime = (AniDB_AnimeVM)obj;



					if (obj.GetType() == typeof(AniDB_Anime_SimilarVM))

						anime = ((AniDB_Anime_SimilarVM)obj).AniDB_Anime;



					// check if a series already exists

					bool seriesExists = JMMServerVM.Instance.clientBinaryHTTP.GetSeriesExistingForAnime(anime.AnimeID);

					if (seriesExists)

					{

						MessageBox.Show(Properties.Resources.ERROR_SeriesExists, "Error", MessageBoxButton.OK, MessageBoxImage.Error);

						return;

					}



					NewSeries frmNewSeries = new NewSeries();

					frmNewSeries.Owner = this;

					frmNewSeries.Init(anime, anime.FormattedTitle);



					bool? result = frmNewSeries.ShowDialog();

					if (result.HasValue && result.Value == true)

					{



					}

				}

				else

				{

					NewSeries frm = new NewSeries();

					frm.Owner = this;

					frm.Init(0, "");

					bool? result = frm.ShowDialog();

					if (result.HasValue && result.Value == true)

					{

						

					}

				}

				

			}

			catch (Exception ex)

			{

				Utils.ShowErrorMessage(ex);

			}

		}



		private void CommandBinding_AvdumpFile(object sender, ExecutedRoutedEventArgs e)

		{

			try

			{

				Window parentWindow = Window.GetWindow(this);



				object obj = e.Parameter;

				if (obj == null) return;



				if (obj.GetType() == typeof(VideoLocalVM))

				{

					VideoLocalVM vid = obj as VideoLocalVM;



					foreach (AVDumpVM dumpTemp in MainListHelperVM.Instance.AVDumpFiles)

					{

						if (dumpTemp.FullPath == vid.FullPath) return;

					}



					AVDumpVM dump = new AVDumpVM(vid);

					MainListHelperVM.Instance.AVDumpFiles.Add(dump);

					

				}



				if (obj.GetType() == typeof(MultipleVideos))

				{

					MultipleVideos mv = obj as MultipleVideos;

					foreach (VideoLocalVM vid in mv.VideoLocals)

					{

						bool alreadyExists = false;

						foreach (AVDumpVM dumpTemp in MainListHelperVM.Instance.AVDumpFiles)

						{

							if (dumpTemp.FullPath == vid.FullPath)

							{

								alreadyExists = true;

								break;

							}



						}



						if (alreadyExists) continue;



						AVDumpVM dump = new AVDumpVM(vid);

						MainListHelperVM.Instance.AVDumpFiles.Add(dump);

					}

				}



				tabControl1.SelectedIndex = TAB_MAIN_FileManger;

				tabFileManager.SelectedIndex = TAB_FileManger_Avdump;



			}

			catch (Exception ex)

			{

				Utils.ShowErrorMessage(ex);

			}



		}



		private void CommandBinding_BookmarkAnime(object sender, ExecutedRoutedEventArgs e)

		{

			Window parentWindow = Window.GetWindow(this);



			object obj = e.Parameter;

			if (obj == null) return;



			try

			{

				if (obj.GetType() == typeof(RecommendationVM))

				{

					RecommendationVM rec = obj as RecommendationVM;

					if (rec == null) return;



					BookmarkedAnimeVM bookmark = new BookmarkedAnimeVM();

					bookmark.AnimeID = rec.RecommendedAnimeID;

					bookmark.Downloading = 0;

					bookmark.Notes = "";

					bookmark.Priority = 1;

					if (bookmark.Save())

						MainListHelperVM.Instance.RefreshBookmarkedAnime();

						

				}



				if (obj.GetType() == typeof(MissingEpisodeVM))

				{

					MissingEpisodeVM rec = obj as MissingEpisodeVM;

					if (rec == null) return;



					BookmarkedAnimeVM bookmark = new BookmarkedAnimeVM();

					bookmark.AnimeID = rec.AnimeID;

					bookmark.Downloading = 0;

					bookmark.Notes = "";

					bookmark.Priority = 1;

					if (bookmark.Save())

						MainListHelperVM.Instance.RefreshBookmarkedAnime();

				}



				if (obj.GetType() == typeof(AniDB_AnimeVM))

				{

					AniDB_AnimeVM rec = obj as AniDB_AnimeVM;

					if (rec == null) return;



					BookmarkedAnimeVM bookmark = new BookmarkedAnimeVM();

					bookmark.AnimeID = rec.AnimeID;

					bookmark.Downloading = 0;

					bookmark.Notes = "";

					bookmark.Priority = 1;

					if (bookmark.Save())

						MainListHelperVM.Instance.RefreshBookmarkedAnime();

				}



				if (obj.GetType() == typeof(AniDB_Anime_SimilarVM))

				{

					AniDB_Anime_SimilarVM sim = (AniDB_Anime_SimilarVM)obj;



					BookmarkedAnimeVM bookmark = new BookmarkedAnimeVM();

					bookmark.AnimeID = sim.SimilarAnimeID;

					bookmark.Downloading = 0;

					bookmark.Notes = "";

					bookmark.Priority = 1;

					if (bookmark.Save())

						MainListHelperVM.Instance.RefreshBookmarkedAnime();

				}



				if (obj.GetType() == typeof(AniDB_Anime_RelationVM))

				{

					AniDB_Anime_RelationVM rel = (AniDB_Anime_RelationVM)obj;



					BookmarkedAnimeVM bookmark = new BookmarkedAnimeVM();

					bookmark.AnimeID = rel.RelatedAnimeID;

					bookmark.Downloading = 0;

					bookmark.Notes = "";

					bookmark.Priority = 1;

					if (bookmark.Save())

						MainListHelperVM.Instance.RefreshBookmarkedAnime();

				}

			}

			catch (Exception ex)

			{

				Utils.ShowErrorMessage(ex);

			}

		}



		private void CommandBinding_RefreshBookmarks(object sender, ExecutedRoutedEventArgs e)

		{

			Window parentWindow = Window.GetWindow(this);



			try

			{

				MainListHelperVM.Instance.RefreshBookmarkedAnime();

			}

			catch (Exception ex)

			{

				Utils.ShowErrorMessage(ex);

			}

		}



		public void ShowTorrentSearch(DownloadSearchCriteria crit)

		{

			this.Cursor = Cursors.Wait;



			tabControl1.SelectedIndex  = TAB_MAIN_Downloads;

			tabcDownloads.SelectedIndex = 1;

			ucTorrentSearch.PerformSearch(crit);



			this.Cursor = Cursors.Arrow;

		}



		private void CommandBinding_ShowTorrentSearch(object sender, ExecutedRoutedEventArgs e)

		{

			//object obj = lbGroupsSeries.SelectedItem;

			object obj = e.Parameter;

			if (obj == null) return;



			try

			{

				if (obj.GetType() == typeof(AnimeEpisodeVM))

				{

					AnimeEpisodeVM ep = (AnimeEpisodeVM)obj;

					DownloadSearchCriteria crit = new DownloadSearchCriteria(DownloadSearchType.Episode, ep);

					ShowTorrentSearch(crit);

				}



				if (obj.GetType() == typeof(MissingEpisodeVM))

				{

					MissingEpisodeVM rec = obj as MissingEpisodeVM;

					if (rec == null) return;



					JMMServerBinary.Contract_AnimeEpisode contract = JMMServerVM.Instance.clientBinaryHTTP.GetEpisodeByAniDBEpisodeID(rec.EpisodeID, 

						JMMServerVM.Instance.CurrentUser.JMMUserID.Value);

					if (contract != null)

					{

						DownloadSearchCriteria crit = new DownloadSearchCriteria(DownloadSearchType.Episode, new AnimeEpisodeVM(contract));

						ShowTorrentSearch(crit);

					}

				}



				/*if (obj.GetType() == typeof(MissingFileVM))

				{

					MissingFileVM mis = (MissingFileVM)obj;

					ShowPinnedSeries(mis.AnimeSeries);

				}*/





				if (obj.GetType() == typeof(RecommendationVM))

				{

					RecommendationVM rec = obj as RecommendationVM;

					if (rec == null) return;



					DownloadSearchCriteria crit = new DownloadSearchCriteria(DownloadSearchType.Series, rec.Recommended_AniDB_Anime);

					ShowTorrentSearch(crit);

				}



				if (obj.GetType() == typeof(AniDB_AnimeVM))

				{

					AniDB_AnimeVM anime = (AniDB_AnimeVM)obj;

					DownloadSearchCriteria crit = new DownloadSearchCriteria(DownloadSearchType.Series, anime);

					ShowTorrentSearch(crit);

				}



				if (obj.GetType() == typeof(AnimeSeriesVM))

				{

					AnimeSeriesVM ser = (AnimeSeriesVM)obj;

					DownloadSearchCriteria crit = new DownloadSearchCriteria(DownloadSearchType.Series, ser.AniDB_Anime);

					ShowTorrentSearch(crit);

				}



				if (obj.GetType() == typeof(AniDB_Anime_SimilarVM))

				{

					AniDB_Anime_SimilarVM sim = (AniDB_Anime_SimilarVM)obj;

					DownloadSearchCriteria crit = new DownloadSearchCriteria(DownloadSearchType.Series, sim.AniDB_Anime);

					ShowTorrentSearch(crit);

				}



				if (obj.GetType() == typeof(AniDB_Anime_RelationVM))

				{

					AniDB_Anime_RelationVM rel = (AniDB_Anime_RelationVM)obj;

					DownloadSearchCriteria crit = new DownloadSearchCriteria(DownloadSearchType.Series, rel.AniDB_Anime);

					ShowTorrentSearch(crit);

				}



				if (obj.GetType() == typeof(BookmarkedAnimeVM))

				{

					BookmarkedAnimeVM ba = (BookmarkedAnimeVM)obj;

					DownloadSearchCriteria crit = new Dow…