/// <summary>
/// Event handler for connected devices.
/// </summary>
/// <param name="sender">Sender of the event.</param>
/// <param name="args">Event arguments.</param>
private void OnDeviceConnected(object sender, CDMEventArgs args)
{
Device device = args.Device;
if (configuration.ShowNotificationPopups)
{
string message = "'" + device.Name + "' has been connected. "
+ "You may now synchronize the device "
+ "with the playlist for this device.\n\nDevices currently connected:";
foreach (Device d in connectedDevices.GetConnectedDevices())
{
message += "\n - " + d.Name;
}
itaTray.ShowBalloonTip(5, "Device connected!", message, ToolTipIcon.Info);
}
IITPlaylist playlist = PlaylistExists(device);
//Delete playlist if it exists.
//if (playlist != null)
// playlist.Delete();
if (playlist == null)
{
try
{
if (configuration.UseListFolder)
{
CreateMyDevicesFolder();
playlist = folderMyDevices.CreatePlaylist(device.Name);
}
else
{
playlist = itunes.CreatePlaylist(device.Name);
}
}
catch (Exception e)
{
l.Error(e);
MessageBox.Show("Failed to create list for device '" + device.Name
+ "'. You will not be able to synchronize this device with iTunes.",
"Playlist error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
else
{
//If the option to use "My Devices" folder is set, move the playlist to that folder.
if (configuration.UseListFolder && (playlist.Kind == ITPlaylistKind.ITPlaylistKindUser) &&
(device.Playlist == null || device.Playlist.Length == 0))
{
CreateMyDevicesFolder();
object parent = (object)folderMyDevices;
((IITUserPlaylist)playlist).set_Parent(ref parent);
}
}
}
private DataTable GetSourceTracks(IITPlaylist sourcePlaylist)
{
DataTable sourceTracks = CreateTracksTable();
DataRow trackDetails;
toolStripProgressBarCore.Maximum = sourcePlaylist.Tracks.Count;
int currentTrackNumber = 0;
foreach (IITTrack track in sourcePlaylist.Tracks)
{
//foreach (IITTrack track in sourceMusic1.Search("chorale vii", ITPlaylistSearchField.ITPlaylistSearchFieldSongNames)) {
if (track.KindAsString != "PDF document" && track.DiscNumber != 0 && track.TrackNumber != 0)
{
currentTrackNumber++;
trackDetails = sourceTracks.NewRow();
trackDetails["Name"] = track.Name;
trackDetails["Album"] = track.Album;
trackDetails["Artist"] = track.Artist;
trackDetails["Disc"] = track.DiscNumber;
trackDetails["Track"] = track.TrackNumber;
trackDetails["Size"] = track.Size;
trackDetails["Rating"] = track.Rating;
trackDetails["Count"] = track.PlayedCount;
trackDetails["Date"] = track.PlayedDate;
trackDetails["Type"] = track.KindAsString;
trackDetails["TrackId"] = track.trackID;
trackDetails["DatabaseId"] = track.TrackDatabaseID;
sourceTracks.Rows.Add(trackDetails);
toolStripProgressBarCore.Value = currentTrackNumber;
}
}
return(sourceTracks);
}
public void FillGrid(DataGridView dataGrid, ProgressBar bar)
{
IITPlaylist recently = GetRecentyPlayed();
if (recently == null)
{
throw new Exception("No iDotFm list found in iTunes");
}
dataGrid.Rows.Clear();
bar.Maximum = recently.Tracks.Count;
bar.Value = 0;
foreach (IITTrack track in recently.Tracks)
{
bar.Value = bar.Value + 1;
for (int j = 0; j < track.PlayedCount; j++)
{
dataGrid.Rows.Add(new String[] {
track.Artist,
track.Album,
track.Name,
(track.PlayedDate.AddSeconds(j * (track.Duration / 2) + 1)).ToString(),
track.Duration.ToString()
});
}
}
dataGrid.Sort(dataGrid.Columns[3], System.ComponentModel.ListSortDirection.Ascending);
fmain.SubmitTracks.Enabled = dataGrid.Rows.Count > 0;
}
private PersistentID GetPlaylistPersistentID(string name)
{
IITPlaylist playlist = itunes.LibrarySource.Playlists.get_ItemByName(name);
PersistentID pid = GetPersistentID(playlist);
return(pid);
}
private void PlaylistSelectionChanged(int index)
{
IITPlaylist newPlaylist = null;
if ((index > 0) && (index < _playlists.Count))
{
newPlaylist = _playlists[index];
_workspaceViewModel.Workspace.Settings.ITunesSyncPlaylist = newPlaylist.Name;
ITunesSync.RemoveOldTracks(newPlaylist);
}
foreach (var track in _workspaceViewModel.Tracks)
{
if (SelectedPlaylist != null)
{
ITunesSync.RemoveTrack(SelectedPlaylist, track.Item);
}
if (newPlaylist != null)
{
ITunesSync.AddTrack(newPlaylist, track.Item, track.GetFilePath());
}
}
if (newPlaylist != null)
{
SelectedPlaylist = newPlaylist;
}
}
private DataTable GetTracks(IITPlaylist playlist)
{
// Create the "Track" table.
DataTable trackTable = new DataTable("Track");
trackTable.Columns.Add("TrackDatabaseID", typeof(int));
trackTable.Columns.Add("Name", typeof(String));
trackTable.Columns.Add("Artist", typeof(String));
trackTable.Columns.Add("Album", typeof(String));
trackTable.Columns.Add("Genre", typeof(String));
trackTable.Columns.Add("PlayedCount", typeof(int));
// Populate the "Track" table.
IITTrackCollection tracks = playlist.Tracks;
foreach (IITTrack track in tracks)
{
DataRow trackRow = trackTable.NewRow();
trackRow["TrackDatabaseID"] = track.TrackDatabaseID;
trackRow["Name"] = track.Name;
trackRow["Artist"] = track.Artist;
trackRow["Album"] = track.Album;
trackRow["Genre"] = track.Genre;
trackRow["PlayedCount"] = track.PlayedCount;
trackTable.Rows.Add(trackRow);
}
return(trackTable);
}
public void PerformSynchronize()
{
Dictionary <String, HashSet <Device> > deviceinfo = connectedDevices.GetConnectedDevicesWithDrives();
IDictionaryEnumerator keys = deviceinfo.GetEnumerator();
try
{
// Create synchronizer and form.
ISynchronizer synchronizer = new StandardSynchronizer();
synchronizer.Form = syncForm;
while (keys.MoveNext())
{
string drive = ((string)keys.Key).Substring(0, 3);
HashSet <Device> devices = (HashSet <Device>)keys.Value;
foreach (Device device in devices)
{
if (configuration.ConfirmMusicLocation && !GetMusicLocationConfirmation(drive + device.MediaRoot))
{
syncForm.CloseSafe();
syncForm = null;
synchronizer = null;
return;
}
IITPlaylist playlist = PlaylistExists(device);
if (playlist == null)
{
MessageBox.Show("I could not synchronize '" + device.Name + "' because "
+ "the playlist does not exist! Try reconnecting the device. If the problem continues"
+ " please report the problem to the Notpod developers at http://www.sourceforge.net/projects/ita.",
"Internal synchronization error", MessageBoxButtons.OK, MessageBoxIcon.Error);
continue;
}
synchronizer.Configuration = deviceConfiguration;
synchronizer.SynchronizeError += new SynchronizeErrorEventHandler(OnSynchronizeError);
synchronizer.SynchronizeComplete += new SynchronizeCompleteEventHandler(OnSynchronizeComplete);
synchronizer.SynchronizeCancelled += new SynchronizeCancelledEventHandler(OnSynchronizeCancelled);
synchronizer.SynchronizeDevice((IITUserPlaylist)playlist, drive, device);
}
}
}
catch (Exception ex)
{
l.Error(ex);
string message = "I encountered an unexpected error while synchronizing your device(s). "
+ "\n\nPlease make sure your devices are properly "
+ "connected and try again.";
itaTray.ShowBalloonTip(7, "Synchronize error", message, ToolTipIcon.Error);
}
if (syncForm != null && configuration.CloseSyncWindowOnSuccess)
{
syncForm.CloseSafe();
}
}
private void button6_Click(object sender, EventArgs e)
{
SelectDriveForm sdf = new SelectDriveForm();
if (sdf.ShowDialog() == DialogResult.OK)
{
// check if a removable drive
System.IO.DriveInfo di = sdf.SelectedDrive;
if (di.DriveType != System.IO.DriveType.Removable)
{
if (di.DriveType == System.IO.DriveType.Ram)
{
MessageBox.Show("You have selected a RAM drive. This is not allowed.");
return;
}
else if (di.DriveType == System.IO.DriveType.NoRootDirectory)
{
MessageBox.Show("The Selected drive doesn't have a root Directory!");
return;
}
DialogResult r = MessageBox.Show("Warning: The drive you have selected isn't a removable drive.\nContinue?", "OH NOES!", MessageBoxButtons.YesNo);
if (r == System.Windows.Forms.DialogResult.No)
{
return;
}
}
// generate Drive info
IITPlaylist device = GetPlaylistNameForm.InputBox();
Device newDevice = new Device(device, di);
listBox1.Items.Add(newDevice.Name.ToUpper() + " (" + newDevice.iTunesPlaylist.Name + ")");
ManagedDrives.Add(newDevice);
//MessageBox.Show("To put songs on your device, drag them onto the playlist, \n" + "Then press 'sync'");
}
}
public PlaylistCollection()
{
PlaylistNodes = new List <PlaylistCollection>();
Name = "root";
_playlist = null;
Playlist = null;
_parent = null;
}
private PlaylistCollection(IITPlaylist playlist, PlaylistCollection parent)
{
PlaylistNodes = new List <PlaylistCollection>();
_playlist = playlist;
Playlist = new Playlist(_playlist);
Name = Playlist.Name;
_parent = parent;
}
private static List <Track> BuildLibraryTrackList(iTunesLibrary library, DisplayMessage dm, BackgroundWorker bgw, DoWorkEventArgs bgwArgs)
{
dm(new OutputMessage("Scanning track library...", MessageSeverity.Always));
List <Track> trackList = new List <Track>();
IITPlaylist libraryPlaylist = library.GetLibraryPlaylist();
if (libraryPlaylist != null)
{
int trackCount = libraryPlaylist.Tracks.Count;
int currentTrackIndex = 0;
foreach (IITTrack track in libraryPlaylist.Tracks)
{
if (bgw.CancellationPending == true)
{
break;
}
double percentComplete = Math.Floor(((double)currentTrackIndex / (double)trackCount) * 100.0);
int intPercentComplete = (int)percentComplete;
bgw.ReportProgress(intPercentComplete);
currentTrackIndex++;
if (
track is IITFileOrCDTrack &&
((IITFileOrCDTrack)track).Kind == ITTrackKind.ITTrackKindFile &&
((IITFileOrCDTrack)track).VideoKind == ITVideoKind.ITVideoKindNone &&
((IITFileOrCDTrack)track).Podcast == false &&
string.Compare(((IITFileOrCDTrack)track).Genre, "Voice Memo") != 0
)
{
try
{
IITFileOrCDTrack fileTrack = (IITFileOrCDTrack)track;
Track tr = Track.GetTrack(fileTrack, library.GetITunesApp());
trackList.Add(tr);
}
catch (Exception ex)
{
dm(new OutputMessage("Error: Could not get track information for Track \"" + track.Name + "\", Artist = \"" + track.Artist + "\", Album = \"" + track.Album + "\": " + ex.Message, MessageSeverity.Warning));
}
}
else
{
dm(new OutputMessage("Found excluded track \"" + track.Name + "\", Artist = \"" + track.Artist + "\", Album = \"" + track.Album + "\".", MessageSeverity.Debug));
}
}
}
else
{
dm(new OutputMessage("Could not retrieve the library playlist from the iTunes library.", MessageSeverity.Error));
}
return(trackList);
}
private void PlayPlaylist(IITPlaylist pl)
{
if (pl.Tracks.Count != 0)
{
pl.PlayFirstTrack();
pl.SongRepeat = ITPlaylistRepeatMode.ITPlaylistRepeatModeAll;
pl.Shuffle = false;
}
}
private PlaylistCollection SearchForParentNode(IITPlaylist playlist)
{
// This won't work for non user playlists
if (!(playlist is IITUserPlaylist userPlaylist))
{
return(null);
}
return(SearchForParentNode(userPlaylist));
}
private void button2_Click(object sender, EventArgs e)
{
// use the selected Playlist
if (listBox1.SelectedIndex == -1)
return;
string s = (string)listBox1.SelectedItem;
string parent = s.Split(new string[] { "->" }, StringSplitOptions.None)[0];
string child = s.Split(new string[] { "->" }, StringSplitOptions.None)[1];
IITSource source = MainForm.iTunes.Sources.ItemByName[parent];
IITPlaylist p = source.Playlists.ItemByName[child];
Result = p;
this.Close();
}
public void Clear()
{
IITPlaylist recently = GetRecentyPlayed();
if (recently == null)
{
throw new Exception("No iDotFm list found in iTunes");
}
foreach (IITTrack track in recently.Tracks)
{
track.PlayedCount = 0;
}
}
public static void RemoveOldTracks(IITPlaylist playlist)
{
foreach (var track in playlist.Tracks.Cast <IITTrack>().ToList())
{
if (track.Kind == ITTrackKind.ITTrackKindFile)
{
var fileTrack = track as IITFileOrCDTrack;
if (string.IsNullOrEmpty(fileTrack?.Location) || !File.Exists(fileTrack.Location))
{
fileTrack?.Delete();
}
}
}
}
public void InsertNode(IITPlaylist playlist)
{
var parentNode = SearchForParentNode(playlist);
var node = new PlaylistCollection(playlist, parentNode);
// if we could not find a parent this is the root element.
if (parentNode == null)
{
parentNode = this;
}
// add the node to the parent node
node._parent = parentNode;
parentNode.PlaylistNodes.Add(node);
}
public static iTunesLib.IITUserPlaylist GetiTunesPlaylist(iTunesLib.IiTunes iitApp, string strPlaylist)
{
IITUserPlaylist returnPlaylist = null;
IITPlaylistCollection playlists = iitApp.LibrarySource.Playlists;
int numPlaylists = playlists.Count;
Object podcastfolder = null;
// find the Dopppler Podcasts folder in iTunes
foreach (IITPlaylist folder in iitApp.LibrarySource.Playlists)
{
if (folder.Name == "Doppler Podcasts")
{
podcastfolder = folder;
break;
}
}
if (podcastfolder == null)
{
podcastfolder = iitApp.CreateFolder("Doppler Podcasts");
}
while (numPlaylists != 0)
{
Object currPlaylist = playlists[numPlaylists];
IITPlaylist tempPlaylist = (IITPlaylist)currPlaylist;
// is this a user playlist?
if (tempPlaylist.Kind == ITPlaylistKind.ITPlaylistKindUser)
{
IITUserPlaylist thisPlaylist = (IITUserPlaylist)currPlaylist;
if (thisPlaylist.Name == strPlaylist)
{
returnPlaylist = thisPlaylist;
break;
}
}
numPlaylists--;
}
if (returnPlaylist == null)
{
returnPlaylist = (IITUserPlaylist)iitApp.CreatePlaylist(strPlaylist);
returnPlaylist.set_Parent(ref podcastfolder);
//returnPlaylist = GetiTunesPlaylist(iitApp, strPlaylist);
}
return(returnPlaylist);
}
private void button2_Click(object sender, EventArgs e)
{
// use the selected Playlist
if (listBox1.SelectedIndex == -1)
{
return;
}
string s = (string)listBox1.SelectedItem;
string parent = s.Split(new string[] { "->" }, StringSplitOptions.None)[0];
string child = s.Split(new string[] { "->" }, StringSplitOptions.None)[1];
IITSource source = MainForm.iTunes.Sources.ItemByName[parent];
IITPlaylist p = source.Playlists.ItemByName[child];
Result = p;
this.Close();
}
public static bool RemoveTrack(IITPlaylist playlist, PlaylistItem item)
{
foreach (var track in playlist.Tracks.Cast <IITTrack>().ToList())
{
if (track.Kind == ITTrackKind.ITTrackKindFile)
{
var fileTrack = track as IITFileOrCDTrack;
if (fileTrack?.Name == item.Title)
{
return(true);
}
}
}
return(false);
}
public static void AddTrack(IITPlaylist playlist, PlaylistItem item, string path)
{
foreach (var track in AppClass.LibraryPlaylist.Tracks.Cast <IITTrack>().ToList())
{
if (track.Kind == ITTrackKind.ITTrackKindFile)
{
var fileTrack = track as IITFileOrCDTrack;
if ((fileTrack?.Location == path) || (fileTrack?.Name == item.Title))
{
return;
}
}
}
AppClass.LibraryPlaylist.AddFile(path);
// Add new song to playlist here
}
public void writeTracks(IITPlaylist playlist)
{
deleteImages();
writer.WriteStartDocument();
writer.WriteProcessingInstruction("xml-stylesheet", "type=\"text/xsl\" href=\"fullview.xsl\"");
writer.WriteStartElement("iTunesXML");
foreach (IITTrack track in playlist.Tracks)
{
writeTrack(track);
}
writer.WriteEndElement();
writer.WriteEndDocument();
writer.Flush();
writer.Close();
}
public void writeTracks(IITPlaylist playlist, int num)
{
deleteImages();
writer.WriteStartDocument();
writer.WriteProcessingInstruction("xml-stylesheet", "type=\"text/xsl\" href=\"fullview.xsl\"");
writer.WriteStartElement("iTunesXML");
foreach (int i in new Range(1, num))
{
IITTrack track = playlist.Tracks.get_ItemByPlayOrder(i);
writeTrack(track);
}
writer.WriteEndElement();
writer.WriteEndDocument();
writer.Flush();
writer.Close();
}
public void LoadPlaylist(Playlist playlist)
{
IITObject playlistObject = _iTunesSucks.GetITObjectByID(playlist.iTunesSourceId, playlist.iTunesPlaylistId, 0, 0);
IITPlaylist iTunesPlaylist = (IITPlaylist)playlistObject;
if (playlistObject != null)
{
playlist.Name = iTunesPlaylist.Name;
foreach (IITTrack iTunesTrack in iTunesPlaylist.Tracks)
{
Song track = new Song()
{
Name = iTunesTrack.Name,
Artist = iTunesTrack.Artist,
};
playlist.Songs.Add(track);
}
}
}
private void SetPlayCount(IDictionary <string, int> playcountByArtist, string playlistName)
{
iTunesApp itunes = new iTunesApp();
IITLibraryPlaylist mainLibrary = itunes.LibraryPlaylist;
IITPlaylist playlist = itunes.LibrarySource.Playlists.GetPlaylist(playlistName);
IITTrackCollection tracks = playlist.Tracks;
for (int currTrackIndex = 1; currTrackIndex <= tracks.Count; currTrackIndex++)
{
IITTrack fileTrack = tracks[currTrackIndex];
if (playcountByArtist.ContainsKey(fileTrack.Artist))
{
fileTrack.PlayedCount = playcountByArtist[fileTrack.Artist];
}
else
{
Console.WriteLine("Skipped: {0} - {1}", fileTrack.Artist, fileTrack.Name);
}
}
}
public static Song[] GetSongsFromAlbum(string AlbumName) // TODO
{
List <Song> SongList = new List <Song>();
IITPlaylist Playlist = app.LibrarySource.Playlists.get_ItemByName("Library");
foreach (IITTrack Track in Playlist.Tracks)
{
if (Track.Kind != ITTrackKind.ITTrackKindFile)
{
continue;
}
IITFileOrCDTrack FileTrack = (IITFileOrCDTrack)Track;
if (Track.Album == AlbumName)
{
SongList.Add(new Song(Track));
}
}
return(SongList.ToArray());
}
private static void Export(string playlistName, string pathToExport)
{
//IITLibraryPlaylist mainLibrary = itunes.LibraryPlaylist;
IITPlaylist playlist = itunes.LibrarySource.Playlists.Cast <IITPlaylist>().FirstOrDefault(pl => pl.Name.Equals(playlistName, StringComparison.InvariantCultureIgnoreCase));
List <string> filePaths = GetTracks(playlist);
int songCount = 0;
foreach (string filePath in filePaths)
{
string fileName = Path.GetFileName(filePath);
if (fileName == null)
{
continue;
}
List <char> invalidCharacters = Path.GetInvalidFileNameChars().ToList();
invalidCharacters.AddRange(Path.GetInvalidPathChars());
fileName = invalidCharacters.Aggregate(fileName, (current, invalidCharacter) => current.Replace(invalidCharacter, '.'));
string destination = Path.Combine(pathToExport, fileName);
Console.WriteLine("{0}. {1}", ++songCount, filePath);
if (File.Exists(destination))
{
continue;
}
File.Copy(filePath, destination);
}
Process.Start(pathToExport);
Console.ReadLine();
}
private KeyValuePair <byte, string>[][] GetPlaylistTracks(IITPlaylist playlist)
{
var files = new List <KeyValuePair <byte, string>[]>();
SelectedPlaylistLocationsToPersistentIds.Clear();
foreach (IITTrack currTrack in playlist.Tracks)
{
if (currTrack.Kind == ITTrackKind.ITTrackKindFile)
{
var fileTrack = (IITFileOrCDTrack)currTrack;
if (fileTrack.Location != null)
{
SelectedPlaylistLocationsToPersistentIds.Add(fileTrack.Location, iTunes.GetPersistentId(fileTrack));
files.Add(fileTrack.ToMusicBeeFileProperties());
}
}
Marshal.ReleaseComObject(currTrack);
}
return(files.ToArray());
}
private void AllProps(iTunesAppClass itunes)
{
bool acmpEnabled = itunes.AppCommandMessageProcessingEnabled;
IITEncoder encoder = itunes.CurrentEncoder;
IITEQPreset eqPreset = itunes.CurrentEQPreset;
IITPlaylist playlist = itunes.CurrentPlaylist;
string streamTitle = itunes.CurrentStreamTitle;
string streamURL = itunes.CurrentStreamURL;
IITTrack track = itunes.CurrentTrack;
IITVisual visual = itunes.CurrentVisual;
IITEncoderCollection encoders = itunes.Encoders;
bool eqEnabled = itunes.EQEnabled;
IITEQPresetCollection eqPresets = itunes.EQPresets;
// this always seems to raise a COM exception, whether playing or stopped...
//IITWindow eqWindow = itunes.EQWindow;
bool fgOnDialog = itunes.ForceToForegroundOnDialog;
bool fsVisuals = itunes.FullScreenVisuals;
IITLibraryPlaylist libPlaylist = itunes.LibraryPlaylist;
IITSource libSource = itunes.LibrarySource;
string libXmlPath = itunes.LibraryXMLPath;
bool mute = itunes.Mute;
// this will raise a COM exception when iTunes first started
//int position = itunes.PlayerPosition;
ITPlayerState state = itunes.PlayerState;
IITTrackCollection selectedTracks = itunes.SelectedTracks;
int volume = itunes.SoundVolume;
bool volEnabled = itunes.SoundVolumeControlEnabled;
IITSourceCollection sources = itunes.Sources;
string version = itunes.Version;
IITVisualCollection visuals = itunes.Visuals;
bool visualsEnabled = itunes.VisualsEnabled;
ITVisualSize visualSize = itunes.VisualSize;
IITWindowCollection windows = itunes.Windows;
}
private void PlayButtonClick(object sender, EventArgs e)
{
const string noTrack = "Wrong track";
// create new playlist if it is not exists yet
if (_playlist == null)
{
_playlist = _player.CreatePlaylist(artistComboBox.Text);
var x = (_playlist as IITUserPlaylist);
if (x == null)
// something bad happened
return;
// populating new playlist
foreach (var tr in _player.LibraryPlaylist.SearchSafe(artistComboBox.Text, ITPlaylistSearchField.ITPlaylistSearchFieldArtists).OfType<IITTrack>())
{
object oTrack = tr;
x.AddTrack(ref oTrack);
}
}
// prepare playlist
object oPlaylist = _playlist;
_player.BrowserWindow.set_SelectedPlaylist(ref oPlaylist);
if (_player.get_CanSetShuffle(ref oPlaylist))
{
var control = sender as Control;
_playlist.Shuffle = control != null && control.Tag.Equals(true);
}
// find track
var track = _playlist.SearchSafe(songComboBox.Text, ITPlaylistSearchField.ITPlaylistSearchFieldSongNames).OfType<IITTrack>().FirstOrDefault();
if (track == null)
MessageBox.Show(noTrack);
else
track.Play();
Hide();
}
// getthe tracks from the the specified playlist
private static List <string> GetTracks(IITPlaylist playlist)
{
List <string> filePaths = new List <string>();
// get the collection of tracks from the playlist
IITTrackCollection tracks = playlist.Tracks;
int numTracks = tracks.Count;
for (int currTrackIndex = 1; currTrackIndex <= numTracks; currTrackIndex++)
{
IITTrack currTrack = tracks[currTrackIndex];
if (!currTrack.Enabled)
{
continue;
}
if (currTrack.Kind == ITTrackKind.ITTrackKindFile)
{
IITFileOrCDTrack file = (IITFileOrCDTrack)currTrack;
if (file.Location != null)
{
FileInfo fi = new FileInfo(file.Location);
if (fi.Exists)
{
filePaths.Add(file.Location);
}
else
{
Console.WriteLine("not found " + file.Location);
}
}
}
}
return(filePaths);
}
private void ArtistComboBoxLeave(object sender, EventArgs e)
{
songComboBox.Items.Clear();
int idx = artistComboBox.FindStringExact(artistComboBox.Text);
IEnumerable tracks = Enumerable.Empty<IITTrack>();
// if selected playlist exists
if (idx >= 0)
{
_playlist = _playlists[idx];
tracks = _playlist.Tracks;
}
// if was entered part of the artist name
else if(!string.IsNullOrEmpty(artistComboBox.Text))
{
_playlist = null;
tracks = _player.LibraryPlaylist.SearchSafe(artistComboBox.Text, ITPlaylistSearchField.ITPlaylistSearchFieldArtists);
}
// populate second combobox
foreach (var track in tracks.OfType<IITTrack>().Select(track => track.Name))
{
songComboBox.Items.Add(track);
}
}
private void GoButton_Click(object sender, EventArgs e)
{
if (PlaylistComboBox.SelectedItem == null)
{
MessageBox.Show("Please select a playlist.", "Error", MessageBoxButtons.OK);
return;
}
else
{
// Look for the selected playlist.
foreach (IITPlaylist playlist in iTunes.LibrarySource.Playlists)
{
if (playlist.Name == PlaylistComboBox.SelectedItem.ToString())
{
selectedPlaylist = playlist;
break;
}
}
}
// Warn about playlists with more than 1000 tracks.
if (selectedPlaylist.Tracks.Count > 1000)
{
if (MessageBox.Show("The selected playlist has " + selectedPlaylist.Tracks.Count + " tracks. Do you want to continue?", "Confirmation", MessageBoxButtons.YesNo) == DialogResult.No)
{
return;
}
}
// Get the tracks and populate the grid-view.
MainDataGridView.DataSource = GetTracks(selectedPlaylist);
// Useful code example: How to get the main library.
// IITLibraryPlaylist mainLibrary = iTunes.LibraryPlaylist;
// selectedPlaylist = (IITPlaylist)mainLibrary;
}
public void Run(string playlistName)
{
iTunesApp itunes = new iTunesApp();
IITLibraryPlaylist mainLibrary = itunes.LibraryPlaylist;
IITPlaylist playlist = itunes.LibrarySource.Playlists.GetPlaylist(playlistName);
IITTrackCollection tracks = playlist.Tracks;
string csvFilePath = GetFullCsvFilePath(playlistName);
if (CheckIfUserWantsToAbort(csvFilePath))
{
return;
}
using (StreamWriter csvFile = new StreamWriter(csvFilePath))
{
for (int currTrackIndex = 1; currTrackIndex <= tracks.Count; currTrackIndex++)
{
IITTrack fileTrack = tracks[currTrackIndex];
Console.WriteLine("{0},{1},{2},{3}", fileTrack.Artist, fileTrack.TrackNumber, fileTrack.Name, fileTrack.PlayedCount);
csvFile.WriteLine("\"{0}\",{1},\"{2}\",{3}", fileTrack.Artist, fileTrack.TrackNumber, fileTrack.Name, fileTrack.PlayedCount);
}
}
}
private void WriteRatings(IITPlaylist playlist)
{
foreach (IITTrack playlistTrack in playlist.Tracks)
{
var file = (IITFileOrCDTrack)playlistTrack;
if (File.Exists(file.Location))
{
var tagFile = TagLib.File.Create(file.Location);
var tags = tagFile.GetTag(TagTypes.Id3v2);
var popm = TagLib.Id3v2.PopularimeterFrame.Get((TagLib.Id3v2.Tag)tags, email, true);
var computedRating = Math.Ceiling(ConvertToItunesRatingRange(popm.Rating));
var computedStars = ConvertToStarRange(computedRating);
Console.WriteLine($"Rating for {file.Artist}-{file.Name} => {computedRating} ({computedStars} stars)");
if (!simulateOnly)
{
file.Rating = (int)computedRating;
}
}
}
}
private void SelectSongFormVisibleChanged(object sender, EventArgs e)
{
if (Visible)
{
_playlists = _player.LibrarySource.Playlists.Cast<IITPlaylist>()
.Where(plist => plist.Kind == ITPlaylistKind.ITPlaylistKindUser).ToArray();
artistComboBox.Items.AddRange(_playlists.Select(plist => plist.Name).ToArray());
}
else
{
_playlist = null;
artistComboBox.Items.Clear();
songComboBox.Items.Clear();
artistComboBox.Text = string.Empty;
songComboBox.Text = string.Empty;
artistComboBox.Focus();
}
}
public Device(IITPlaylist playlist, DriveInfo device)
{
_iTunesPlaylist = playlist;
Drive = device;
Name = device.Name;
}
private void comboBoxPlaylists_SelectedIndexChanged(object sender, EventArgs e)
{
if (panelEditor.Visible)
{
foreach (IITPlaylist playlist in librarySource.Playlists)
{
if (playlist.Name == comboBoxPlaylists.Text)
{
playlistSource = playlist;
break;
}
}
}
}
private List<Track> ListTracks(IITPlaylist playlist)
{
var results = new List<Track>();
for (int n = 1; n <= Math.Min(20, playlist.Tracks.Count); n++)
{
if (playlist.Tracks[n].Enabled)
{
int low;
int high;
object iObject = playlist.Tracks[n];
iTunes.GetITObjectPersistentIDs(ref iObject, out high, out low);
results.Add(new Track(playlist.Tracks[n].Name, low, high));
}
}
return results;
}
private void populatePlaylists(string selectedPlaylist = "")
{
if (librarySource != null)
{
if (string.IsNullOrWhiteSpace(selectedPlaylist))
{
selectedPlaylist = defaultPlaylist;
}
foreach (IITPlaylist playlist in librarySource.Playlists)
{
var index = comboBoxPlaylists.Items.Add(playlist.Name);
if (playlist.Name == selectedPlaylist)
{
playlistSource = playlist;
comboBoxPlaylists.SelectedIndex = index;
}
}
}
}
/// <summary>
/// Initialize a new instance that wraps the given iTunes playlist COM object.
/// </summary>
/// <param name="playlist">An IITPlaylist instance.</param>
public Playlist(IITPlaylist playlist)
: base()
{
this.playlist = playlist;
this.isSelected = false;
}
/// <summary>
/// Interaction.Cleanup override; release reference to internal playlist.
/// </summary>
protected override void Cleanup()
{
Release(playlist);
playlist = null;
}
/// <summary>
/// Interaction.Cleanup override; release reference to internal playlist.
/// </summary>
protected override void Cleanup(bool finalRelease)
{
Release(playlist);
playlist = null;
}
public void writeTracks(IITPlaylist playlist)
{
writeTracks(playlist, 10);
}
public iTunesPlaylist(IITPlaylist playlist)
{
m_playlist = playlist;
}
