public static MovieSignature parseMediaMatch(MovieMatch movieMatch)
{
lock (loadingLock) {
if (signatureBuilders == null) {
signatureBuilders = new List<ISignatureBuilder>();
signatureBuilders.Add(new HashBuilder());
signatureBuilders.Add(new LocalBuilder());
signatureBuilders.Add(new BlurayMetaBuilder());
signatureBuilders.Add(new MetaServicesBuilder());
signatureBuilders.Add(new NfoBuilder());
signatureBuilders.Add(new ImdbBuilder());
}
}
MovieSignature movieSignature = new MovieSignature(movieMatch.LocalMedia);
foreach (ISignatureBuilder builder in signatureBuilders) {
SignatureBuilderResult result = builder.UpdateSignature(movieSignature);
// if a builder returns CONCLUSIVE it has updated the signature with
// what is believed to be accurate data and we can exit the loop
// Currently only the Hash and Imdb builder can return this status
if (result == SignatureBuilderResult.CONCLUSIVE)
break;
}
return movieSignature;
}
public ManualAssignPopup(MovieMatch match)
{
InitializeComponent();
foreach (DBLocalMedia currFile in match.LocalMedia) {
fileListBox.Items.Add(currFile.File);
}
uxTitle.Text = match.Signature.Title;
uxYear.Text = match.Signature.Year.ToString();
}
public SearchStringPopup(MovieMatch match)
{
InitializeComponent();
foreach (DBLocalMedia currFile in match.LocalMedia) {
fileListBox.Items.Add(currFile.File);
}
movieMatch = match;
uxTitle.Text = movieMatch.Signature.Title;
uxYear.Text = movieMatch.Signature.Year.ToString();
uxImdbId.Text = movieMatch.Signature.ImdbId;
}
private void movieStatusChangedListener(MovieMatch obj, MovieImporterAction action)
{
// we dont care about any messages except those about media matches
if (obj == null)
return;
// This ensures we are thread safe. Makes sure this method is run by
// the thread that created this panel.
if (InvokeRequired) {
Delegate method = new MovieImporter.MovieStatusChangedHandler(movieStatusChangedListener);
object[] parameters = new object[] { obj, action };
this.Invoke(method, parameters);
return;
}
// if this is not a message about our files ignore it
if (!obj.LocalMedia.Contains(localMedia[0]))
return;
// store the current match
mediaMatch = obj;
switch (action) {
case MovieImporterAction.ADDED:
case MovieImporterAction.PENDING:
statusLabel.Text = "Possible match retrieval pending...";
break;
case MovieImporterAction.GETTING_MATCHES:
statusLabel.Text = "Retrieving possible matches...";
break;
case MovieImporterAction.NEED_INPUT:
updateCombo();
// auto choose the default (mainly to pull in metadata. we can
// easily undo if the user picks another movie.
mediaMatch.Selected = (PossibleMatch)possibleMatchesCombo.SelectedItem;
mediaMatch.HighPriority = true;
MovingPicturesCore.Importer.Approve(mediaMatch);
break;
case MovieImporterAction.APPROVED:
statusLabel.Text = "Close match found...";
updateCombo();
break;
case MovieImporterAction.GETTING_DETAILS:
statusLabel.Text = "Retrieving movie details...";
break;
case MovieImporterAction.COMMITED:
statusLabel.Text = "Match commited...";
movieDetails.DatabaseObject = mediaMatch.Selected.Movie;
break;
}
}
// Adds the files to the importer for processing. If a file has recently been commited
// and it's readded, it will be reprocessed.
private void ScanFiles(List<DBLocalMedia> importFileList, bool highPriority)
{
if (importFileList == null)
return;
List<DBLocalMedia> currFileSet = new List<DBLocalMedia>();
bool alwaysGroup = MovingPicturesCore.Settings.AlwaysGroupByFolder;
// sort the paths in alphabetical order
importFileList.Sort(new DBLocalMediaPathComparer());
foreach (DBLocalMedia currFile in importFileList) {
string fileName = currFile.File.Name;
// if we have already loaded this file, move to the next
if (currFile.ID != null) {
logger.Debug("SKIPPED: File='{0}', Reason='Already in the system'.", fileName);
continue;
}
// File is already in the matching system
if (matchLookup.ContainsKey(currFile)) {
logger.Debug("SKIPPED: File='{0}', Reason='Already being matched'", fileName);
continue;
}
// Files on logical volumes should have a serial number.
// Blocking these files from the import process prevents unnecessary duplications
if (!currFile.ImportPath.IsUnc && currFile.VolumeSerial == string.Empty) {
logger.Debug("SKIPPED: File='{0}', Reason='Missing volume serial'", fileName);
continue;
}
// exclude samplefiles and ignore them
if (VideoUtility.isSampleFile(currFile.File)) {
logger.Info("SKIPPED: File='{0}', Bytes={1}, Reason='Sample detected'", fileName, currFile.File.Length);
continue;
}
// Locked files are put in the files queue (to be processed later)
if (MovingPicturesCore.Settings.DelayLockedFiles && currFile.File.IsLocked()) {
filesQueue.Add(currFile);
logger.Info("DELAYED: File='{0}', Reason='File is locked'", fileName);
continue;
}
// Check file with existing localmedia (only for writable media)
if (!currFile.ImportPath.IsOpticalDrive) {
#region Moved/Renamed Files
// catch files that were moved/renamed while the plugin was not running
List<DBLocalMedia> existingMedia = null;
if (!currFile.IsImageFile && (currFile.IsDVD || currFile.IsBluray) && currFile.DiscId != null)
existingMedia = DBLocalMedia.GetEntriesByDiscId(currFile.DiscId);
else if (currFile.FileHash != null)
existingMedia = DBLocalMedia.GetEntriesByHash(currFile.FileHash);
// process existing media if applicable
if (existingMedia != null && existingMedia.Count > 0) {
bool moved = false;
lock (filesDeleted)
{
foreach (DBLocalMedia oldMedia in existingMedia)
{
bool queued = filesDeleted.Contains(oldMedia);
if (queued || oldMedia.ImportPath.Replaced || oldMedia.IsRemoved)
{
// remove the old media object from the removal queue if it was present.
if (queued) {
filesDeleted.Remove(oldMedia);
}
logger.Info("File '{0}' was moved/renamed to '{1}'. Updating existing entry.", oldMedia.FullPath, currFile.FullPath);
// update our old media object with the new information
oldMedia.ImportPath = currFile.ImportPath;
oldMedia.File = currFile.File;
oldMedia.UpdateVolumeInformation();
oldMedia.Commit();
moved = true;
break;
}
}
}
// if we updated a moved/renamed file we can discard it from the list
if (moved) continue;
}
#endregion
#region Additional Multipart Files
DirectoryInfo currDir = currFile.File.Directory;
DBLocalMedia partnerMedia = null;
// check for folder multipart
if (Utility.isFolderMultipart(currDir.Name)) {
List<DBLocalMedia> possiblePartners = DBLocalMedia.GetAll(currDir.Parent.FullName + "%");
foreach (DBLocalMedia partner in possiblePartners) {
if (!partner.Ignored && Utility.isFolderMultipart(partner.File.Directory.Name) && currDir.FullName != partner.File.Directory.FullName)
{
partnerMedia = partner;
break;
}
}
}
// check for file multipart
if (partnerMedia == null && (alwaysGroup || Utility.isFileMultiPart(currFile.File))) {
List<DBLocalMedia> possiblePartners = DBLocalMedia.GetAll(currFile.File.DirectoryName + "%");
foreach (DBLocalMedia partner in possiblePartners) {
if (!partner.Ignored) {
if (alwaysGroup) {
partnerMedia = partner;
break;
}
if (AdvancedStringComparer.Levenshtein(currFile.File.Name, partner.File.Name) < 3) {
partnerMedia = partner;
break;
}
}
}
}
// associate this file with an existing partner
if (partnerMedia != null && partnerMedia.AttachedMovies.Count == 1) {
DBMovieInfo movie = partnerMedia.AttachedMovies[0];
movie.LocalMedia.Add(currFile);
// Sort on path and recommit part numbers for all related media
movie.LocalMedia.Sort(new DBLocalMediaPathComparer());
for (int i = 0; i < movie.LocalMedia.Count; i++) {
DBLocalMedia media = movie.LocalMedia[i];
media.Part = i + 1;
media.Commit();
}
// Commit movie, log and move to next file
movie.Commit();
logger.Info("File '{0}' was associated with existing movie '{1}' as an additional multi-part media (part {2}).", currFile.FullPath, movie.Title, currFile.Part);
continue;
}
#endregion
}
// if we have no previous files, move on so we can check if the next file
// is a pair to this one.
if (currFileSet.Count == 0) {
currFileSet.Add(currFile);
continue;
}
// check if the currFile is a part of the same movie as the previous
// file(s)
bool isAdditionalMatch = true;
bool isMultiPartFolderMatch = false;
foreach (DBLocalMedia otherFile in currFileSet) {
DirectoryInfo currentDir = currFile.File.Directory;
DirectoryInfo otherDir = otherFile.File.Directory;
// if both files are located in folders marked as multi-part folders
if (Utility.isFolderMultipart(currentDir.Name) && Utility.isFolderMultipart(otherDir.Name)) {
// check if they share the same parent folder, if not then they are not a pair
if (!currentDir.Parent.FullName.Equals(otherDir.Parent.FullName)) {
isAdditionalMatch = false;
break;
}
else {
isMultiPartFolderMatch = true;
}
}
else {
// if files are not in the same folder we assume they are not a pair
if (!currFile.File.DirectoryName.Equals(otherFile.File.DirectoryName)) {
isAdditionalMatch = false;
break;
}
}
// if the setting always group files in the same folder is used just group them
// without checking differences at all.
// @todo: maybe place this below the character differences count?
if (alwaysGroup)
break;
// if the filename differ by more than two characters
// assume they are not a pair
if (AdvancedStringComparer.Levenshtein(currFile.File.Name, otherFile.File.Name) > 2) {
isAdditionalMatch = false;
break;
}
// if the multi-part naming convention doesn't match up
// and we didnt match based on multipart folder names assume they are not a pair
if (!isMultiPartFolderMatch && !Utility.isFileMultiPart(currFile.File)) {
isAdditionalMatch = false;
break;
}
}
// if it's a match store it and move onto the next file to see if
// it is part of the set too
if (isAdditionalMatch) {
currFileSet.Add(currFile);
continue;
}
// if it's not a match, add the previous file set and then start a new one
// with the current file.
if (!isAdditionalMatch) {
MovieMatch newMatch = new MovieMatch();
newMatch.LocalMedia = currFileSet;
lock (pendingMatches.SyncRoot) {
pendingMatches.Add(newMatch);
}
allMatches.Add(newMatch);
foreach (DBLocalMedia subFile in currFileSet)
matchLookup.Add(subFile, newMatch);
if (MovieStatusChanged != null)
MovieStatusChanged(newMatch, MovieImporterAction.ADDED);
if (highPriority)
Reprocess(newMatch);
currFileSet = new List<DBLocalMedia>();
currFileSet.Add(currFile);
}
}
// queue up the last set of files
if (currFileSet.Count > 0) {
MovieMatch newMatch = new MovieMatch();
newMatch.LocalMedia = currFileSet;
lock (pendingMatches.SyncRoot) {
pendingMatches.Add(newMatch);
}
allMatches.Add(newMatch);
foreach (DBLocalMedia subFile in currFileSet)
matchLookup.Add(subFile, newMatch);
if (MovieStatusChanged != null)
MovieStatusChanged(newMatch, MovieImporterAction.ADDED);
if (highPriority)
Reprocess(newMatch);
}
}
private GUIListItem GetListItem(MovieMatch match)
{
// create or grab our list item
GUIListItem listItem = null;
if (listItemLookup.ContainsKey(match)) {
listItem = listItemLookup[match];
}
else {
listItem = new GUIListItem();
listItem.OnItemSelected += new GUIListItem.ItemSelectedHandler(ListItemSelected);
listItemLookup[match] = listItem;
}
// populate it with most recent info
listItem.Label = match.LocalMediaString;
listItem.Label2 = (match.Selected != null ? match.Selected.DisplayMember : "");
listItem.Label3 = match.LongLocalMediaString;
listItem.IsPlayed = match.LocalMedia.Count == 0 ? false : match.LocalMedia[0].Ignored;
listItem.AlbumInfoTag = match;
return listItem;
}
/// <summary>
/// Receives updates about specific items in the importer and updates the UI accordingly.
/// </summary>
private void MovieStatusChangedListener(MovieMatch match, MovieImporterAction action)
{
lock (statusChangedSyncToken) {
// if the importer fired up or shut down clear out our display
if (action == MovieImporterAction.STARTED || action == MovieImporterAction.STOPPED) {
allItems.Clear();
pendingItems.Clear();
completedItems.Clear();
listItemLookup.Clear();
allFilesListControl.ListItems.Clear();
pendingFilesListControl.ListItems.Clear();
completedFileListControl.ListItems.Clear();
return;
}
// our message is about a specific match
GUIListItem listItem = GetListItem(match);
AddToList(listItem, FilterMode.ALL);
switch (action) {
// file is queued but not yet processed have no icon
case MovieImporterAction.ADDED:
case MovieImporterAction.ADDED_FROM_SPLIT:
case MovieImporterAction.ADDED_FROM_JOIN:
listItem.PinImage = IdleIcon;
break;
// files that are currently being scanned are blue
case MovieImporterAction.PENDING:
case MovieImporterAction.GETTING_MATCHES:
case MovieImporterAction.APPROVED:
case MovieImporterAction.GETTING_DETAILS:
listItem.PinImage = ProcessingIcon;
break;
// files that need help from the user are yellow
case MovieImporterAction.NEED_INPUT:
listItem.PinImage = NeedInputIcon;
AddToList(listItem, FilterMode.PENDING);
break;
// files that have successfully imported are green
case MovieImporterAction.COMMITED:
listItem.PinImage = DoneIcon;
AddToList(listItem, FilterMode.COMPLETED);
RemoveFromList(listItem, FilterMode.PENDING);
break;
case MovieImporterAction.IGNORED:
listItem.PinImage = IgnoredIcon;
AddToList(listItem, FilterMode.PENDING);
RemoveFromList(listItem, FilterMode.COMPLETED);
break;
}
UpdateArtwork();
}
}
// Returns a possible match set for the given media file(s)
// using the given custom search string
private void GetMatches(MovieMatch mediaMatch)
{
List<DBMovieInfo> movieList;
List<PossibleMatch> rankedMovieList = new List<PossibleMatch>();
// notify any listeners we are checking for matches
if (MovieStatusChanged != null)
MovieStatusChanged(mediaMatch, MovieImporterAction.GETTING_MATCHES);
// Get the MovieSignature
MovieSignature signature = mediaMatch.Signature;
// grab a list of movies from our dataProvider and rank each returned movie on
// how close a match it is
if (mediaMatch.PreferedDataSource != null)
movieList = mediaMatch.PreferedDataSource.Provider.Get(signature);
else
movieList = MovingPicturesCore.DataProviderManager.Get(signature);
DBSourceInfo lastSource = null;
bool multipleSources = false;
foreach (DBMovieInfo currMovie in movieList) {
if (lastSource == null)
lastSource = currMovie.PrimarySource;
// check if our list of possible matches is from multiple sources
if (lastSource != currMovie.PrimarySource)
multipleSources = true;
// Create a Possible Match object
PossibleMatch currMatch = new PossibleMatch();
// Add the movie
currMatch.Movie = currMovie;
// Get the matching score for this movie
currMatch.Result = signature.GetMatchResult(currMovie);
// Add the match to the ranked movie list
rankedMovieList.Add(currMatch);
}
// if we have multiple sources, make sure we display info about where each possible
// match is coming from
if (multipleSources)
foreach (PossibleMatch currMatch in rankedMovieList)
currMatch.DisplaySourceInfo = true;
mediaMatch.PossibleMatches = rankedMovieList;
}
private bool DisplaySearchDialog(MovieMatch selectedFile)
{
GUIDialogMenu dialog = (GUIDialogMenu)GUIWindowManager.GetWindow((int)GUIWindow.Window.WINDOW_DIALOG_MENU);
if (dialog == null) {
logger.Error("Could not create search dialog.");
return false;
}
int maxid = 0;
dialog.Reset();
dialog.SetHeading(Translation.Search);
int titleId = ++maxid;
dialog.Add(string.Format("{0}: {1}", Translation.Title, selectedFile.Signature.Title));
int yearId = ++maxid;
dialog.Add(string.Format("{0}: {1}", Translation.Year, selectedFile.Signature.Year));
int imdbId = ++maxid;
dialog.Add(string.Format("{0}: {1}", Translation.ImdbId, selectedFile.Signature.ImdbId));
dialog.DoModal(GUIWindowManager.ActiveWindow);
// user picked nothing, go back to previous dialog
if (dialog.SelectedId == -1) {
return false;
}
// build and display our virtual keyboard
VirtualKeyboard keyboard = (VirtualKeyboard)GUIWindowManager.GetWindow((int)GUIWindow.Window.WINDOW_VIRTUAL_KEYBOARD);
keyboard.Reset();
keyboard.IsSearchKeyboard = true;
if (dialog.SelectedId == titleId) keyboard.Text = selectedFile.Signature.Title;
if (dialog.SelectedId == yearId) keyboard.Text = (selectedFile.Signature.Year == null) ? "" : selectedFile.Signature.Year.ToString();
if (dialog.SelectedId == imdbId) keyboard.Text = (selectedFile.Signature.ImdbId == null) ? "" : selectedFile.Signature.ImdbId;
keyboard.DoModal(GUIWindowManager.ActiveWindow);
// if the user escaped out redisplay the searchdialog
if (!keyboard.IsConfirmed) return DisplaySearchDialog(selectedFile);
// user entered something so update the movie signature
if (dialog.SelectedId == titleId) selectedFile.Signature.Title = keyboard.Text;
if (dialog.SelectedId == yearId) selectedFile.Signature.Year = Convert.ToInt32(keyboard.Text);
if (dialog.SelectedId == imdbId) selectedFile.Signature.ImdbId = keyboard.Text;
MovingPicturesCore.Importer.Reprocess(selectedFile);
return true;
}
// removes the given match from all pending process lists
private void RemoveFromMatchLists(MovieMatch match)
{
lock (pendingMatches.SyncRoot) {
if (pendingMatches.Contains(match))
pendingMatches.Remove(match);
}
lock (priorityPendingMatches.SyncRoot) {
if (priorityPendingMatches.Contains(match)) {
priorityPendingMatches.Remove(match);
}
}
lock (matchesNeedingInput.SyncRoot) {
if (matchesNeedingInput.Contains(match))
matchesNeedingInput.Remove(match);
}
lock (approvedMatches.SyncRoot) {
if (approvedMatches.Contains(match))
approvedMatches.Remove(match);
}
lock (priorityApprovedMatches.SyncRoot) {
if (priorityApprovedMatches.Contains(match))
priorityApprovedMatches.Remove(match);
}
lock (commitedMatches.SyncRoot) {
if (commitedMatches.Contains(match)) {
commitedMatches.Remove(match);
}
}
lock (retrievingDetailsMatches.SyncRoot) {
if (retrievingDetailsMatches.Contains(match)) {
retrievingDetailsMatches.Remove(match);
}
}
foreach (DBLocalMedia currFile in match.LocalMedia) {
if (matchLookup.ContainsKey(currFile)) {
matchLookup.Remove(currFile);
allMatches.Remove(match);
}
}
}
// Approves the MovieMatch for detail processing and commit. THis shold be
// used in conjunction with the MatchListChanged event when a NEED_INPUT action
// is received.
public void Approve(MovieMatch match)
{
if (match.Selected == null)
return;
RemoveFromMatchLists(match);
// clear the ignored flag in case these files were previously on the disable list
foreach (DBLocalMedia currFile in match.LocalMedia) {
currFile.Ignored = false;
}
// select the list to add this match to based on priority
ArrayList approveList;
if (match.HighPriority) approveList = priorityApprovedMatches;
else approveList = approvedMatches;
lock (approveList.SyncRoot) {
approveList.Insert(0, match);
allMatches.Add(match);
foreach (DBLocalMedia currFile in match.LocalMedia)
matchLookup[currFile] = match;
}
// notify any listeners of the status change
logger.Info("User approved " + match.LocalMediaString + " as " + match.Selected.Movie.Title);
if (MovieStatusChanged != null)
MovieStatusChanged(match, MovieImporterAction.APPROVED);
}
// rescans for possible movie matches using the specified search string
public void Reprocess(MovieMatch match)
{
RemoveFromMatchLists(match);
if (match.ExistingMovieInfo == null)
RemoveCommitedRelations(match.LocalMedia);
// clear the ignored flag in case these files were previously on the disable list
foreach (DBLocalMedia currFile in match.LocalMedia) {
currFile.Ignored = false;
}
match.PossibleMatches.Clear();
lock (priorityPendingMatches) {
match.HighPriority = true;
priorityPendingMatches.Add(match);
allMatches.Add(match);
foreach (DBLocalMedia currFile in match.LocalMedia)
matchLookup[currFile] = match;
}
// notify any listeners of the status change
logger.Info("User reprocessing " + match.LocalMediaString);
if (MovieStatusChanged != null)
MovieStatusChanged(match, MovieImporterAction.PENDING);
}
// takes the given match containing multiple files and splits it up into
// individual matches for each file
public void Split(MovieMatch match)
{
if (match == null || match.LocalMedia.Count < 2)
return;
RemoveFromMatchLists(match);
RemoveCommitedRelations(match.LocalMedia);
match.Deleted = true;
// notify any listeners of the status change
logger.Info("User split pair " + match.LocalMediaString);
if (MovieStatusChanged != null)
MovieStatusChanged(match, MovieImporterAction.REMOVED_FROM_SPLIT);
foreach (DBLocalMedia currFile in match.LocalMedia) {
// clear the ignored flag in case these files were previously on the disable list
currFile.Ignored = false;
MovieMatch newMatch = new MovieMatch();
newMatch.LocalMedia.Add(currFile);
lock (priorityPendingMatches.SyncRoot) {
newMatch.HighPriority = true;
priorityPendingMatches.Insert(0, newMatch);
}
if (MovieStatusChanged != null)
MovieStatusChanged(newMatch, MovieImporterAction.ADDED_FROM_SPLIT);
}
}
public void ManualAssign(MovieMatch match)
{
if (match.Selected == null)
return;
// remove match from all lists
RemoveFromMatchLists(match);
// clear the ignored flag in case these files were previously on the disable list
foreach (DBLocalMedia currFile in match.LocalMedia) {
currFile.Ignored = false;
}
// assign files to movie
AssignAndCommit(match, false);
// add match to the committed list
commitedMatches.Add(match);
// grab mediainfo
UpdateMediaInfo(match);
// notify any listeners of the status change
logger.Info("User manually assigned " + match.LocalMediaString + "as " + match.Selected.Movie.Title);
if (MovieStatusChanged != null)
MovieStatusChanged(match, MovieImporterAction.MANUAL);
}
// given multiple matches, a new match is created that is the sum of the previous
// parts. In practice this means that two parts of the same movie were joined together
// to be treated as one.
public void Join(List<MovieMatch> matchList)
{
if (matchList == null || matchList.Count < 2)
return;
List<DBLocalMedia> fileList = new List<DBLocalMedia>();
// build the file list and clear out old matches
foreach (MovieMatch currMatch in matchList) {
RemoveFromMatchLists(currMatch);
RemoveCommitedRelations(currMatch.LocalMedia);
currMatch.Deleted = true;
fileList.AddRange(currMatch.LocalMedia);
// notify any listeners of the status change
if (MovieStatusChanged != null)
MovieStatusChanged(currMatch, MovieImporterAction.REMOVED_FROM_JOIN);
}
// build the new match and add it for processing
MovieMatch newMatch = new MovieMatch();
newMatch.LocalMedia = fileList;
newMatch.LocalMedia.Sort(new DBLocalMediaComparer());
lock (priorityPendingMatches.SyncRoot) {
newMatch.HighPriority = true;
priorityPendingMatches.Insert(0, newMatch);
}
// notify any listeners of the status change
logger.Info("User joined " + newMatch.LocalMediaString);
if (MovieStatusChanged != null)
MovieStatusChanged(newMatch, MovieImporterAction.ADDED_FROM_JOIN);
}
// removes any association with the file(s) in the MovieMatch and flags the files
// to be ignored in the future.
public void Ignore(MovieMatch match)
{
RemoveFromMatchLists(match);
RemoveCommitedRelations(match.LocalMedia);
foreach (DBLocalMedia currFile in match.LocalMedia) {
currFile.Ignored = true;
currFile.Commit();
}
// add match to the committed list
commitedMatches.Add(match);
// notify any listeners of the status change
logger.Info("User ignored " + match.LocalMediaString);
if (MovieStatusChanged != null)
MovieStatusChanged(match, MovieImporterAction.IGNORED);
}
private void movieStatusChangedListener(MovieMatch obj, MovieImporterAction action)
{
// This ensures we are thread safe. Makes sure this method is run by
// the thread that created this panel.
if (InvokeRequired) {
Delegate method = new MovieImporter.MovieStatusChangedHandler(movieStatusChangedListener);
object[] parameters = new object[] { obj, action };
this.Invoke(method, parameters);
return;
}
if (action == MovieImporterAction.STARTED)
return;
if (action == MovieImporterAction.STOPPED) {
unapprovedMatchesBindingSource.Clear();
return;
}
if (action == MovieImporterAction.REMOVED_FROM_SPLIT ||
action == MovieImporterAction.REMOVED_FROM_JOIN) {
lastSplitJoinLocation = unapprovedMatchesBindingSource.IndexOf(obj);
unapprovedMatchesBindingSource.Remove(obj);
clearSelection = true;
return;
}
// add the match if necessary and grab the row number
int rowNum;
if (action == MovieImporterAction.ADDED)
rowNum = unapprovedMatchesBindingSource.Add(obj);
else if (action == MovieImporterAction.ADDED_FROM_SPLIT ||
action == MovieImporterAction.ADDED_FROM_JOIN) {
unapprovedMatchesBindingSource.Insert(lastSplitJoinLocation, obj);
if (clearSelection) {
unapprovedGrid.ClearSelection();
clearSelection = false;
}
unapprovedGrid.Rows[lastSplitJoinLocation].Selected = true;
rowNum = lastSplitJoinLocation;
lastSplitJoinLocation++;
} else
rowNum = unapprovedMatchesBindingSource.IndexOf(obj);
// setup tooltip for filename
DataGridViewTextBoxCell filenameCell = (DataGridViewTextBoxCell)unapprovedGrid.Rows[rowNum].Cells["unapprovedLocalMediaColumn"];
filenameCell.ToolTipText = obj.LongLocalMediaString;
// setup the combo box of possible matches
DataGridViewComboBoxCell movieListCombo = (DataGridViewComboBoxCell)unapprovedGrid.Rows[rowNum].Cells["unapprovedPossibleMatchesColumn"];
movieListCombo.Items.Clear();
foreach (PossibleMatch currMatch in obj.PossibleMatches)
movieListCombo.Items.Add(currMatch);
// set the status icon
DataGridViewImageCell imageCell = (DataGridViewImageCell)unapprovedGrid.Rows[rowNum].Cells["statusColumn"];
switch (action) {
case MovieImporterAction.ADDED:
case MovieImporterAction.ADDED_FROM_SPLIT:
case MovieImporterAction.ADDED_FROM_JOIN:
imageCell.Value = blank;
break;
case MovieImporterAction.PENDING:
imageCell.Value = Resources.arrow_rotate_clockwise;
break;
case MovieImporterAction.GETTING_MATCHES:
imageCell.Value = Resources.arrow_down1;
break;
case MovieImporterAction.NEED_INPUT:
imageCell.Value = Resources.information;
break;
case MovieImporterAction.APPROVED:
imageCell.Value = Resources.approved;
break;
case MovieImporterAction.GETTING_DETAILS:
imageCell.Value = Resources.approved;
break;
case MovieImporterAction.COMMITED:
imageCell.Value = Resources.accept;
break;
case MovieImporterAction.IGNORED:
imageCell.Value = Resources.ignored;
break;
case MovieImporterAction.MANUAL:
imageCell.Value = Resources.accept; // @TODO change icon
break;
}
updateButtons();
}
private void AssignAndCommit(MovieMatch match, bool update)
{
lock (match) {
// if we already have a movie object with assigned files, just update
if (match.ExistingMovieInfo != null && update) {
DBMovieInfo movie = match.ExistingMovieInfo;
// Using IMovieProvider
string siteID = match.Selected.Movie.GetSourceMovieInfo(match.PreferedDataSource).Identifier;
movie.GetSourceMovieInfo(match.PreferedDataSource).Identifier = siteID;
// and update from that
match.PreferedDataSource.Provider.Update(movie);
movie.Commit();
}
// no movie object exists so go ahead and assign our retrieved details.
else {
AssignFileToMovie(match.LocalMedia, match.Selected.Movie, update);
}
}
}
// This will add the specified movie to the importer for reprocessing, using the
// specified data source.
public void Update(DBMovieInfo movie, DBSourceInfo source)
{
MovieMatch newMatch = new MovieMatch();
newMatch.ExistingMovieInfo = movie;
newMatch.PreferedDataSource = source;
newMatch.LocalMedia = movie.LocalMedia;
if (matchLookup.ContainsKey(movie.LocalMedia[0]))
RemoveFromMatchLists(matchLookup[movie.LocalMedia[0]]);
lock (priorityPendingMatches.SyncRoot) {
priorityPendingMatches.Add(newMatch);
}
allMatches.Add(newMatch);
foreach (DBLocalMedia subFile in movie.LocalMedia)
matchLookup.Add(subFile, newMatch);
if (MovieStatusChanged != null)
MovieStatusChanged(newMatch, MovieImporterAction.ADDED);
}
private void UpdateMediaInfo(MovieMatch match)
{
foreach (DBLocalMedia currFile in match.LocalMedia) {
currFile.UpdateMediaInfo();
currFile.Commit();
}
}
