public CmdCoverArtDrop(object[] parameters)
{
object[] cmdParms = (object[])parameters[1];
var fileName = (string)cmdParms[0];
Util.SendMessage("setwaitcursor", null);
Util.SendProgress(string.Format("Downloading picture from {0}", fileName));
if (fileName.ToLower().StartsWith("http"))
{
_pic = GetCoverArtFromUrl(fileName);
}
else
{
_pic = new Picture(fileName);
}
if (_pic == null || _pic.Data == null)
{
Util.SendMessage("resetwaitcursor", null);
return;
}
if (Options.MainSettings.ChangeCoverSize && Picture.ImageFromData(_pic.Data).Width > Options.MainSettings.MaxCoverWidth)
{
_pic.Resize(Options.MainSettings.MaxCoverWidth);
}
_pic.MimeType = "image/jpg";
_pic.Description = "Front Cover";
_pic.Type = PictureType.FrontCover;
}
/// <summary>
/// A Picture file has been dropped on the Ribbon Gallery.
/// Set the picture for all selected rows
/// </summary>
/// <param name="fileName"></param>
public void CoverArtDrop(string fileName)
{
SetWaitCursor();
Util.SendProgress(string.Format("Downloading picture from {0}", fileName));
Picture pic = null;
if (fileName.ToLower().StartsWith("http"))
{
pic = GetCoverArtFromUrl(fileName);
}
else
{
pic = new Picture(fileName);
}
if (pic == null || pic.Data == null)
{
ResetWaitCursor();
return;
}
if (Options.MainSettings.ChangeCoverSize && Picture.ImageFromData(pic.Data).Width > Options.MainSettings.MaxCoverWidth)
{
pic.Resize(Options.MainSettings.MaxCoverWidth);
}
pic.MimeType = "image/jpg";
pic.Description = "Front Cover";
pic.Type = PictureType.FrontCover;
foreach (DataGridViewRow row in tracksGrid.SelectedRows)
{
ClearStatusColumn(row.Index);
TrackData track = Options.Songlist[row.Index];
track.Pictures.Clear();
track.Pictures.Add(pic);
SetBackgroundColorChanged(row.Index);
track.Changed = true;
Options.Songlist[row.Index] = track;
_itemsChanged = true;
}
Util.SendProgress("");
_main.SetGalleryItem();
ResetWaitCursor();
}
/// <summary>
/// Get Cover Art from a given Url
/// </summary>
/// <param name="url"></param>
/// <returns></returns>
private Picture GetCoverArtFromUrl(string url)
{
Picture pic = null;
try
{
// When dragging from Google images, we have a imgurl. extract the right url.
int imgurlIndex = url.IndexOf("imgurl=");
if (imgurlIndex > -1)
{
url = url.Substring(imgurlIndex + 7);
url = url.Substring(0, url.IndexOf("&"));
}
log.Info("Retrieving Coverart from: {0}", url);
WebRequest req = WebRequest.Create(url);
req.Proxy = new WebProxy();
req.Proxy.Credentials = CredentialCache.DefaultCredentials;
WebResponse response = req.GetResponse();
if (response == null)
{
return null;
}
Stream stream = response.GetResponseStream();
if (stream == null)
{
return null;
}
Image img = Image.FromStream(stream);
stream.Close();
pic = new Picture { Data = Picture.ImageToByte((Image)img.Clone()) };
if (Options.MainSettings.ChangeCoverSize && img.Width > Options.MainSettings.MaxCoverWidth)
{
pic.Resize(Options.MainSettings.MaxCoverWidth);
}
img.Dispose();
return pic;
}
catch (Exception ex)
{
log.Error("Error retrieving Image from Url: {0} Error: {1}", url, ex.Message);
}
return null;
}
public void ShowAlbumDetails(Album album)
{
_dlgAlbumDetails = new AlbumDetails();
// Prepare the Details Dialog
_dlgAlbumDetails.Artist = album.Artist;
_dlgAlbumDetails.Album = album.Title;
_dlgAlbumDetails.Year = album.Year;
try
{
using (MemoryStream ms = new MemoryStream(album.AlbumImage.Data))
{
Image img = Image.FromStream(ms);
_dlgAlbumDetails.Cover.Image = img;
}
}
catch {}
// Add Tracks of the selected album
foreach (List<AlbumTrack> disc in album.Discs)
{
foreach (AlbumTrack track in disc)
{
ListViewItem lvItem = new ListViewItem(track.Number.ToString());
lvItem.SubItems.Add(track.Title);
_dlgAlbumDetails.AlbumTracks.Items.Add(lvItem);
}
}
// Add selected Files from Grid
foreach (DataGridViewRow row in _tracksGrid.Rows)
{
if (!row.Selected)
continue;
TrackData track = Options.Songlist[row.Index];
ListViewItem lvItem = new ListViewItem((row.Index + 1).ToString());
lvItem.SubItems.Add(track.FileName);
lvItem.Tag = row.Index;
_dlgAlbumDetails.DiscTracks.Items.Add(lvItem);
}
// if we have less files selected, than in the album, fill the rest with"unassigned"
if (_dlgAlbumDetails.DiscTracks.Items.Count < _dlgAlbumDetails.AlbumTracks.Items.Count)
{
for (int i = _dlgAlbumDetails.DiscTracks.Items.Count - 1; i < _dlgAlbumDetails.AlbumTracks.Items.Count - 1; i++)
{
ListViewItem unassignedItem = new ListViewItem((i + 2).ToString());
unassignedItem.SubItems.Add(ServiceScope.Get<ILocalisation>().ToString("Lookup", "Unassigned"));
unassignedItem.Tag = -1;
unassignedItem.Checked = false;
_dlgAlbumDetails.DiscTracks.Items.Add(unassignedItem);
}
}
int albumTrackPos = 0;
foreach (ListViewItem lvAlbumItem in _dlgAlbumDetails.AlbumTracks.Items)
{
int discTrackPos = 0;
foreach (ListViewItem lvDiscItem in _dlgAlbumDetails.DiscTracks.Items)
{
if (Util.LongestCommonSubstring(lvAlbumItem.SubItems[1].Text, lvDiscItem.SubItems[1].Text) > 0.75)
{
lvDiscItem.Checked = true;
_dlgAlbumDetails.DiscTracks.Items.RemoveAt(discTrackPos);
_dlgAlbumDetails.DiscTracks.Items.Insert(albumTrackPos, lvDiscItem);
break;
}
discTrackPos++;
}
albumTrackPos++;
}
_dlgAlbumDetails.Renumber();
if (main.ShowModalDialog(_dlgAlbumDetails) == DialogResult.OK)
{
int i = -1;
foreach (ListViewItem lvItem in _dlgAlbumDetails.DiscTracks.Items)
{
i++;
int index = (int)lvItem.Tag;
if (index == -1 || lvItem.Checked == false)
continue;
TrackData track = Options.Songlist[index];
track.Artist = _dlgAlbumDetails.Artist;
track.Album = _dlgAlbumDetails.Album;
string strYear = _dlgAlbumDetails.Year;
if (strYear.Length > 4)
strYear = strYear.Substring(0, 4);
int year = 0;
try
{
year = Convert.ToInt32(strYear);
}
catch (Exception) {}
if (year > 0 && track.Year == 0)
track.Year = year;
// Add the picture
ByteVector vector = album.AlbumImage;
if (vector != null)
{
MPTagThat.Core.Common.Picture pic = new MPTagThat.Core.Common.Picture();
pic.MimeType = "image/jpg";
pic.Description = "";
pic.Type = PictureType.FrontCover;
pic.Data = vector.Data;
track.Pictures.Add(pic);
}
ListViewItem trackItem = _dlgAlbumDetails.AlbumTracks.Items[i];
track.Track = trackItem.SubItems[0].Text;
track.Title = trackItem.SubItems[1].Text;
main.TracksGridView.SetBackgroundColorChanged(index);
track.Changed = true;
Options.Songlist[index] = track;
main.TracksGridView.Changed = true;
}
}
_dlgAlbumDetails.Dispose();
}
/// <summary>
/// Tag the the Selected files from Internet
/// </summary>
private void IdentifyFilesThread(object sender, DoWorkEventArgs e)
{
log.Trace(">>>");
//Make calls to Tracksgrid Threadsafe
if (tracksGrid.InvokeRequired)
{
ThreadSafeGridDelegate1 d = IdentifyFilesThread;
tracksGrid.Invoke(d, new[] { sender, e });
return;
}
int count = 0;
int trackCount = tracksGrid.SelectedRows.Count;
SetProgressBar(trackCount);
MusicBrainzAlbum musicBrainzAlbum = new MusicBrainzAlbum();
foreach (DataGridViewRow row in tracksGrid.Rows)
{
ClearStatusColumn(row);
if (!row.Selected)
{
continue;
}
count++;
try
{
Application.DoEvents();
_main.progressBar1.Value += 1;
if (_progressCancelled)
{
ResetProgressBar();
return;
}
TrackData track = bindingList[row.Index];
using (MusicBrainzTrackInfo trackinfo = new MusicBrainzTrackInfo())
{
log.Debug("Identify: Processing file: {0}", track.FullFileName);
List<MusicBrainzTrack> musicBrainzTracks = trackinfo.GetMusicBrainzTrack(track.FullFileName);
if (musicBrainzTracks == null)
{
log.Debug("Identify: Couldn't identify file");
continue;
}
if (musicBrainzTracks.Count > 0)
{
MusicBrainzTrack musicBrainzTrack = null;
if (musicBrainzTracks.Count == 1)
musicBrainzTrack = musicBrainzTracks[0];
else
{
// Skip the Album selection, if the album been selected already for a previous track
bool albumFound = false;
foreach (MusicBrainzTrack mbtrack in musicBrainzTracks)
{
if (mbtrack.AlbumID == musicBrainzAlbum.Id)
{
albumFound = true;
musicBrainzTrack = mbtrack;
break;
}
}
if (!albumFound)
{
MusicBrainzAlbumResults dlgAlbumResults = new MusicBrainzAlbumResults(musicBrainzTracks);
dlgAlbumResults.Owner = _main;
if (_main.ShowModalDialog(dlgAlbumResults) == DialogResult.OK)
{
if (dlgAlbumResults.SelectedListItem > -1)
musicBrainzTrack = musicBrainzTracks[dlgAlbumResults.SelectedListItem];
else
musicBrainzTrack = musicBrainzTracks[0];
}
dlgAlbumResults.Dispose();
}
}
// We didn't get a track
if (musicBrainzTrack == null)
{
log.Debug("Identify: No information returned from Musicbrainz");
continue;
}
// Are we still at the same album?
// if not, get the album, so that we have the release date
if (musicBrainzAlbum.Id != musicBrainzTrack.AlbumID)
{
using (MusicBrainzAlbumInfo albumInfo = new MusicBrainzAlbumInfo())
{
Application.DoEvents();
if (_progressCancelled)
{
ResetProgressBar();
return;
}
musicBrainzAlbum = albumInfo.GetMusicBrainzAlbumById(musicBrainzTrack.AlbumID.ToString());
}
}
track.Title = musicBrainzTrack.Title;
track.Artist = musicBrainzTrack.Artist;
track.Album = musicBrainzTrack.Album;
track.Track = musicBrainzTrack.Number.ToString();
if (musicBrainzAlbum.Year != null && musicBrainzAlbum.Year.Length >= 4)
track.Year = Convert.ToInt32(musicBrainzAlbum.Year.Substring(0, 4));
// Do we have a valid Amazon Album?
if (musicBrainzAlbum.Amazon != null)
{
// Only write a picture if we don't have a picture OR Overwrite Pictures is set
if (track.Pictures.Count == 0 || Options.MainSettings.OverwriteExistingCovers)
{
ByteVector vector = musicBrainzAlbum.Amazon.AlbumImage;
if (vector != null)
{
MPTagThat.Core.Common.Picture pic = new MPTagThat.Core.Common.Picture();
pic.MimeType = "image/jpg";
pic.Description = "";
pic.Type = PictureType.FrontCover;
pic.Data = pic.ImageFromData(vector.Data);
track.Pictures.Add(pic);
}
}
}
SetBackgroundColorChanged(row.Index);
track.Changed = true;
_itemsChanged = true;
}
}
}
catch (Exception ex)
{
SetStatusColumnError(row);
AddErrorMessage(row, ex.Message);
}
}
tracksGrid.Refresh();
tracksGrid.Parent.Refresh();
_main.TagEditForm.FillForm();
ResetProgressBar();
log.Trace("<<<");
}
/// <summary>
/// Get Cover Art via Amazon Webservice
/// </summary>
private void GetCoverArtThread()
{
log.Trace(">>>");
//Make calls to Tracksgrid Threadsafe
if (tracksGrid.InvokeRequired)
{
ThreadSafeGridDelegate d = GetCoverArtThread;
tracksGrid.Invoke(d, new object[] { });
return;
}
int count = 0;
int trackCount = tracksGrid.SelectedRows.Count;
SetProgressBar(trackCount);
AmazonAlbum amazonAlbum = null;
bool isMultipleArtistAlbum = false;
string savedArtist = "";
string savedAlbum = "";
string savedFolder = "";
Core.Common.Picture folderThumb = null;
// Find out, if we deal with a multiple artist album and submit only the album name
// If we have different artists, then it is a multiple artist album.
// BUT: if the album is different, we don't have a multiple artist album and should submit the artist as well
foreach (DataGridViewRow row in tracksGrid.Rows)
{
ClearStatusColumn(row);
if (!row.Selected)
{
continue;
}
TrackData track = bindingList[row.Index];
if (savedArtist == "")
{
savedArtist = track.Artist;
savedAlbum = track.Album;
}
if (savedArtist != track.Artist)
{
isMultipleArtistAlbum = true;
}
if (savedAlbum != track.Album)
{
isMultipleArtistAlbum = false;
break;
}
}
if (isMultipleArtistAlbum)
{
log.Debug("CoverArt: Album contains Multiple Artists, just search for the album");
}
Dictionary<string, AmazonAlbum> savedCoverCash = new Dictionary<string, AmazonAlbum>();
foreach (DataGridViewRow row in tracksGrid.Rows)
{
ClearStatusColumn(row);
if (!row.Selected)
{
continue;
}
count++;
try
{
Application.DoEvents();
_main.progressBar1.Value += 1;
if (_progressCancelled)
{
ResetProgressBar();
return;
}
TrackData track = bindingList[row.Index];
log.Debug("CoverArt: Retrieving coverart for: {0} - {1}", track.Artist, track.Album);
// Should we take an existing folder.jpg instead of searching the web
if (Options.MainSettings.EmbedFolderThumb && !Options.MainSettings.OnlySaveFolderThumb)
{
if (folderThumb == null || Path.GetDirectoryName(track.FullFileName) != savedFolder)
{
savedFolder = Path.GetDirectoryName(track.FullFileName);
folderThumb = GetFolderThumb(savedFolder);
}
if (folderThumb != null)
{
// Only write a picture if we don't have a picture OR Overwrite Pictures is set
if (track.Pictures.Count == 0 || Options.MainSettings.OverwriteExistingCovers)
{
log.Debug("CoverArt: Using existing folder.jpg");
// First Clear all the existingPictures
track.Pictures.Clear();
track.Pictures.Add(folderThumb);
SetBackgroundColorChanged(row.Index);
track.Changed = true;
_itemsChanged = true;
_main.SetGalleryItem();
}
continue;
}
}
// If we don't have an Album don't do any query
if (track.Album == "")
continue;
string coverSearchString = track.Artist + track.Album;
if (isMultipleArtistAlbum)
{
coverSearchString = track.Album;
}
bool foundInCash = savedCoverCash.ContainsKey(coverSearchString);
if (foundInCash)
{
amazonAlbum = savedCoverCash[coverSearchString];
}
else
{
amazonAlbum = null;
}
// Only retrieve the Cover Art, if we don't have it yet)
if (!foundInCash || amazonAlbum == null)
{
CoverSearch dlgAlbumResults = new CoverSearch();
dlgAlbumResults.Artist = isMultipleArtistAlbum ? "" : track.Artist;
dlgAlbumResults.Album = track.Album;
dlgAlbumResults.FileDetails = track.FullFileName;
dlgAlbumResults.Owner = _main;
amazonAlbum = null;
DialogResult dlgResult = _main.ShowModalDialog(dlgAlbumResults);
if (dlgResult == DialogResult.OK)
{
if (dlgAlbumResults.SelectedAlbum != null)
{
amazonAlbum = dlgAlbumResults.SelectedAlbum;
}
}
else if (dlgResult == DialogResult.Abort)
{
log.Debug("CoverArt: Search for all albums cancelled");
break;
}
else
{
log.Debug("CoverArt: Album Selection cancelled");
continue;
}
dlgAlbumResults.Dispose();
}
// Now update the Cover Art
if (amazonAlbum != null)
{
if (!savedCoverCash.ContainsKey(coverSearchString))
{
savedCoverCash.Add(coverSearchString, amazonAlbum);
}
// Only write a picture if we don't have a picture OR Overwrite Pictures is set);
if ((track.Pictures.Count == 0 || Options.MainSettings.OverwriteExistingCovers) && !Options.MainSettings.OnlySaveFolderThumb)
{
track.Pictures.Clear();
ByteVector vector = amazonAlbum.AlbumImage;
if (vector != null)
{
MPTagThat.Core.Common.Picture pic = new MPTagThat.Core.Common.Picture();
pic.MimeType = "image/jpg";
pic.Description = "Front Cover";
pic.Type = PictureType.FrontCover;
pic.Data = pic.ImageFromData(vector.Data);
track.Pictures.Add(pic);
}
// And also set the Year from the Release Date delivered by Amazon
// only if not present in Track
if (amazonAlbum.Year != null)
{
string strYear = amazonAlbum.Year;
if (strYear.Length > 4)
strYear = strYear.Substring(0, 4);
int year = 0;
try
{
year = Convert.ToInt32(strYear);
}
catch (Exception) { }
if (year > 0 && track.Year == 0)
track.Year = year;
}
SetBackgroundColorChanged(row.Index);
track.Changed = true;
_itemsChanged = true;
_main.SetGalleryItem();
}
}
// If the user has selected to store only the folder thumb, without touching the file
if (amazonAlbum != null && Options.MainSettings.OnlySaveFolderThumb)
{
ByteVector vector = amazonAlbum.AlbumImage;
if (vector != null)
{
string fileName = Path.Combine(Path.GetDirectoryName(track.FullFileName), "folder.jpg");
try
{
MPTagThat.Core.Common.Picture pic = new MPTagThat.Core.Common.Picture();
Image img = pic.ImageFromData(vector.Data);
// Need to make a copy, otherwise we have a GDI+ Error
Bitmap bmp = new Bitmap(img);
bmp.Save(fileName, ImageFormat.Jpeg);
FileInfo fi = new FileInfo(fileName);
_nonMusicFiles.RemoveAll(f => f.Name == fi.Name);
_nonMusicFiles.Add(fi);
_main.MiscInfoPanel.AddNonMusicFiles(_nonMusicFiles);
}
catch (Exception ex)
{
log.Error("Exception Saving picture: {0} {1}", fileName, ex.Message);
}
break;
}
}
}
catch (Exception ex)
{
SetStatusColumnError(row);
AddErrorMessage(row, ex.Message);
}
}
tracksGrid.Refresh();
tracksGrid.Parent.Refresh();
_main.TagEditForm.FillForm();
ResetProgressBar();
log.Trace("<<<");
}
public void ShowAlbumDetails(AmazonAlbum album)
{
dlgAlbumDetails = new AlbumDetails();
// Prepare the Details Dialog
dlgAlbumDetails.Artist = album.Artist;
dlgAlbumDetails.Album = album.Title;
dlgAlbumDetails.Year = album.Year;
try
{
using (MemoryStream ms = new MemoryStream(album.AlbumImage.Data))
{
Image img = Image.FromStream(ms);
if (img != null)
{
dlgAlbumDetails.Cover.Image = img;
}
}
}
catch {}
// Add Tracks of the selected album
foreach (List <AmazonAlbumTrack> disc in album.Discs)
{
foreach (AmazonAlbumTrack track in disc)
{
ListViewItem lvItem = new ListViewItem(track.Number.ToString());
lvItem.SubItems.Add(track.Title);
dlgAlbumDetails.AlbumTracks.Items.Add(lvItem);
}
}
// Add selected Files from Grid
foreach (DataGridViewRow row in _tracksGrid.Rows)
{
if (!row.Selected)
{
continue;
}
TrackData track = main.TracksGridView.TrackList[row.Index];
ListViewItem lvItem = new ListViewItem((row.Index + 1).ToString());
lvItem.SubItems.Add(track.FileName);
lvItem.Tag = row.Index;
dlgAlbumDetails.DiscTracks.Items.Add(lvItem);
}
// if we have less files selected, than in the album, fill the rest with"unassigned"
if (dlgAlbumDetails.DiscTracks.Items.Count < dlgAlbumDetails.AlbumTracks.Items.Count)
{
for (int i = dlgAlbumDetails.DiscTracks.Items.Count - 1; i < dlgAlbumDetails.AlbumTracks.Items.Count - 1; i++)
{
ListViewItem unassignedItem = new ListViewItem((i + 2).ToString());
unassignedItem.SubItems.Add(ServiceScope.Get <ILocalisation>().ToString("Lookup", "Unassigned"));
unassignedItem.Tag = -1;
unassignedItem.Checked = false;
dlgAlbumDetails.DiscTracks.Items.Add(unassignedItem);
}
}
int albumTrackPos = 0;
foreach (ListViewItem lvAlbumItem in dlgAlbumDetails.AlbumTracks.Items)
{
int discTrackPos = 0;
foreach (ListViewItem lvDiscItem in dlgAlbumDetails.DiscTracks.Items)
{
if (Util.LongestCommonSubstring(lvAlbumItem.SubItems[1].Text, lvDiscItem.SubItems[1].Text) > 0.75)
{
lvDiscItem.Checked = true;
dlgAlbumDetails.DiscTracks.Items.RemoveAt(discTrackPos);
dlgAlbumDetails.DiscTracks.Items.Insert(albumTrackPos, lvDiscItem);
break;
}
discTrackPos++;
}
albumTrackPos++;
}
dlgAlbumDetails.Renumber();
if (main.ShowModalDialog(dlgAlbumDetails) == DialogResult.OK)
{
int i = -1;
foreach (ListViewItem lvItem in dlgAlbumDetails.DiscTracks.Items)
{
i++;
int index = (int)lvItem.Tag;
if (index == -1 || lvItem.Checked == false)
{
continue;
}
TrackData track = main.TracksGridView.TrackList[index];
track.Artist = dlgAlbumDetails.Artist;
track.Album = dlgAlbumDetails.Album;
string strYear = dlgAlbumDetails.Year;
if (strYear.Length > 4)
{
strYear = strYear.Substring(0, 4);
}
int year = 0;
try
{
year = Convert.ToInt32(strYear);
}
catch (Exception) {}
if (year > 0 && track.Year == 0)
{
track.Year = year;
}
// Add the picture
ByteVector vector = album.AlbumImage;
if (vector != null)
{
MPTagThat.Core.Common.Picture pic = new MPTagThat.Core.Common.Picture();
pic.MimeType = "image/jpg";
pic.Description = "";
pic.Type = PictureType.FrontCover;
pic.Data = pic.ImageFromData(vector.Data);
track.Pictures.Add(pic);
}
ListViewItem trackItem = dlgAlbumDetails.AlbumTracks.Items[i];
track.Track = trackItem.SubItems[0].Text;
track.Title = trackItem.SubItems[1].Text;
main.TracksGridView.SetBackgroundColorChanged(index);
track.Changed = true;
main.TracksGridView.Changed = true;
main.TracksGridView.SetStatusColumnChange(main.TracksGridView.View.Rows[index]);
}
}
dlgAlbumDetails.Dispose();
}
