private void WordNetBrowser_WordSenseDragStarted(WordSense wordSense)
{
if (WordSensesControl.WordSenseNavigator.EditingIsEnabled)
{
WordSensesControl.WordSenseNavigator.ViewModel.Edit.SetDropTargets_ForWordSense(wordSense);
}
}
private void CurrentSynsetGlossBorder_Drop(object sender, DragEventArgs e)
{
if (e.Data.GetDataPresent(typeof(WordSense)))
{
WordSense droppedWordSense = (WordSense)e.Data.GetData(typeof(WordSense));
ViewModel.SetCurrentSynset(droppedWordSense.LinkedSynset);
}
}
internal void SetDropTargets_ForWordSense(WordSense draggedWordSense)
{
if (CurrentWordSenseSource.CurrentWordSense != null)
{
GetNewWordSenseRelationConstraintsResult addRelationConstraints = WordNetData.Context.GetNewWordSenseRelationConstraints(CurrentWordSenseSource.CurrentWordSense.SynsetID, CurrentWordSenseSource.CurrentWordSense.WordNumber, draggedWordSense.SynsetID, draggedWordSense.WordNumber).Single();
Antonyms.DropIsEnabled = (bool)addRelationConstraints.CanAddAntonym;
Derivations.DropIsEnabled = (bool)addRelationConstraints.CanAddDerivation;
SeeAlso.DropIsEnabled = (bool)addRelationConstraints.CanAddSeeAlso;
Pertainers.DropIsEnabled = (bool)addRelationConstraints.CanAddPertainer;
ParticipleForms.DropIsEnabled = (bool)addRelationConstraints.CanAddParticipleForm;
PertainsTo.DropIsEnabled = (bool)addRelationConstraints.CanAddPertainedTo;
BaseVerbFormsOfParticiple.DropIsEnabled = (bool)addRelationConstraints.CanAddBaseFormOfParticiple;
DerivedAdverbs.DropIsEnabled = (bool)addRelationConstraints.CanAddDerivedAdverb;
AdjectiveBasesOfDerivedAdverb.DropIsEnabled = (bool)addRelationConstraints.CanAddAdjectiveBaseOfDerivedAdverb;
}
}
internal void SetCurrentSynset(Synset newCurrentSynset)
{
if (newCurrentSynset != WordSensesForSynsetList.DataContext)
{
WordSensesForSynsetList.DataContext = newCurrentSynset;
// If the new current synset has only one associated word sense, go ahead and select that word sense and make it current.
// If there are multiple associated word senses, the user has to choose one in order to make it the focus of this control.
if (newCurrentSynset.WordSensesForSynset.Count() == 1)
{
WordSense theOnlyWordSenseForThisSynset = newCurrentSynset.WordSensesForSynset.Single();
WordSensesForSynsetList.SelectedItem = theOnlyWordSenseForThisSynset;
WordSenseNavigator.ViewModel.CurrentWordSense = theOnlyWordSenseForThisSynset;
WordSenseNavigator.Visibility = Visibility.Visible;
}
else
{
WordSensesForSynsetList.SelectedItem = null;
WordSenseNavigator.ViewModel.CurrentWordSense = null;
WordSenseNavigator.Visibility = Visibility.Hidden;
}
}
}
internal void DeleteAdjectiveBaseOfDerivedAdverb(WordSense existingAdjectiveBase)
{
CurrentWordSenseSource.CurrentWordSense.DeleteAdjectiveBaseOfDerivedAdverb(existingAdjectiveBase);
}
internal void DeleteSeeAlso(WordSense existingSeeAlso)
{
CurrentWordSenseSource.CurrentWordSense.DeleteSeeAlso(existingSeeAlso);
}
internal void DeleteDerivation(WordSense existingDerivation)
{
CurrentWordSenseSource.CurrentWordSense.DeleteDerivation(existingDerivation);
}
internal void DeleteAntonym(WordSense existingAntonym)
{
CurrentWordSenseSource.CurrentWordSense.DeleteAntonym(existingAntonym);
}
private void OnWordSenseDropCompleted(WordSense wordSense) => WordSenseDropCompleted?.Invoke(wordSense);
private void OnWordSenseDragCancelled(WordSense wordSense) => WordSenseDragCancelled?.Invoke(wordSense);
internal void DeletePertainsTo(WordSense existingPertainsTo)
{
CurrentWordSenseSource.CurrentWordSense.DeleteParticipleForm(existingPertainsTo);
}
internal void DeleteParticipleForm(WordSense existingParticipleForm)
{
CurrentWordSenseSource.CurrentWordSense.DeleteParticipleForm(existingParticipleForm);
}
internal void DeleteDerivedAdverb(WordSense existingDerivedAdverb)
{
CurrentWordSenseSource.CurrentWordSense.DeleteDerivedAdverb(existingDerivedAdverb);
}
public async Task <Word> LookUp(AsyncRetryPolicy retryPolicy, string url, string word)
{
var wordModel = new Word();
HtmlDocument htmlDoc = new HtmlDocument();
await retryPolicy.ExecuteAsync(async() =>
{
htmlDoc = await Web.LoadFromWebAsync(url + word);
});
var wordEntryBodyNodes = htmlDoc.DocumentNode.SelectNodes(Xpaths.wordEntryBodyNodes);
if (wordEntryBodyNodes == null)
{
return(null);
}
else
{
wordModel.Head = word;
var wordVariants = new List <WordVariant>();
foreach (var wordEntryBodyNode in wordEntryBodyNodes)
{
var wordNodeXPath = wordEntryBodyNode.XPath;
var wordHeadXpath = $"{wordNodeXPath}/{Xpaths.wordHeadNodes}";
var wordTypeXpath = $"{wordNodeXPath}/{Xpaths.wordTypeNodes}";
var wordSenseBlockXpath = $"{wordNodeXPath}/{Xpaths.wordSenseBlockNodes}";
var wordPronounceXpath = $"{wordNodeXPath}/{Xpaths.wordPronounceNodes}";
var wordHead = htmlDoc.GetInnerTextByXpath(wordHeadXpath);
var wordType = htmlDoc.GetInnerTextByXpath(wordTypeXpath);
var wordPronounce = htmlDoc.GetInnerTextByXpath(wordPronounceXpath);
Console.WriteLine($"{wordHead.ToUpper()} - {wordType}");
Console.WriteLine($"{wordPronounce}");
//wordModel.WordVariants.Add(new WordVariant(wordType) { Pronunciation = wordPronounce });
var wordVariant = new WordVariant(wordType);
wordVariant.Pronunciation = wordPronounce;
var senseBlockNodes = htmlDoc.DocumentNode.SelectNodes(wordSenseBlockXpath);
if (senseBlockNodes != null)
{
List <WordSense> wordSenses = new List <WordSense>();
foreach (var senseBlock in senseBlockNodes)
{
var senseBlockXpath = senseBlock.XPath;
var senseBodyDefinitionBlockXpath = $"{senseBlockXpath}/{Xpaths.wordSenseBodyDefBlockNodes}";
var senseBodyDefinitionBlocks = htmlDoc.DocumentNode.SelectNodes(senseBodyDefinitionBlockXpath);
if (senseBodyDefinitionBlocks != null)
{
var wordSense = new WordSense();
foreach (var senseBody in senseBodyDefinitionBlocks)
{
var senseBodyXPath = senseBody.XPath;
var senseBodyDefinitionHeaderXpath = $"{senseBodyXPath}/{Xpaths.wordSenseBodyDefHeadNodes}";
var senseBodyDefinitionExampleXpath = $"{senseBodyXPath}/{Xpaths.wordSenseBodyDefExampleNodes}";
var def = htmlDoc.GetInnerTextByXpath(senseBodyDefinitionHeaderXpath);
wordSense.Definition = def;
var exampleNodes = htmlDoc.DocumentNode.SelectNodes(senseBodyDefinitionExampleXpath);
if (exampleNodes != null)
{
foreach (var example in exampleNodes)
{
wordSense.Examples.Add(example.InnerText);
}
}
}
wordSenses.Add(wordSense);
}
Console.WriteLine();
Console.WriteLine();
}
wordVariant.WordsSenses = wordSenses;
}
wordVariants.Add(wordVariant);
}
wordModel.WordVariants = wordVariants;
}
return(wordModel);
}
private void WordSenseNavigator_WordSenseDropCompleted(WordSense wordSense) => WordSenseDropCompleted?.Invoke(wordSense);
private void WordSenseNavigator_WordSenseDragCancelled(WordSense wordSense) => WordSenseDragCancelled?.Invoke(wordSense);
private void WordSenseNavigator_WordSenseDragStarted(WordSense wordSense) => WordSenseDragStarted?.Invoke(wordSense);
private void OnWordSenseSelected(WordSense wordSense)
{
ViewModel.CurrentWordSense = wordSense;
WordSenseSelected?.Invoke(wordSense);
}
internal void DeleteBaseVerbFormOfParticiple(WordSense existingBaseVerbFormOfParticiple)
{
CurrentWordSenseSource.CurrentWordSense.DeleteBaseVerbFormOfParticiple(existingBaseVerbFormOfParticiple);
}
private void WordNetBrowser_WordSenseDropCompleted(WordSense wordSense) => WordSensesControl.WordSenseNavigator.ViewModel.Edit.ClearDropTargets();
internal void DeletePertainer(WordSense existingPertainer)
{
CurrentWordSenseSource.CurrentWordSense.DeletePertainer(existingPertainer);
}
private void WordSensesControl_WordSenseDragStarted(WordSense wordSense)
{
SynsetNavigator.ViewModel.SetDropTargets_ForWordSense(wordSense);
WordSenseDragStarted?.Invoke(wordSense);
}
private void WordSensesControl_WordSenseDropCompleted(WordSense wordSense)
{
SynsetNavigator.ViewModel.ClearDropTargets();
WordSenseDropCompleted?.Invoke(wordSense);
}
private void OnWordSenseDragStarted(WordSense wordSense) => WordSenseDragStarted?.Invoke(wordSense);
