/**

 * MainWindow.xaml.cs

 * 

 * The logic behind the main window. Contains

 * the code that connects the different part

 * of Stoffi. Sort of like the spider in the net.

 * 

 * * * * * * * * *

 * 

 * This code is part of the Stoffi Music Player Project.

 * Visit our website at: stoffiplayer.com

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version

 * 3 of the License, or (at your option) any later version.

 * 

 * See stoffiplayer.com/license for more information.

 **/



using GlassLib;

using System;

using System.ComponentModel;

using System.Collections;

using System.Collections.ObjectModel;

using System.Collections.Generic;

using System.Collections.Specialized;

using System.Configuration;

using System.Windows.Data;

using System.Globalization;

using System.IO;

using System.Reflection;

using System.Threading;

using System.Windows;

using System.Windows.Controls;

using System.Windows.Input;

using System.Windows.Media;

using System.Windows.Media.Imaging;

using System.Windows.Threading;

using System.Windows.Interop;

using System.Windows.Shell;

using Hardcodet.Wpf.TaskbarNotification;

using Microsoft.WindowsAPICodePack.Dialogs;

using Microsoft.Win32;

using Tomers.WPF.Localization;



namespace Stoffi

{

	/// <summary>

	/// Interaction logic for MainWindow.xaml

	/// </summary>

	public partial class StoffiWindow : Window, INotifyPropertyChanged

	{

		#region Members



		private KeyboardListener kListener = new KeyboardListener();

		public ContextMenu trayMenu;

		public MenuItem trayMenuShow;

		public MenuItem trayMenuPlay;

		public MenuItem trayMenuNext;

		public MenuItem trayMenuPrev;

		public MenuItem trayMenuExit;

		private ContextMenu addMenu;

		public MenuItem addMenuFile;

		public MenuItem addMenuFolder;

		public MenuItem addMenuPlaylist;

		private ContextMenu showMenu;

		public MenuItem showMenuDetailsPane;

		public MenuItem showMenuMenuBar;

		private ContextMenu toolsMenu;

		public MenuItem toolsMenuImporter;

		public MenuItem toolsMenuExporter;

		public MenuItem toolsMenuGenerate;

		public Microsoft.WindowsAPICodePack.Taskbar.ThumbnailToolbarButton taskbarPrev;

		public Microsoft.WindowsAPICodePack.Taskbar.ThumbnailToolbarButton taskbarPlay;

		public Microsoft.WindowsAPICodePack.Taskbar.ThumbnailToolbarButton taskbarNext;

		public TaskbarIcon trayIcon;

		private WindowState oldWindowState = WindowState.Minimized;

		private WindowState currentWindowState = WindowState.Normal;

		public System.Windows.Shell.JumpList jumpList;

		public System.Windows.Shell.JumpTask jumpTaskPlay;

		public System.Windows.Shell.JumpTask jumpTaskNext;

		public System.Windows.Shell.JumpTask jumpTaskPrev;

		private bool glassEffect = true;

		private List<Key> currentPressedKeys = new List<Key>();

		public Microsoft.WindowsAPICodePack.Taskbar.TabbedThumbnail taskbarPreview;

		private EditableTextBlock etbInEdit = null;

		private Equalizer equalizer = null;

		private DispatcherTimer resortDelay = new DispatcherTimer();

		private List<string> pathsThatWasChanged = new List<string>();

		public MenuItem listMenuPlay = new MenuItem();

		public MenuItem listMenuRemove = new MenuItem();

		public MenuItem listMenuDelete = new MenuItem();

		public MenuItem listMenuInfo = new MenuItem();

		public MenuItem listMenuQueue = new MenuItem();

		public MenuItem listMenuAddToNew = new MenuItem();

		public MenuItem listMenuAddToPlaylist = new MenuItem();

		public MenuItem listMenuRemoveFromPlaylist = new MenuItem();

		public MenuItem listMenuWatchOnYouTube = new MenuItem();

		public MenuItem listMenuShareSong = new MenuItem();

		private ContextMenu listMenu = new ContextMenu();

		private string dialogPath = @"C:\";

		private DispatcherTimer sourceModifiedDelay = new DispatcherTimer();

		private Hashtable sourceModifiedTracks = new Hashtable();

		private bool doRestart = false;

		private TrackData currentlySelectedTrack = null;

		private ScannerCallback sourceModifiedCallback;

		private bool resumeWhenBack = false; // whether or not to resume playback at login/unlock

		private object sourceModifiedCallbackParams;

		private bool initialized = false;

		private bool showMediaError = false; // whether or not to show errors from media manager as popup



		#endregion



		#region Properties



		/// <summary>

		/// The total time of all tracks in the history (in seconds)

		/// </summary>

		public double HistoryTime { get; private set; }



		/// <summary>

		/// The total time of all tracks in the queue (in seconds)

		/// </summary>

		public double QueueTime { get; private set; }



		/// <summary>

		/// The total time of all tracks in the library (in seconds)

		/// </summary>

		public double LibraryTime { get; private set; }



		/// <summary>

		/// A table of the TrackList for each playlist

		/// </summary>

		public Hashtable PlaylistTrackLists { get; private set; }



		/// <summary>

		/// The height of the details pane

		/// </summary>

		public double DetailsPaneHeight

		{

			get { return SettingsManager.DetailsPaneHeight; }

			set { SettingsManager.DetailsPaneHeight = value; }

		}



		#endregion



		#region Constructor



		/// <summary>

		/// 

		/// </summary>

		public StoffiWindow()

		{

			U.L(LogLevel.Debug, "MAIN", "Creating main window");

			//SettingsManager.FirstRun = true;

			//*********** Next ***********/

			// TODO: In-place track edit

			// TODO: Images (currently playing, queue) in front of t + style

			// TODO: Images (currently playing) in front of playlists/library

			// TODO: MusicBrainz

			// TODO: Jumplist: playlists

			// TODO: Drag search text

			// TODO: Track score (how good is it?)

			// TODO: Last.fm support

			// TODO: Spotify

			// TODO: Spectrum

			// TODO: Views (album, artist, genre, all)

			// TODO: Playlist view

			// TODO: Network sources

			// TODO: Device sources

			// TODO: Tools for cutting track

			// TODO: Album cover download

			// TODO: Lyrics

			// TODO: Radio

			// TODO: TaskDialogs

			// TODO: Wikipedia

			// TODO: Social music



			U.L(LogLevel.Debug, "MAIN", "Setting culture");

			LanguageContext.Instance.Culture = CultureInfo.GetCultureInfo(SettingsManager.Language);



			if (!Microsoft.WindowsAPICodePack.Taskbar.TaskbarManager.IsPlatformSupported)

			{

				MessageBox.Show(U.T("MessageOldWindows", "Message"), U.T("MessageOldWindows", "Title"), MessageBoxButton.OK, MessageBoxImage.Error);

				Application.Current.Shutdown();

				return;

			}



			U.L(LogLevel.Debug, "MAIN", "Initialize");

			InitializeComponent();

			U.L(LogLevel.Debug, "MAIN", "Initialized");



			// we have to remove controls from their parent so "LastChildFill" doesn't screw everything up

			// we add them later on when they are toggled

			MainContainer.Children.Remove(ControlPanel);

		}



		#endregion



		#region Methods



		#region Public



		/// <summary>

		/// Restarts the application

		/// </summary>

		public void Restart()

		{

			doRestart = true;

			this.Close();

		}



		/// <summary>

		/// 

		/// </summary>

		/// <param name="modifiers"></param>

		/// <returns></returns>

		public String GetModifiersAsText(List<Key> modifiers)

		{

			String txt = "";

			foreach (Key k in modifiers)

			{

				if (k == Key.LeftCtrl || k == Key.RightCtrl) txt += "Ctrl+";

				else if (k == Key.LeftAlt || k == Key.RightAlt) txt += "Alt+";

				else if (k == Key.LWin || k == Key.RWin) txt += "Win+";

				else if (k == Key.LeftShift || k == Key.RightShift) txt += "Shift+";

			}

			if (txt.Length > 0) return txt.Substring(0, txt.Length - 1);

			else return "";

		}



		/// <summary>

		/// 

		/// </summary>

		/// <param name="k"></param>

		/// <returns></returns>

		public String KeyToString(Key k)

		{

			switch (k)

			{

				case Key.NumPad0:

					return "0 (numpad)";

				case Key.NumPad1:

					return "1 (numpad)";

				case Key.NumPad2:

					return "2 (numpad)";

				case Key.NumPad3:

					return "3 (numpad)";

				case Key.NumPad4:

					return "4 (numpad)";

				case Key.NumPad5:

					return "5 (numpad)";

				case Key.NumPad6:

					return "6 (numpad)";

				case Key.NumPad7:

					return "7 (numpad)";

				case Key.NumPad8:

					return "8 (numpad)";

				case Key.NumPad9:

					return "9 (numpad)";

				case Key.D0:

					return "0";

				case Key.D1:

					return "1";

				case Key.D2:

					return "2";

				case Key.D3:

					return "3";

				case Key.D4:

					return "4";

				case Key.D5:

					return "5";

				case Key.D6:

					return "6";

				case Key.D7:

					return "7";

				case Key.D8:

					return "8";

				case Key.D9:

					return "9";

				case Key.OemComma:

					return ",";

				case Key.OemPeriod:

					return ".";

				case Key.Subtract:

					return "-";

				case Key.Multiply:

					return "*";

				case Key.Divide:

					return "/";

				case Key.Add:

					return "+";

				case Key.Back:

					return "Backspace";

				case Key.OemMinus:

					return "-";

				case Key.CapsLock:

					return "CapsLock";

				case Key.Scroll:

					return "ScrollLock";

				case Key.PrintScreen:

					return "PrintScreen";

				case Key.Return:

					return "Enter";

				case Key.PageDown:

					return "PageDown";

				case Key.PageUp:

					return "PageUp";



				// TODO: hardcoded temporary fix

				case Key.Oem3:

					return "´";

				case Key.OemPlus:

					return "=";

				case Key.OemOpenBrackets:

					return "[";

				case Key.Oem6:

					return "]";

				case Key.Oem5:

					return @"\";

				case Key.Oem1:

					return ";";

				case Key.OemQuotes:

					return "'";

				case Key.OemQuestion:

					return "/";



				default:

					return k.ToString();

			}

		}



		/// <summary>

		/// 

		/// </summary>

		/// <param name="argument"></param>

		public void CallFromSecondInstance(String argument)

		{

			if (argument == "/play")

			{

				PlayPause();

			}

			else if (argument == "/next")

			{

				MediaManager.Next();

				if (SettingsManager.MediaState != MediaState.Playing)

					MediaManager.Tick(null, null);

			}

			else if (argument == "/previous")

			{

				MediaManager.Previous();

				if (SettingsManager.MediaState != MediaState.Playing)

					MediaManager.Tick(null, null);

			}

			else

			{

				if (File.Exists(argument))

				{

					// file is a playlist

					if (PlaylistManager.IsSupported(argument))

					{

						PlaylistData pl = PlaylistManager.LoadPlaylist(argument);

						if (pl != null)

						{

							NavigationPane.SwitchNavigation("Playlist:" + pl.Name);

							if (pl.Tracks.Count > 0)

							{

								MediaManager.Load(pl.Tracks[0]);

								MediaManager.Play();

							}

						}

					}



					// file is a track

					else if (MediaManager.IsSupported(argument))

					{

						Open(argument);

					}

				}

				// TODO: bring to front

			}

		}



		/// <summary>

		/// Retrives the currently selected track list's source.

		/// </summary>

		/// <returns>The collection used as ItemsSource for the current track list</returns>

		public ObservableCollection<TrackData> GetCurrentTrackCollection()

		{

			if (SettingsManager.CurrentSelectedNavigation == "History")

				return SettingsManager.HistoryTracks;

			else if (SettingsManager.CurrentSelectedNavigation == "Queue")

				return SettingsManager.QueueTracks;

			else if (SettingsManager.CurrentSelectedNavigation.StartsWith("Playlist:"))

			{

				PlaylistData p = PlaylistManager.FindPlaylist(SettingsManager.CurrentSelectedNavigation.Split(new[] { ':' }, 2)[1]);

				if (p == null) return null;

				return p.Tracks;

			}

			else if (SettingsManager.CurrentSelectedNavigation == "Files")

				return SettingsManager.FileTracks;

			else if (SettingsManager.CurrentSelectedNavigation == "YouTube")

				return YouTubeManager.TrackSource;

			else

				return null;

		}



		/// <summary>

		/// 

		/// </summary>

		/// <returns></returns>

		public ViewDetails GetCurrentTrackList()

		{

			if (SettingsManager.CurrentSelectedNavigation == "History")

				return HistoryTracks;

			else if (SettingsManager.CurrentSelectedNavigation == "Queue")

				return QueueTracks;

			else if (SettingsManager.CurrentSelectedNavigation.StartsWith("Playlist:"))

				return (ViewDetails)PlaylistTrackLists[SettingsManager.CurrentSelectedNavigation.Split(new[] { ':' }, 2)[1]];

			else if (SettingsManager.CurrentSelectedNavigation == "Files")

				return FileTracks;

			else if (SettingsManager.CurrentSelectedNavigation == "YouTube")

				return YouTubeContainer.YouTubeTracks;

			else

				return null;

		}



		/// <summary>

		/// 

		/// </summary>

		/// <returns></returns>

		public ViewDetails GetActiveTrackList()

		{

			string can = SettingsManager.CurrentActiveNavigation;

			if (can == "History" || can == "Queue")

				can = SettingsManager.CurrentTrack == null ? "Files" : SettingsManager.CurrentTrack.Source;



			if (can.StartsWith("Playlist:"))

			{

				PlaylistData p = PlaylistManager.FindPlaylist(can.Split(new[] { ':' }, 2)[1]);

				if (p != null)

					return (ViewDetails)PlaylistTrackLists[p.Name];

			}

			if (can == "YouTube")

				return YouTubeContainer.YouTubeTracks;

			else

				return FileTracks;

		}



		/// <summary>

		/// 

		/// </summary>

		/// <param name="name"></param>

		public void OnPropertyChanged(string name)

		{

			if (PropertyChanged != null) PropertyChanged(this, new PropertyChangedEventArgs(name));

		}



		#endregion



		#region Private



		/// <summary>

		/// Play the currently selected track

		/// </summary>

		/// <param name="resume">Resume at the current position if the selected track is the CurrentTrack</param>

		private void Play(bool resume = false)

		{

			showMediaError = true;



			if (resume && SettingsManager.CurrentTrack != null)

				MediaManager.Play();



			else if (GetCurrentTrackList().SelectedItem is TrackData)

			{

				string pl = "";



				if (SettingsManager.CurrentSelectedNavigation == "Library")

					pl = "";

				else if (SettingsManager.CurrentSelectedNavigation.StartsWith("Playlist:"))

					pl = SettingsManager.CurrentSelectedNavigation.Split(new[]{':'},2)[1];



				TrackData track = GetCurrentTrackList().SelectedItem as TrackData;

				MediaManager.TrackCollection = GetCurrentTrackList().Items;



				if (SettingsManager.CurrentSelectedNavigation == "History")

					SettingsManager.HistoryIndex = SettingsManager.HistoryTracks.IndexOf(track);

				else

					SettingsManager.HistoryIndex = SettingsManager.HistoryTracks.Count;



				SettingsManager.CurrentActiveNavigation = SettingsManager.CurrentSelectedNavigation;



				if (SettingsManager.CurrentActiveNavigation.StartsWith("Playlist:"))

					PlaylistManager.CurrentPlaylist = SettingsManager.CurrentActiveNavigation.Split(new[] { ':' }, 2)[1];

				else

					PlaylistManager.CurrentPlaylist = "";





				MediaManager.Stop();

				MediaManager.Load(track);

				MediaManager.Play();

			}

		}



		/// <summary>

		/// Toggle the play and pause state

		/// </summary>

		private void PlayPause()

		{

			if (SettingsManager.MediaState == MediaState.Playing)

				SettingsManager.MediaState = MediaState.Paused;

			else

				SettingsManager.MediaState = MediaState.Playing;

		}



		/// <summary>

		/// Removes a set of tracks from a given collection of tracks.

		/// </summary>

		/// <param name="tracksToRemove">The tracks to remove</param>

		/// <param name="tracks">The collection from where to remove the tracks</param>

		private void RemoveTracks(SortedList<string, TrackData> tracksToRemove, ObservableCollection<TrackData> tracks)

		{

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

			{

				if (tracksToRemove.ContainsKey(tracks[i].Path))

				{

					tracks.RemoveAt(i--);

				}

			}

		}



		/// <summary>

		/// Removes a set of tracks from a given collection of tracks.

		/// </summary>

		/// <param name="tracksToRemove">The tracks to remove</param>

		/// <param name="tracks">The collection from where to remove the tracks</param>

		private void RemoveTracks(SortedList<string, TrackData> tracksToRemove, List<TrackData> tracks)

		{

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

			{

				if (tracksToRemove.ContainsKey(tracks[i].Path))

				{

					tracks.RemoveAt(i--);

				}

			}

		}



		/// <summary>

		/// Removes tracks with a given filename for a specific collection of tracks

		/// </summary>

		/// <param name="filename">The filename of the tracks to remove</param>

		/// <param name="tracks">The collection of tracks from which to remove</param>

		private void RemoveTrack(String filename, ObservableCollection<TrackData> tracks)

		{

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

			{

				if (tracks[i].Path == filename)

				{

					tracks.RemoveAt(i);

					break;

				}

			}

		}



		/// <summary>

		/// Removes tracks with a given filename for a specific list of tracks

		/// </summary>

		/// <param name="filename">The filename of the tracks to remove</param>

		/// <param name="tracks">The list of tracks from which to remove</param>

		private void RemoveTrack(String filename, List<TrackData> tracks)

		{

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

			{

				if (tracks[i].Path == filename)

				{

					tracks.RemoveAt(i);

					break;

				}

			}

		}



		/// <summary>

		/// Reapply the sorting on a tracklist

		/// </summary>

		/// <param name="tl">The tracklist to re-sort</param>

		/// <param name="paths">A list of the paths that was changed</param>

		private void ResortTracklist(ViewDetails tl, List<string> paths)

		{

			bool resort = false;

			foreach (TrackData t in SettingsManager.FileTracks)

			{

				if (paths.Contains(t.Path))

				{

					resort = true;

					break;

				}

			}

			if (resort)

			{

				if (tl.Items.SortDescriptions.Count > 0)

				{

					SortDescription sd = tl.Items.SortDescriptions[0];

					tl.Items.SortDescriptions.Remove(sd);

					tl.Items.SortDescriptions.Insert(0, sd);

				}

			}

		}



		/// <summary>

		/// Load a file and add it according to the AddPolicy and play 

		/// it according to the PlayPolicy

		/// </summary>

		/// <param name="filename">The filename of the track</param>

		/// <param name="forcePlay">Whether or not to override the PlayPolicy</param>

		private void Open(string filename, bool forcePlay = false)

		{

			U.L(LogLevel.Debug, "MAIN", "Opening " + filename);

			OpenAddPolicy DoAdd = SettingsManager.OpenAddPolicy;

			OpenPlayPolicy DoPlay = SettingsManager.OpenPlayPolicy;

			TrackData track = null;



			// add track

			if (DoAdd == OpenAddPolicy.Library || DoAdd == OpenAddPolicy.LibraryAndPlaylist)

			{

				// add track to library if needed

				track = FilesystemManager.GetTrack(filename);

				if (track == null)

				{

					U.L(LogLevel.Debug, "MAIN", "Adding to collection");

					FilesystemManager.AddSource(new SourceData() 

					{ 

						Data = filename, 

						Include = true, 

						HumanType = U.T("SourcesTypeFile"),

						Type = SourceType.File 

					});

					track = FilesystemManager.GetTrack(filename);

				}



				if (track == null)

					U.L(LogLevel.Warning, "MAIN", "Could not add track to Library: " + filename);



				// add track to current playlist as well

				if (DoAdd == OpenAddPolicy.LibraryAndPlaylist && track != null)

				{

					if (SettingsManager.CurrentSelectedNavigation.StartsWith("Playlist:"))

					{

						U.L(LogLevel.Debug, "MAIN", "Adding to current playlist");

						String playlistName = SettingsManager.CurrentSelectedNavigation.Split(new[]{':'},2)[1];

						List<object> tracks = new List<object>();

						tracks.Add(track);

						PlaylistManager.AddToPlaylist(tracks, playlistName);

					}

				}

			}



			// play track

			if (DoPlay != OpenPlayPolicy.DoNotPlay || forcePlay)

			{

				// create track if it is null

				if (track == null)

				{

					U.L(LogLevel.Debug, "MAIN", "Creating track");

					track = FilesystemManager.CreateTrack(filename);

					if (track == null)

					{

						U.L(LogLevel.Warning, "MAIN", "Could not create track for: " + filename);

						return;

					}

					FilesystemManager.UpdateTrack(track);

				}



				if (DoPlay == OpenPlayPolicy.Play || forcePlay)

				{

					U.L(LogLevel.Debug, "MAIN", "Playing track");

					MediaManager.Stop();

					MediaManager.Load(track);

					MediaManager.Play();



					if (DoAdd == OpenAddPolicy.LibraryAndPlaylist && SettingsManager.CurrentSelectedNavigation.StartsWith("Playlist:"))

						SettingsManager.CurrentActiveNavigation = SettingsManager.CurrentSelectedNavigation;

					else if (DoAdd == OpenAddPolicy.Library)

						SettingsManager.CurrentActiveNavigation = "Library";

				}



				else if (DoPlay == OpenPlayPolicy.BackOfQueue)

					MediaManager.Queue(new List<TrackData>() { track });



				else if (DoPlay == OpenPlayPolicy.FrontOfQueue)

					MediaManager.Queue(new List<TrackData>() { track }, 0);

			}

		}



		/// <summary>

		/// Creates a playlist track list and navigation items

		/// </summary>

		/// <param name="playlist">The data for the playlist to create</param>

		/// <param name="select">Whether to select the playlist after it has been created</param>

		private void CreatePlaylist(PlaylistData playlist, bool select = true)

		{

			Dispatcher.Invoke(DispatcherPriority.Background, new Action(delegate()

			{

				// create track list

				ViewDetails vd = new ViewDetails();

				Grid.SetRow(vd, 1);

				TrackContainer.Children.Add(vd);

				vd.ItemsSource = playlist.Tracks;

				playlist.Tracks.CollectionChanged +=

					new System.Collections.Specialized.NotifyCollectionChangedEventHandler(vd.ItemsSource_CollectionChanged);

				if (playlist.ListConfig == null)

				{

					ViewDetailsConfig vdc = SettingsManager.CreateListConfig();

					SettingsManager.InitViewDetailsConfig(vdc);

					vdc.HasNumber = true;

					playlist.ListConfig = vdc;

				}

				if (PlaylistTrackLists.ContainsKey(playlist.Name))

					PlaylistTrackLists.Remove(playlist.Name);

				PlaylistTrackLists.Add(playlist.Name, vd);

				vd.ContextMenu = listMenu;

				vd.Visibility = Visibility.Collapsed;

				vd.BorderThickness = new Thickness(0);

				vd.ItemsSource = playlist.Tracks;

				vd.Config = playlist.ListConfig;

				vd.FilterMatch = TrackList_SearchMatch;

				vd.SelectionChanged += new SelectionChangedEventHandler(TrackList_SelectionChanged);

				vd.MouseDoubleClick += new MouseButtonEventHandler(TrackList_MouseDoubleClick);

				vd.ContextMenuOpening += new ContextMenuEventHandler(TrackList_ContextMenuOpening);

				vd.FilesDropped += new FileDropEventHandler(TrackList_FilesDropped);

				vd.MoveItem += new MoveItemEventHandler(TrackList_MoveItem);



				// create the item in the navigation tree

				TreeViewItem item = new TreeViewItem();

				item.Selected += NavigationPane.Playlist_Selected;

				item.Drop += NavigationPane.Playlist_Drop;

				item.KeyDown += NavigationPlaylist_KeyDown;

				item.Tag = playlist.Name;

				item.Padding = new Thickness(8, 0, 0, 0);



				StackPanel sp = new StackPanel();

				sp.Orientation = System.Windows.Controls.Orientation.Horizontal;



				Image img = new Image();

				img.Source = Utilities.GetIcoImage("pack://application:,,,/GUI/Images/Icons/DiscAudio.ico", 16, 16);

				img.Width = 16;

				img.Height = 16;

				sp.Children.Add(img);



				EditableTextBlock etb = new EditableTextBlock();

				etb.EnteredEditMode += new EventHandler(EditableTextBlock_EnteredEditMode);

				etb.Text = playlist.Name;

				etb.Margin = new Thickness(5, 0, 5, 0);

				etb.Edited += NavigationPane.Playlist_Edited;

				sp.Children.Add(etb);



				item.Header = sp;

				item.ContextMenuOpening += new ContextMenuEventHandler(NavigationPane.Playlist_ContextMenuOpening);

				item.ContextMenu = NavigationPane.playlistMenu;

				NavigationPane.Playlists.Items.Insert(NavigationPane.Playlists.Items.Count - 1, item);

				if (select)

					item.Focus();



				// create list context menu items

				MenuItem miAdd = new MenuItem();

				miAdd.Header = playlist.Name;

				miAdd.Click += new RoutedEventHandler(listMenuAddToPlaylist_Click);

				listMenuAddToPlaylist.Visibility = System.Windows.Visibility.Visible;

				listMenuAddToPlaylist.Items.Insert(listMenuAddToPlaylist.Items.Count - 1, miAdd);



				MenuItem miDel = new MenuItem();

				miDel.Header = playlist.Name;

				miDel.Click += new RoutedEventHandler(listMenuRemoveFromPlaylist_Click);

				listMenuRemoveFromPlaylist.Visibility = System.Windows.Visibility.Visible;

				listMenuRemoveFromPlaylist.Items.Add(miDel);



				PlaybackControls.Search.AddPlaylist(playlist);

			}));

		}



		/// <summary>

		/// Updates the visibility of a given element according to the settings

		/// </summary>

		/// <param name="element">The element to update (menubar or details)</param>

		private void UpdateVisibility(string element)

		{

			switch (element)

			{

				case "menubar":

					bool mv = SettingsManager.MenuBarVisibile;

					showMenuMenuBar.IsChecked = mv;

					MenuItemViewMenuBar.IsChecked = mv;

					MenuBar.Visibility = mv ? System.Windows.Visibility.Visible : System.Windows.Visibility.Collapsed;

					break;



				case "details":

					bool dv = SettingsManager.DetailsPaneVisible;

					showMenuDetailsPane.IsChecked = dv;

					MenuItemViewDetailsPane.IsChecked = dv;

					DetailsRow.MinHeight = (dv ? 80 : 0);

					DetailsRow.Height = new GridLength((dv ? SettingsManager.DetailsPaneHeight : 0));

					DetailsPane.Visibility = dv ? System.Windows.Visibility.Visible : System.Windows.Visibility.Collapsed;

					HorizontalSplitter.Visibility = dv ? System.Windows.Visibility.Visible : System.Windows.Visibility.Collapsed;

					break;

			}

		}



		/// <summary>

		/// Updates the strings around the GUI, that are hardcoded, according to the current Language

		/// </summary>

		private void UpdateGUIStrings()

		{

			// change column headers of list views

			foreach (ViewDetailsColumn c in SettingsManager.SourceListConfig.Columns)

			{

				if (c.Binding == "HumanType") c.Text = U.T("ColumnType");

				else if (c.Binding == "Data") c.Text = U.T("ColumnLocation");

			}

			foreach (ViewDetailsColumn c in SettingsManager.YouTubeListConfig.Columns)

			{

				if (c.Binding == "Artist")      c.Text = U.T("ColumnArtist");

				else if (c.Binding == "Title")  c.Text = U.T("ColumnTitle");

				else if (c.Binding == "Path")   c.Text = U.T("ColumnPath");

				else if (c.Binding == "Length") c.Text = U.T("ColumnLength");

			}

			foreach (ViewDetailsColumn c in SettingsManager.FileListConfig.Columns)

			{

				if (c.Binding == "Artist")          c.Text = U.T("ColumnArtist");

				else if (c.Binding == "Title")      c.Text = U.T("ColumnTitle");

				else if (c.Binding == "Album")      c.Text = U.T("ColumnAlbum");

				else if (c.Binding == "Genre")      c.Text = U.T("ColumnGenre");

				else if (c.Binding == "LastPlayed") c.Text = U.T("ColumnLastPlayed");

				else if (c.Binding == "Length")     c.Text = U.T("ColumnLength");

				else if (c.Binding == "PlayCount")  c.Text = U.T("ColumnPlayCount");

				else if (c.Binding == "Path")       c.Text = U.T("ColumnPath");

				else if (c.Binding == "Track")      c.Text = U.T("ColumnTrack");

				else if (c.Binding == "Year")       c.Text = U.T("ColumnYear");

			}

			foreach (ViewDetailsColumn c in SettingsManager.QueueListConfig.Columns)

			{

				if (c.Binding == "Artist")          c.Text = U.T("ColumnArtist");

				else if (c.Binding == "Title")      c.Text = U.T("ColumnTitle");

				else if (c.Binding == "Album")      c.Text = U.T("ColumnAlbum");

				else if (c.Binding == "Genre")      c.Text = U.T("ColumnGenre");

				else if (c.Binding == "LastPlayed") c.Text = U.T("ColumnLastPlayed");

				else if (c.Binding == "Length")     c.Text = U.T("ColumnLength");

				else if (c.Binding == "PlayCount")  c.Text = U.T("ColumnPlayCount");

				else if (c.Binding == "Path")       c.Text = U.T("ColumnPath");

				else if (c.Binding == "Track")      c.Text = U.T("ColumnTrack");

				else if (c.Binding == "Year")       c.Text = U.T("ColumnYear");

			}

			foreach (ViewDetailsColumn c in SettingsManager.HistoryListConfig.Columns)

			{

				if (c.Binding == "Artist")          c.Text = U.T("ColumnArtist");

				else if (c.Binding == "Title")      c.Text = U.T("ColumnTitle");

				else if (c.Binding == "Album")      c.Text = U.T("ColumnAlbum");

				else if (c.Binding == "Genre")      c.Text = U.T("ColumnGenre");

				else if (c.Binding == "LastPlayed") c.Text = U.T("ColumnPlayed");

				else if (c.Binding == "Length")     c.Text = U.T("ColumnLength");

				else if (c.Binding == "PlayCount")  c.Text = U.T("ColumnPlayCount");

				else if (c.Binding == "Path")       c.Text = U.T("ColumnPath");

				else if (c.Binding == "Track")      c.Text = U.T("ColumnTrack");

				else if (c.Binding == "Year")       c.Text = U.T("ColumnYear");

			}

			foreach (PlaylistData p in SettingsManager.Playlists)

				foreach (ViewDetailsColumn c in p.ListConfig.Columns)

				{

					if (c.Binding == "Artist")          c.Text = U.T("ColumnArtist");

					else if (c.Binding == "Title")      c.Text = U.T("ColumnTitle");

					else if (c.Binding == "Album")      c.Text = U.T("ColumnAlbum");

					else if (c.Binding == "Genre")      c.Text = U.T("ColumnGenre");

					else if (c.Binding == "LastPlayed") c.Text = U.T("ColumnPlayed");

					else if (c.Binding == "Length")     c.Text = U.T("ColumnLength");

					else if (c.Binding == "PlayCount")  c.Text = U.T("ColumnPlayCount");

					else if (c.Binding == "Path")       c.Text = U.T("ColumnPath");

					else if (c.Binding == "Track")      c.Text = U.T("ColumnTrack");

					else if (c.Binding == "Year")       c.Text = U.T("ColumnYear");

				}



			// change source types

			foreach (SourceData s in SettingsManager.Sources)

				switch (s.Type)

				{

					case SourceType.File:

						s.HumanType = U.T("SourcesTypeFile");

						break;



					case SourceType.Folder:

						s.HumanType = U.T("SourcesTypeFolder");

						break;



					case SourceType.Library:

						s.HumanType = U.T("SourcesTypeLibrary");

						break;

				}



			// change shortcuts

			ControlPanel.GlobalLabel.Content = U.T("ShortcutGlobal");

			foreach (TextBlock t in ControlPanel.ShortcutTitles)

				t.Text = U.T((string)t.Tag);

			foreach (TextBlock t in ControlPanel.ShortcutDescriptions)

				t.Text = U.T((string)t.Tag);

			foreach (Label l in ControlPanel.ShortcutLabels)

				l.Content = U.T((string)l.Tag);



			// change menus

			trayMenuShow.Header = U.T("TrayShow");

			trayMenuPlay.Header = U.T("TrayPlay");

			trayMenuNext.Header = U.T("TrayNext");

			trayMenuPrev.Header = U.T("TrayPrev");

			trayMenuExit.Header = U.T("TrayExit");

			taskbarPlay.Tooltip = U.T("TaskbarPlay");

			taskbarNext.Tooltip = U.T("TaskbarNext");

			taskbarPrev.Tooltip = U.T("TaskbarPrev");

			jumpTaskPlay.Title = U.T("JumpPlay", "Title");

			jumpTaskNext.Title = U.T("JumpNext", "Title");

			jumpTaskPrev.Title = U.T("JumpPrev", "Title");

			jumpTaskPlay.Description = U.T("JumpPlay", "Description");

			jumpTaskNext.Description = U.T("JumpNext", "Description");

			jumpTaskPrev.Description = U.T("JumpPrev", "Description");

			listMenuAddToPlaylist.Header = U.T("MenuAddToPlaylist", "Header");

			listMenuAddToNew.Header = U.T("MenuCreateNew", "Header");

			listMenuDelete.Header = U.T("MenuDelete");

			listMenuInfo.Header = U.T("MenuInfo");

			listMenuPlay.Header = U.T("MenuPlay");

			listMenuQueue.Header = U.T("MenuQueue");

			listMenuRemove.Header = U.T("MenuRemove");

			listMenuRemoveFromPlaylist.Header = U.T("MenuRemoveFromPlaylist", "Header");

			listMenuWatchOnYouTube.Header = U.T("MenuWatchOnYouTube");

			listMenuShareSong.Header = U.T("MenuShareSong");

			addMenuFile.Header = U.T("ToolbarAddTrack");

			addMenuFolder.Header = U.T("ToolbarAddFolder");

			addMenuPlaylist.Header = U.T("ToolbarAddPlaylist");

			showMenuDetailsPane.Header = U.T("ToolbarDetailsPane");

			showMenuMenuBar.Header = U.T("ToolbarMenuBar");

			toolsMenuExporter.Header = U.T("ToolbarExporter");

			toolsMenuImporter.Header = U.T("ToolbarImporter");

			toolsMenuGenerate.Header = U.T("ToolbarGeneratePlaylist");

			NavigationPane.playlistMenuRemove.Header = U.T("MenuRemovePlaylist");

			NavigationPane.playlistMenuRename.Header = U.T("MenuRenamePlaylist");

			NavigationPane.playlistMenuSave.Header = U.T("MenuSavePlaylist");

			NavigationPane.playlistMenuShare.Header = U.T("MenuSharePlaylist");

			NavigationPane.CreateNewPlaylistETB.Text = U.T("NavigationCreateNew");

			ControlPanel.menuRemove.Header = U.T("MenuRemove");



			// change tracklist header

			string csn = SettingsManager.CurrentSelectedNavigation;

			switch (csn)

			{

				case "Files":

					InfoPaneTitle.Text = U.T("NavigationFilesTitle");

					InfoPaneDuration.Text = U.TimeSpanToLongString(new TimeSpan(0, 0, (int)LibraryTime)); ;

					InfoPaneTracks.Text = SettingsManager.FileTracks.Count.ToString() + " " + U.T("HeaderTracks");

					break;



				case "Queue":

					InfoPaneTitle.Text = U.T("NavigationQueueTitle");

					InfoPaneDuration.Text = U.TimeSpanToLongString(new TimeSpan(0, 0, (int)QueueTime)); ;

					InfoPaneTracks.Text = SettingsManager.QueueTracks.Count.ToString() + " " + U.T("HeaderTracks");

					break;



				case "History":

					InfoPaneTitle.Text = U.T("NavigationHistoryTitle");

					InfoPaneDuration.Text = U.TimeSpanToLongString(new TimeSpan(0, 0, (int)HistoryTime)); ;

					InfoPaneTracks.Text = SettingsManager.HistoryTracks.Count.ToString() + " " + U.T("HeaderTracks");

					break;



				default:

					if (csn.StartsWith("Playlist:"))

					{

						PlaylistData p = PlaylistManager.FindPlaylist(csn.Split(new[] { ':' }, 2)[1]);

						InfoPaneTitle.Text = U.T("NavigationPlaylistTitle") + " '" + p.Name + "'";

						InfoPaneDuration.Text = U.TimeSpanToLongString(new TimeSpan(0, 0, (int)p.Time)); ;

						InfoPaneTracks.Text = p.Tracks.Count.ToString() + " " + U.T("HeaderTracks");

					}

					break;

			}

		}



		/// <summary>

		/// Will repaint the glass effect behind the playback pane.

		/// </summary>

		private void RefreshGlassEffect()

		{

			try

			{

				Dwm.Glass[this].Enabled = true;

				Thickness foo = new Thickness(1, 75, 1, 1);

				Dwm.Glass[this].Margins = foo;

				Background = Brushes.Transparent;

				glassEffect = true;

			}

			catch (Exception e)

			{

				U.L(LogLevel.Warning, "MAIN", "Could not set glass effect: " + e.Message);

				if (System.Windows.Forms.VisualStyles.VisualStyleInformation.DisplayName == "")

					Background = SystemColors.ControlBrush;

				else

					Background = SystemColors.GradientActiveCaptionBrush;

				glassEffect = false;

			}

		}



		/// <summary>

		/// Initializes the GUI

		/// </summary>

		private void InitGUI()

		{

			U.L(LogLevel.Debug, "MAIN", "Init settings manager");

			SettingsManager.Initialize();



			U.L(LogLevel.Debug, "MAIN", "Init service manager");

			ServiceManager.Initialize();



			// create playlists

			ThreadStart PlaylistThread = delegate()

			{

				Dispatcher.Invoke(DispatcherPriority.Background, new Action(delegate()

				{

					if (SettingsManager.CurrentSelectedNavigation == "YouTube")

						NavigationPane.Youtube.Focus();

					else if (SettingsManager.CurrentSelectedNavigation == "Queue")

						NavigationPane.Queue.Focus();

					else if (SettingsManager.CurrentSelectedNavigation == "History")

						NavigationPane.History.Focus();

					else if (!SettingsManager.CurrentSelectedNavigation.StartsWith("Playlist:"))

						NavigationPane.Files.Focus();



					// create playlists

					PlaylistManager.Initialize();



					foreach (PlaylistData playlist in SettingsManager.Playlists)

						CreatePlaylist(playlist, false);



					PlaylistManager.PlaylistModified += new ModifiedEventHandler(PlaylistManager_PlaylistModified);

					PlaylistManager.PlaylistRenamed += new RenamedEventHandler(PlaylistManager_PlaylistRenamed);



					// if csn == playlist: select

					if (SettingsManager.CurrentSelectedNavigation.StartsWith("Playlist:"))

					{

						string name = SettingsManager.CurrentSelectedNavigation.Split(new[] { ':' }, 2)[1];

						foreach (TreeViewItem tvi in NavigationPane.Playlists.Items)

						{

							if ((string)tvi.Tag == name)

							{

								tvi.Focus();

								break;

							}

						}

					}

				}));

			};



			ThreadStart GUIThread = delegate()

			{

				// init media manager

				ThreadStart MediaManagerThread = delegate()

				{

					Dispatcher.Invoke(DispatcherPriority.Background, new Action(delegate()

					{

						MediaManager.Initialize(new WindowInteropHelper(this).Handle);

						MediaManager.Browser = NowPlayingContainer.Browser;



						// load the track collection

						if (SettingsManager.CurrentActiveNavigation == "Queue")

							MediaManager.TrackCollection = QueueTracks.Items;

						else if (SettingsManager.CurrentActiveNavigation == "History")

							MediaManager.TrackCollection = HistoryTracks.Items;

						else if (SettingsManager.CurrentActiveNavigation == "YouTube")

							MediaManager.TrackCollection = YouTubeContainer.YouTubeTracks.Items;

						else if (SettingsManager.CurrentActiveNavigation.StartsWith("Playlist:"))

						{

							string pname = SettingsManager.CurrentActiveNavigation.Split(new[] { ':' }, 2)[1];

							ViewDetails p = (ViewDetails)PlaylistTrackLists[pname];

							if (p == null)

								MediaManager.TrackCollection = FileTracks.Items;

							else

								MediaManager.TrackCollection = p.Items;

						}

						else

							MediaManager.TrackCollection = FileTracks.Items;



						// check if we have any command line arguments

						String[] arguments = Environment.GetCommandLineArgs();

						if (arguments.Length > 1)

						{

							if (arguments[1] == "/play") MediaManager.Play();

							else if (arguments[1] == "/pause") MediaManager.Pause();

							else if (arguments[1] == "/stop") MediaManager.Stop();

							else if (arguments[1] == "/next") MediaManager.Next();

							else if (arguments[1] == "/previous") MediaManager.Previous();



							else if (File.Exists(arguments[1]) && MediaManager.IsSupported(arguments[1]))

							{

								Open(arguments[1], true);

							}

						}

					}));

				};



				// init upgrade manager

				ThreadStart UpgradeManagerThread = delegate()

				{

					UpgradeManager.Initialize(new TimeSpan(0, 60, 0));

					UpgradeManager.Probe(null, null);

				};



				// init filesystem manager

				ThreadStart FilesystemManagerThread = delegate()

				{

					FilesystemManager.Initialize();



					if (SettingsManager.FirstRun)

					{

						FilesystemManager.ScanLibraries(true, false);

						if (SettingsManager.Sources.Count == 0)

						{

							Dispatcher.Invoke(DispatcherPriority.Background, new Action(delegate()

							{

								Welcome dialog = new Welcome();

								dialog.ShowDialog();

								FilesystemManager.ScanSources();

							}));

						}



						SettingsManager.FirstRun = false;

					}

					else

						FilesystemManager.ScanLibraries(true);

				};



				// calculate play time

				ThreadStart PTThread = delegate()

				{

					LibraryTime = 0;

					QueueTime = 0;

					HistoryTime = 0;

					if (SettingsManager.FileTracks != null)

						foreach (TrackData track in SettingsManager.FileTracks)

							LibraryTime += track.RawLength;

					if (SettingsManager.QueueTracks != null)

						foreach (TrackData track in SettingsManager.QueueTracks)

							QueueTime += track.RawLength;

					if (SettingsManager.HistoryTracks != null)

						foreach (TrackData track in SettingsManager.HistoryTracks)

							HistoryTime += track.RawLength;

				};



				Thread mm_thread = new Thread(MediaManagerThread);

				Thread um_thread = new Thread(UpgradeManagerThread);

				Thread fm_thread = new Thread(FilesystemManagerThread);

				Thread pt_thread = new Thread(PTThread);

				mm_thread.Name = "Init Media Manager";

				um_thread.Name = "Init Upgrade Manager";

				fm_thread.Name = "Init Filesystem Manager";

				pt_thread.Name = "Playing Time Thread";

				mm_thread.Priority = ThreadPriority.BelowNormal;

				um_thread.Priority = ThreadPriority.BelowNormal;

				fm_thread.Priority = ThreadPriority.BelowNormal;

				pt_thread.Priority = ThreadPriority.BelowNormal;

				mm_thread.Start();

				um_thread.Start();

				fm_thread.Start();

				pt_thread.Start();



				Dispatcher.Invoke(DispatcherPriority.Background, new Action(delegate()

				{

					FileTracks.Config = SettingsManager.FileListConfig;

					HistoryTracks.Config = SettingsManager.HistoryListConfig;

					QueueTracks.Config = SettingsManager.QueueListConfig;

					ControlPanel.SourceList.Config = SettingsManager.SourceListConfig;

					YouTubeContainer.YouTubeTracks.Config = SettingsManager.YouTubeListConfig;



					FileTracks.ItemsSource = SettingsManager.FileTracks;

					QueueTracks.ItemsSource = SettingsManager.QueueTracks;

					HistoryTracks.ItemsSource = SettingsManager.HistoryTracks;

					ControlPanel.SourceList.ItemsSource = SettingsManager.Sources;

					YouTubeContainer.Search(SettingsManager.YouTubeListConfig.Filter);

				}));



				SettingsManager.FileTracks.CollectionChanged += new NotifyCollectionChangedEventHandler(FileTracks.ItemsSource_CollectionChanged);

				SettingsManager.QueueTracks.CollectionChanged += new NotifyCollectionChangedEventHandler(QueueTracks.ItemsSource_CollectionChanged);

				SettingsManager.HistoryTracks.CollectionChanged += new NotifyCollectionChangedEventHandler(HistoryTracks.ItemsSource_CollectionChanged);

				SettingsManager.QueueTracks.CollectionChanged += new NotifyCollectionChangedEventHandler(QueueTracks_CollectionChanged);

				SettingsManager.HistoryTracks.CollectionChanged += new NotifyCollectionChangedEventHandler(HistoryTracks_CollectionChanged);

				SettingsManager.FileTracks.CollectionChanged += new NotifyCollectionChangedEventHandler(LibraryTracks_CollectionChanged);



				jumpTaskPlay = new JumpTask()

				{

					Title = U.T("JumpPlay", "Title"),

					Arguments = "/play",

					Description = U.T("JumpPlay", "Description"),

					IconResourceIndex = -1,

					ApplicationPath = Assembly.GetEntryAssembly().CodeBase,

				};



				jumpTaskNext = new JumpTask()

				{

					Title = U.T("JumpNext", "Title"),

					Arguments = "/next",

					Description = U.T("JumpNext", "Description"),

					IconResourceIndex = -1,

					ApplicationPath = Assembly.GetEntryAssembly().CodeBase,

				};



				jumpTaskPrev = new JumpTask()

				{

					Title = U.T("JumpPrev", "Title"),

					Arguments = "/previous",

					Description = U.T("JumpPrev", "Description"),

					IconResourceIndex = -1,

					ApplicationPath = Assembly.GetEntryAssembly().CodeBase,

				};



				jumpList = new JumpList();

				jumpList.JumpItems.Add(jumpTaskPlay);

				jumpList.JumpItems.Add(jumpTaskNext);

				jumpList.JumpItems.Add(jumpTaskPrev);

				jumpList.ShowRecentCategory = true;

				jumpList.ShowFrequentCategory = true;



				Dispatcher.Invoke(DispatcherPriority.Background, new Action(delegate()

				{

					PlaybackControls.VolumeSlide.Value = SettingsManager.Volume;



					NavigationColumn.Width = new GridLength(SettingsManager.NavigationPaneWidth);

					double h = SettingsManager.DetailsPaneHeight;

					DetailsRow.Height = new GridLength(h);



					UpdateVisibility("menubar");

					UpdateVisibility("details");



					ControlPanel.InitShortcuts();

					JumpList.SetJumpList(Application.Current, jumpList);



					UpdateGUIStrings();

				}));  



			};



			Thread pl_thread = new Thread(PlaylistThread);

			Thread gui_thread = new Thread(GUIThread);

			pl_thread.Name = "Init Playlist Manager";

			gui_thread.Name = "Init managers and GUI";

			pl_thread.Priority = ThreadPriority.BelowNormal;

			gui_thread.Priority = ThreadPriority.BelowNormal;

			pl_thread.Start();

			gui_thread.Start();

		}



		#endregion



		#region Event handlers



		/// <summary>

		/// 

		/// </summary>

		/// <param name="sender"></param>

		/// <param name="e"></param>

		private void Window_Loaded(object sender, RoutedEventArgs e)

		{

			U.L(LogLevel.Debug, "MAIN", "Loaded");



			System.Windows.Forms.Application.EnableVisualStyles();



			WindowState = (WindowState)Enum.Parse(typeof(WindowState), SettingsManager.WinState);



			kListener.KeyDown += new RawKeyEventHandler(KListener_KeyDown);

			kListener.KeyUp += new RawKeyEventHandler(KListener_KeyUp);



			addMenu = new ContextMenu();

			showMenu = new ContextMenu();

			toolsMenu = new ContextMenu();



			addMenuFile = new MenuItem();

			addMenuFile.Header = U.T("ToolbarAddTrack");

			addMenuFile.Click += AddFile_Clicked;



			addMenuFolder = new MenuItem();

			addMenuFolder.Header = U.T("ToolbarAddFolder");

			addMenuFolder.Click += AddFolder_Clicked;



			addMenuPlaylist = new MenuItem();

			addMenuPlaylist.Header = U.T("ToolbarAddPlaylist");

			addMenuPlaylist.Click += OpenPlaylist_Clicked;



			showMenuDetailsPane = new MenuItem();

			showMenuDetailsPane.Header = U.T("ToolbarDetailsPane");

			showMenuDetailsPane.IsCheckable = true;

			showMenuDetailsPane.Click += ToggleDetailsPane;



			showMenuMenuBar = new MenuItem();

			showMenuMenuBar.Header = U.T("ToolbarMenuBar");

			showMenuMenuBar.IsCheckable = true;

			showMenuMenuBar.Click += ToggleMenuBar;



			toolsMenuImporter = new MenuItem();

			toolsMenuImporter.Header = U.T("ToolbarImporter");

			toolsMenuImporter.Click += Importer_Clicked;



			toolsMenuExporter = new MenuItem();

			toolsMenuExporter.Header = U.T("ToolbarExporter");

			toolsMenuExporter.Click += Exporter_Clicked;



			toolsMenuGenerate = new MenuItem();

			toolsMenuGenerate.Header = U.T("ToolbarGeneratePlaylist");

			toolsMenuGenerate.Click += GeneratePlaylist_Clicked;



			addMenu.Items.Add(addMenuFile);

			addMenu.Items.Add(addMenuFolder);

			addMenu.Items.Add(addMenuPlaylist);

			showMenu.Items.Add(showMenuMenuBar);

			showMenu.Items.Add(showMenuDetailsPane);

			toolsMenu.Items.Add(toolsMenuImporter);

			toolsMenu.Items.Add(toolsMenuExporter);

			toolsMenu.Items.Add(toolsMenuGenerate);

			addMenu.Placement = System.Windows.Controls.Primitives.PlacementMode.Bottom;

			showMenu.Placement = System.Windows.Controls.Primitives.PlacementMode.Bottom;

			toolsMenu.Placement = System.Windows.Controls.Primitives.PlacementMode.Bottom;



			listMenuAddToPlaylist.Header = U.T("MenuAddToPlaylist", "Header");

			listMenuDelete.Header = U.T("MenuDelete");

			listMenuDelete.Click += new RoutedEventHandler(listMenuDelete_Click);

			listMenuInfo.Header = U.T("MenuInfo");

			listMenuInfo.Click += new RoutedEventHandler(listMenuInfo_Click);

			listMenuPlay.Header = U.T("MenuPlay");

			listMenuPlay.Click += new RoutedEventHandler(listMenuPlay_Click);

			listMenuWatchOnYouTube.Header = U.T("MenuWatchOnYouTube");

			listMenuWatchOnYouTube.Click += new RoutedEventHandler(listMenuWatchOnYouTube_Click);

			listMenuQueue.Header = U.T("MenuQueue");

			listMenuQueue.Click += new RoutedEventHandler(listMenuQueue_Click);

			listMenuRemove.Header = U.T("MenuRemove");

			listMenuRemove.Click += new RoutedEventHandler(listMenuRemove_Click);

			listMenuRemoveFromPlaylist.Header = U.T("MenuRemoveFromPlaylist", "Header");

			listMenuRemoveFromPlaylist.Visibility = System.Windows.Visibility.Collapsed;



			listMenuAddToNew = new MenuItem();

			listMenuAddToNew.Header = U.T("MenuCreateNew", "Header");

			listMenuAddToNew.FontStyle = FontStyles.Italic;

			listMenuAddToNew.Click += new RoutedEventHandler(listMenuAddToPlaylist_Click);

			listMenuAddToPlaylist.Items.Add(listMenuAddToNew);



			listMenu.Items.Add(listMenuPlay);

			listMenu.Items.Add(listMenuQueue);

			listMenu.Items.Add(new Separator());

			listMenu.Items.Add(listMenuAddToPlaylist);

			listMenu.Items.Add(listMenuRemoveFromPlaylist);

			listMenu.Items.Add(listMenuRemove);

			listMenu.Items.Add(listMenuDelete);

			listMenu.Items.Add(new Separator());

			listMenu.Items.Add(listMenuWatchOnYouTube);

			listMenu.Items.Add(listMenuInfo);



			PlaylistTrackLists = new Hashtable();



			//// TODO: remove all these lines

			////FileTracks.ParentWindow = this;

			////QueueTracks.ParentWindow = this;

			////HistoryTracks.ParentWindow = this;

			ControlPanel.ParentWindow = this;

			NavigationPane.ParentWindow = this;

			PlaybackControls.ParentWindow = this;



			FileTracks.ContextMenu = listMenu;

			HistoryTracks.ContextMenu = listMenu;

			QueueTracks.ContextMenu = listMenu;

			YouTubeContainer.YouTubeTracks.ContextMenu = listMenu;



			YouTubeContainer.YouTubeTracks.MouseDoubleClick += new MouseButtonEventHandler(TrackList_MouseDoubleClick);

			YouTubeContainer.YouTubeTracks.SelectionChanged += new SelectionChangedEventHandler(TrackList_SelectionChanged);

			YouTubeContainer.YouTubeTracks.ContextMenuOpening += new ContextMenuEventHandler(TrackList_ContextMenuOpening);

			YouTubeContainer.YouTubeTracks.MoveItem += new MoveItemEventHandler(TrackList_MoveItem);



			sourceModifiedDelay.Tick += new EventHandler(SourceModifiedDelay_Tick);

			sourceModifiedDelay.Interval = new TimeSpan(0, 0, 0, 1, 500);



			SettingsManager.PropertyChanged += new PropertyChangedWithValuesEventHandler(SettingsManager_PropertyChanged);



			NavigationPane.CreateNewPlaylistETB.EnteredEditMode += new EventHandler(EditableTextBlock_EnteredEditMode);



			U.ListenForShortcut = true;



			SystemEvents.SessionSwitch += new SessionSwitchEventHandler(SystemEvents_SessionSwitch);



			String defaultAlbumArt = "/GUI/Images/AlbumArt/Default.jpg";



			//// rough detection of aero vs classic

			//// you'll se a lot more of these around the code

			if (System.Windows.Forms.VisualStyles.VisualStyl…