/// ------------------------------------------------------------------------------------
/// <summary>
/// Forces a save of lexicon
/// </summary>
/// ------------------------------------------------------------------------------------
public void Save()
{
LexicalProviderManager.ResetLexicalProviderTimer();
// ENHANCE: We could do a save on the cache here. It doesn't seem really important
// since the cache will be saved automatically with 10 seconds of inactivity anyways.
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Displays the related words to the specified entry using the application with the
/// lexical data.
/// </summary>
/// ------------------------------------------------------------------------------------
public void ShowRelatedWords(string entry, EntryType entryType)
{
LexicalProviderManager.ResetLexicalProviderTimer();
Logger.WriteEvent("Showing related word from external application for the " + entryType + " " + entry);
if (entryType != EntryType.Word)
{
throw new ArgumentException("Unknown entry type specified.");
}
// An asynchronous call is necessary because the WCF server (FieldWorks) will not
// respond until this method returns. This also allows methods that show dialogs on the
// WCF server to not be OneWay. (Otherwise, time-out exceptions occur.)
FieldWorks.ThreadHelper.InvokeAsync(() =>
{
ITsString tss = TsStringUtils.MakeTss(entry, FieldWorks.Cache.DefaultVernWs);
Mediator mediator = new Mediator();
mediator.HelpTopicProvider = FieldWorks.GetHelpTopicProvider(FwUtils.ksFlexAbbrev);
mediator.FeedbackInfoProvider = FieldWorks.GetOrCreateFlexApp();
mediator.PropertyTable.SetProperty("App", FieldWorks.GetOrCreateFlexApp());
LexEntryUi.DisplayRelatedEntries(FieldWorks.Cache, mediator, mediator.HelpTopicProvider,
"UserHelpFile", tss);
});
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Adds the lexeme to the lexicon.
/// </summary>
/// <exception cref="ArgumentException">if matching lexeme is already in lexicon</exception>
/// ------------------------------------------------------------------------------------
public void AddLexeme(LexicalEntry lexeme)
{
LexicalProviderManager.ResetLexicalProviderTimer();
Logger.WriteEvent("Adding new lexeme from an external application: " + lexeme.LexicalForm);
NonUndoableUnitOfWorkHelper.Do(m_cache.ActionHandlerAccessor, () =>
{
string sForm = lexeme.LexicalForm;
switch (lexeme.Type)
{
case LexemeType.Word:
ITsString tss = TsStringUtils.MakeTss(lexeme.LexicalForm, m_cache.DefaultVernWs);
m_cache.ServiceLocator.GetInstance <IWfiWordformFactory>().Create(tss);
break;
default:
{
SandboxGenericMSA msa = new SandboxGenericMSA();
msa.MsaType = (lexeme.Type == LexemeType.Stem) ? MsaType.kStem : MsaType.kUnclassified;
IMoMorphType morphType = GetMorphTypeForLexemeType(lexeme.Type);
ITsString tssForm = TsStringUtils.MakeTss(sForm, m_cache.DefaultVernWs);
m_cache.ServiceLocator.GetInstance <ILexEntryFactory>().Create(morphType, tssForm, null, msa);
break;
}
}
});
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Displays the specified entry using the application with the lexical data.
/// </summary>
/// ------------------------------------------------------------------------------------
public void ShowEntry(string entry, EntryType entryType)
{
LexicalProviderManager.ResetLexicalProviderTimer();
Logger.WriteEvent("Showing entry from external application for the " + entryType + " " + entry);
if (entryType != EntryType.Word)
{
throw new ArgumentException("Unknown entry type specified.");
}
// An asynchronous call is necessary because the WCF server (FieldWorks) will not
// respond until this method returns. This also allows methods that show dialogs on the
// WCF server to not be OneWay. (Otherwise, time-out exceptions occur.)
FieldWorks.ThreadHelper.InvokeAsync(() =>
{
ITsString tss = TsStringUtils.MakeString(entry, FieldWorks.Cache.DefaultVernWs);
using (Mediator mediator = new Mediator())
using (PropertyTable propertyTable = new PropertyTable(mediator))
{
propertyTable.SetProperty("HelpTopicProvider", FieldWorks.GetHelpTopicProvider(), true);
propertyTable.SetPropertyPersistence("HelpTopicProvider", false);
var flexApp = FieldWorks.GetOrCreateFlexApp();
propertyTable.SetProperty("FeedbackInfoProvider", flexApp, true);
propertyTable.SetPropertyPersistence("FeedbackInfoProvider", false);
propertyTable.SetProperty("App", flexApp, true);
LexEntryUi.DisplayEntry(FieldWorks.Cache, mediator, propertyTable, propertyTable.GetValue <IHelpTopicProvider>("HelpTopicProvider"),
"UserHelpFile", tss, null);
}
});
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// This must be called before entries are changed to ensure that
/// it is saved to disk. Since the lexicon is a complex structure
/// and other features depend on knowing when it is changed,
/// all work done with the lexicon is marked with a begin and
/// end change.
/// </summary>
/// ------------------------------------------------------------------------------------
public void BeginChange()
{
LexicalProviderManager.ResetLexicalProviderTimer();
// Ideally, we would like to be able to begin an undo task here and then end it in
// EndChange(). However, because there is no guarantee that EndChange() will ever
// get called (and to keep the data in a consistant state), we need to wrap
// each individual change in it's own undo task.
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Gets the version of the specified provider that the server supports. If the
/// providerType is not supported, return 0 for the version.
/// </summary>
/// ------------------------------------------------------------------------------------
public int GetSupportedVersion(string providerType)
{
LexicalProviderManager.ResetLexicalProviderTimer();
if (providerType == kLexicalProviderType)
{
return(kSupportedLexicalProviderVersion);
}
return(0);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Adds a new sense to the lexeme with the specified information
/// </summary>
/// ------------------------------------------------------------------------------------
public LexSense AddSenseToEntry(LexemeType type, string lexicalForm, int homograph)
{
LexicalProviderManager.ResetLexicalProviderTimer();
Logger.WriteEvent("Adding new sense to lexeme '" + lexicalForm + "' from an external application");
return(NonUndoableUnitOfWorkHelper.Do(m_cache.ActionHandlerAccessor, () =>
{
string guid = string.Empty;
switch (type)
{
case LexemeType.Word:
{
IWfiWordform dbWordform = GetDbWordform(lexicalForm);
if (dbWordform == null)
{
throw new ArgumentException("Entry in the lexicon not found for the specified information");
}
// For wordforms, our "senses" could be new meanings of an analysis for the word
// or it could be a brand new analysis. Because we have no idea what the user actually
// wanted, we just assume the worst (they want to create a new analysis for the word
// with a new meaning).
IWfiAnalysis dbAnalysis = m_cache.ServiceLocator.GetInstance <IWfiAnalysisFactory>().Create();
dbWordform.AnalysesOC.Add(dbAnalysis);
guid = kAnalysisPrefix + dbAnalysis.Guid;
break;
}
default:
{
ILexEntry dbEntry = GetDbLexeme(type, lexicalForm, homograph);
if (dbEntry == null)
{
throw new ArgumentException("Entry in the lexicon not found for the specified information");
}
if (dbEntry.SensesOS.Count == 1 && dbEntry.SensesOS[0].Gloss.StringCount == 0)
{
// An empty sense exists (probably was created during a call to AddLexeme)
guid = dbEntry.SensesOS[0].Guid.ToString();
break;
}
ILexSense newSense = m_cache.ServiceLocator.GetInstance <ILexSenseFactory>().Create(
dbEntry, new SandboxGenericMSA(), null);
guid = newSense.Guid.ToString();
break;
}
}
return new LexSense(guid);
}));
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Gets the location for the provider for the specified project and provider type.
/// If the providerType is not supported, return null for the Uri.
/// </summary>
/// ------------------------------------------------------------------------------------
public Uri GetProviderLocation(string projhandle, string providerType)
{
LexicalProviderManager.ResetLexicalProviderTimer();
if (providerType == kLexicalProviderType)
{
Uri projUri = new Uri("net.pipe://localhost/" + FwUtils.GeneratePipeHandle(projhandle) + ":LP");
LexicalProviderManager.StartProvider(projUri, new LexicalProviderImpl(m_cache), typeof(ILexicalProvider));
return(projUri);
}
return(null);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Gets the location for the provider for the specified project and provider type.
/// If the providerType is not supported, return null for the Uri.
/// </summary>
/// ------------------------------------------------------------------------------------
public Uri GetProviderLocation(string projhandle, string providerType)
{
LexicalProviderManager.ResetLexicalProviderTimer();
if (providerType == kLexicalProviderType)
{
var url = LexicalProviderManager.UrlPrefix + LexicalProviderManager.FixPipeHandle(FwUtils.GeneratePipeHandle(projhandle + ":LP"));
Uri projUri = new Uri(url);
LexicalProviderManager.StartProvider(projUri, new LexicalProviderImpl(m_cache), typeof(ILexicalProvider));
return(projUri);
}
return(null);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Looks up an lexeme
/// </summary>
/// ------------------------------------------------------------------------------------
public LexicalEntry GetLexeme(LexemeType type, string lexicalForm, int homograph)
{
LexicalProviderManager.ResetLexicalProviderTimer();
switch (type)
{
case LexemeType.Word:
IWfiWordform wf = GetDbWordform(lexicalForm);
return((wf != null) ? CreateEntryFromDbWordform(wf) : null);
default:
ILexEntry dbEntry = GetDbLexeme(type, lexicalForm, homograph);
return((dbEntry != null) ? CreateEntryFromDbEntry(type, dbEntry) : null);
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Adds a new gloss to the sense with the specified information
/// </summary>
/// ------------------------------------------------------------------------------------
public LexGloss AddGlossToSense(LexemeType type, string lexicalForm, int homograph,
string senseId, string language, string text)
{
LexicalProviderManager.ResetLexicalProviderTimer();
Logger.WriteEvent("Adding new gloss to lexeme '" + lexicalForm + "' from an external application");
return(NonUndoableUnitOfWorkHelper.Do(m_cache.ActionHandlerAccessor, () =>
{
IMultiUnicode dbGlosses;
if (senseId.StartsWith(kAnalysisPrefix))
{
// The "sense" is actually an analysis for a wordform and our new
// gloss is a new meaning for that analysis.
Guid analysisGuid = new Guid(senseId.Substring(kAnalysisPrefix.Length));
IWfiAnalysis dbAnalysis = m_cache.ServiceLocator.GetInstance <IWfiAnalysisRepository>().GetObject(analysisGuid);
IWfiGloss dbGloss = dbAnalysis.MeaningsOC.FirstOrDefault();
if (dbGloss == null)
{
dbGloss = m_cache.ServiceLocator.GetInstance <IWfiGlossFactory>().Create();
dbAnalysis.MeaningsOC.Add(dbGloss);
}
dbGlosses = dbGloss.Form;
dbAnalysis.ApprovalStatusIcon = 1; // Assume the analysis from the external application is user approved
}
else
{
Guid senseGuid = new Guid(senseId);
ILexSense dbSense = m_cache.ServiceLocator.GetInstance <ILexSenseRepository>().GetObject(senseGuid);
dbGlosses = dbSense.Gloss;
}
// Add the new gloss to the list of glosses for the sense
ILgWritingSystem writingSystem = m_cache.WritingSystemFactory.get_Engine(language);
dbGlosses.set_String(writingSystem.Handle, TsStringUtils.MakeTss(text, writingSystem.Handle));
return new LexGloss(language, text);
}));
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Removes the gloss with the specified language form the sense with the specified information
/// </summary>
/// ------------------------------------------------------------------------------------
public void RemoveGloss(LexemeType type, string lexicalForm, int homograph,
string senseId, string language)
{
LexicalProviderManager.ResetLexicalProviderTimer();
Logger.WriteEvent("Removing gloss from lexeme '" + lexicalForm + "' from an external application");
NonUndoableUnitOfWorkHelper.Do(m_cache.ActionHandlerAccessor, () =>
{
IMultiUnicode dbGlosses;
Guid guid;
if (senseId.StartsWith(kAnalysisPrefix))
{
// The "sense" is actually an analysis for a wordform and the gloss
// we want to delete is a meaning for that analysis.
guid = new Guid(senseId.Substring(kAnalysisPrefix.Length));
IWfiAnalysis dbAnalysis = m_cache.ServiceLocator.GetInstance <IWfiAnalysisRepository>().GetObject(guid);
IWfiGloss dbGloss = dbAnalysis.MeaningsOC.First();
dbGlosses = dbGloss.Form;
}
else
{
guid = new Guid(senseId);
ILexSense dbSense = m_cache.ServiceLocator.GetInstance <ILexSenseRepository>().GetObject(guid);
dbGlosses = dbSense.Gloss;
}
// Remove the gloss from the list of glosses for the sense
int wsId = m_cache.WritingSystemFactory.GetWsFromStr(language);
dbGlosses.set_String(wsId, (ITsString)null);
// Delete the sense if there are no more glosses for it
if (dbGlosses.StringCount == 0)
{
RemoveSense(senseId, guid);
}
});
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Gets all lexemes in the Lexicon
/// </summary>
/// ------------------------------------------------------------------------------------
public IEnumerable <LexicalEntry> Lexemes()
{
LexicalProviderManager.ResetLexicalProviderTimer();
List <LexicalEntry> entries = new List <LexicalEntry>();
// Get all of the lexical entries in the database
foreach (ILexEntry dbEntry in m_cache.ServiceLocator.GetInstance <ILexEntryRepository>().AllInstances())
{
IMoMorphType morphType = dbEntry.PrimaryMorphType;
if (morphType != null)
{
entries.Add(CreateEntryFromDbEntry(GetLexemeTypeForMorphType(morphType), dbEntry));
}
}
// Get all the wordforms in the database
foreach (IWfiWordform wordform in m_cache.ServiceLocator.GetInstance <IWfiWordformRepository>().AllInstances())
{
entries.Add(CreateEntryFromDbWordform(wordform));
}
return(entries);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// This must be called after entries are changed to ensure that
/// other features dependent on the lexicon are made aware of the
/// change.
/// </summary>
/// ------------------------------------------------------------------------------------
public void EndChange()
{
LexicalProviderManager.ResetLexicalProviderTimer();
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Unlike a normal ping method that gets a response, we just use this ping method
/// to determine if the service provider is actually valid since no exception is
/// thrown until a method is called.
/// </summary>
/// ------------------------------------------------------------------------------------
public void Ping()
{
// Nothing to do for this method except reset our timer for the life of the LexicalProvider.
// See comment for this method.
LexicalProviderManager.ResetLexicalProviderTimer();
}
