/// ------------------------------------------------------------------------------------
private static bool TryToFindAudioFile(WordCacheEntry entry, string audioFilePath,
string rootPath)
{
if (string.IsNullOrEmpty(rootPath) || string.IsNullOrEmpty(audioFilePath))
{
return(false);
}
// First, combine the audioFilePath and the specified rootPath.
string newPath = Path.Combine(rootPath, audioFilePath);
var s = newPath.Normalize(NormalizationForm.FormC);
if (File.Exists(s))
{
entry.AbsoluteAudioFilePath = s;
return(true);
}
// Now try removing just the filename from audioFilePath and
// combining that with the specified root path.
newPath = Path.GetFileName(audioFilePath);
newPath = Path.Combine(rootPath, newPath);
if (File.Exists(newPath))
{
entry.AbsoluteAudioFilePath = newPath;
return(true);
}
return(false);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// This method will determine if the specified audio file path is relative or
/// absolute. If it's relative, then it is combined with several different absolute
/// paths in an attempt to find the audio file.
/// </summary>
/// ------------------------------------------------------------------------------------
private static string AttemptToFindMissingAudioFile(WordCacheEntry entry, string audioFilePath)
{
// In case the path is rooted with just a backslash (as opposed to a drive letter),
// strip off the backslash before trying to find the audio file by combining the
// result with various other rooted paths. I do this because combining a rooted
// path (using Path.Combine) with any other path just returns the rooted path so
// we're no better off than we were before the combine method was called.
if (Path.IsPathRooted(audioFilePath))
{
audioFilePath = audioFilePath.TrimStart('\\');
}
entry.AbsoluteAudioFilePath = null;
if (entry.RecordEntry.DataSource.FwSourceDirectFromDB &&
TryToFindAudioFile(entry, audioFilePath, FwDBUtils.FwRootDataDir))
{
return(entry.AbsoluteAudioFilePath);
}
// Check a path relative to the data source file's path.
if (TryToFindAudioFile(entry, audioFilePath, entry[PaField.kDataSourcePathFieldName]))
{
return(entry.AbsoluteAudioFilePath);
}
if (entry.RecordEntry.DataSource.Type == DataSourceType.FW7 &&
TryToFindAudioFile(entry, audioFilePath, Path.Combine(entry[PaField.kDataSourcePathFieldName], "LinkedFiles\\AudioVisual")))
{
return(entry.AbsoluteAudioFilePath);
}
// Check a path relative to the project file's path
if (TryToFindAudioFile(entry, audioFilePath, entry.Project.Folder))
{
return(entry.AbsoluteAudioFilePath);
}
// Check an 'Audio' path relative to the project file's path
if (TryToFindAudioFile(entry, audioFilePath, Path.Combine(entry.Project.Folder, "Audio")))
{
return(entry.AbsoluteAudioFilePath);
}
// Check a path relative to the application's startup path
if (TryToFindAudioFile(entry, audioFilePath, Application.StartupPath))
{
return(entry.AbsoluteAudioFilePath);
}
// Now try the alternate path location the user may have specified in
// the project's undocumented alternate audio file location field.
return(TryToFindAudioFile(entry, audioFilePath, entry.Project.AlternateAudioFileFolder) ?
entry.AbsoluteAudioFilePath : null);
}
/// ------------------------------------------------------------------------------------
/// <summary>
///
/// \tx nimeolewa.
/// \mb ni- me - oa -le -wa
/// \ge 1S- PF - marry -DER -PASS
/// \ps pro- tns- v -sfx -sfx
///
/// </summary>
/// ------------------------------------------------------------------------------------
private static void ParseEntryAsInterlinear(RecordCacheEntry entry)
{
string firstInterlinearLine = entry[entry.FirstInterlinearField];
if (string.IsNullOrEmpty(firstInterlinearLine))
{
return;
}
// Get the width of each interlinear column.
var colWidths = GetInterlinearColumnWidths(firstInterlinearLine);
// Store the unparsed interlinear lines in a collection of strings, then remove
// those lines from the record cache entry so they no longer take up space.
var unparsedLines = entry.InterlinearFields.ToDictionary(f => f, f => entry[f]);
foreach (var field in entry.InterlinearFields)
{
entry.SetValue(field, null);
}
// Now parse each interlinear line.
int startIndex = 0;
int wordIndex = 0;
foreach (int width in colWidths)
{
var wordEntry = new WordCacheEntry(entry, wordIndex++);
foreach (var line in unparsedLines.Where(l => l.Value != null && startIndex < l.Value.Length))
{
wordEntry[line.Key] = (startIndex + width > line.Value.Length ?
line.Value.Substring(startIndex) : line.Value.Substring(startIndex, width)).Trim();
if (line.Key == entry.FirstInterlinearField)
{
wordEntry.SetFieldAsFirstLineInterlinear(line.Key);
}
else
{
wordEntry.SetFieldAsSubordinateInterlinear(line.Key);
}
}
entry.WordEntries.Add(wordEntry);
startIndex += width;
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Uses the offset and length to build three groups of strings, the phones in the
/// environment before, the phones in the environment after and the phones in the
/// search item.
/// </summary>
/// <param name="entry">The underlying word cache entry from which we're building
/// a WordListCacheEntry.</param>
/// <param name="phones">Array of phones that make up the phonetic word. When
/// this is null or empty, then it's assumed the WordListCacheEntry is not for a
/// search result item.</param>
/// <param name="offset">Offset in the phones array where a search item was found.
/// </param>
/// <param name="length">Length in phones of the matched search item.</param>
/// <param name="savePhonesArray">When true, it forces the phones passed in the phones
/// parameter to be saved in the new WordListCacheEntry rather than the
/// new WordListCacheEntry deferring to the phones from its associated WordCacheEntry
/// (which is passed in the entry parameter).</param>
/// ------------------------------------------------------------------------------------
public void Add(WordCacheEntry entry, string[] phones, int offset, int length,
bool savePhonesArray)
{
var newEntry = new WordListCacheEntry();
newEntry.WordCacheEntry = entry;
Add(newEntry);
// When the array of phones is non-existent, it means
// we're not adding an entry for a search result cache.
if (phones == null || phones.Length == 0)
{
return;
}
// Do some preprocessing for spaces before and after.
ProcessSpaces(ref phones, ref offset, ref length);
IsForSearchResults = true;
newEntry.SearchItemOffset = offset;
newEntry.SearchItemLength = length;
if (savePhonesArray)
{
newEntry.SetPhones(phones);
}
// Build the environment before string.
if (offset > 0)
{
newEntry.EnvironmentBefore = string.Join(string.Empty, phones, 0, offset);
}
// Build the environment after string.
if (offset < phones.Length - 1)
{
int afterStart = offset + length;
newEntry.EnvironmentAfter = string.Join(string.Empty, phones,
afterStart, phones.Length - afterStart);
}
// Build the search item string.
newEntry.SearchItem = (length == 0 ? string.Empty :
string.Join(string.Empty, phones, offset, length));
}
/// ------------------------------------------------------------------------------------
public void Add(WordCacheEntry entry)
{
Add(entry, null, 0, 0, false);
}
