public void LexEntriesComboHandler_ItemsInComboForInflVariant()
{
using (var sandbox = SetupSandbox(() =>
{
const string wff = "blonde";
var mockText = MakeText(wff);
var wf = MakeWordform(wff);
var wa = MakeAnalysis(wf);
var options = new MakeBundleOptions();
options.LexEntryForm = wff;
options.MakeMorph = (mff) =>
{
Guid slotType = GetSlotType(mff);
IMoMorphSynAnalysis msa1;
var mainEntry = MakeEntry("blondEntry", "", slotType, out msa1);
var mainSense = MakeSense(mainEntry, "fair haired", msa1);
IMoMorphSynAnalysis msa2;
var variantEntry = MakeEntry("blondeEntry", "", slotType, out msa2);
ILexEntryType letDialectalVariantType = Cache.ServiceLocator.GetInstance <ILexEntryTypeRepository>().GetObject(LexEntryTypeTags.kguidLexTypDialectalVar);
letDialectalVariantType.Abbreviation.set_String(Cache.DefaultAnalWs, "dial.var. of");
letDialectalVariantType.Name.set_String(Cache.DefaultAnalWs, "Dialectal Variant");
letDialectalVariantType.ReverseAbbr.set_String(Cache.DefaultAnalWs, "dial.var.");
variantEntry.MakeVariantOf(mainSense, letDialectalVariantType);
return(variantEntry.LexemeFormOA);
};
options.MakeSense = (entry) =>
{
var entryRef = entry.EntryRefsOS.First();
return(entryRef.ComponentLexemesRS.First() as ILexSense);
};
options.MakeMsa = (sense) => { return(sense.MorphoSyntaxAnalysisRA); };
var wmb = MakeBundle(wa, options);
var para = (IStTxtPara)mockText.ContentsOA.ParagraphsOS[0];
var seg = para.SegmentsOS[0];
seg.AnalysesRS.Add(wa);
return(new AnalysisOccurrence(seg, 0));
}))
{
var initialAnalysisStack = sandbox.CurrentAnalysisTree;
using (var handler = GetComboHandler(sandbox, InterlinLineChoices.kflidLexEntries, 0) as SandboxBase.IhMissingEntry)
{
var imorphItemCurrentSandboxState = handler.IndexOfCurrentItem;
Assert.That(imorphItemCurrentSandboxState, Is.EqualTo(1));
var handlerList = handler.ComboList.Items;
Assert.That(handlerList[0].ToString(), Is.EqualTo("Add New Sense for blondeEntry ..."));
Assert.That(handlerList[1].ToString(), Is.EqualTo(" fair haired, ???, blondEntry+dial.var."));
Assert.That(handlerList[2].ToString(), Is.EqualTo(" Add New Sense..."));
}
}
}
protected ILexEntry AddVariantLexeme(List <ICmObject> addList, IVariantComponentLexeme origLe,
string lexForm, IMoMorphType morphTypePoss, string gloss, IPartOfSpeech categoryPoss,
ILexEntryType varType)
{
Assert.IsNotNull(varType, "Need a variant entry type!");
var msa = new SandboxGenericMSA {
MainPOS = categoryPoss
};
var comp = new LexEntryComponents {
MorphType = morphTypePoss, MSA = msa
};
comp.GlossAlternatives.Add(m_tssFact.MakeString(gloss, Cache.DefaultAnalWs));
comp.LexemeFormAlternatives.Add(m_tssFact.MakeString(lexForm, Cache.DefaultVernWs));
var entry = m_entryFact.Create(comp);
entry.MakeVariantOf(origLe, varType);
addList.Add(entry);
return(entry);
}
/// <summary>
/// </summary>
/// <param name="variantEntryType"></param>
/// <param name="gloss"></param>
/// <param name="wsGloss"></param>
/// <returns></returns>
public static ITsString MakeGlossOptionWithInflVariantTypes(ILexEntryType variantEntryType, IMultiStringAccessor gloss, CoreWritingSystemDefinition wsGloss)
{
var inflVariantEntryType = variantEntryType as ILexEntryInflType;
if (gloss == null || inflVariantEntryType == null)
{
return(null);
}
int wsActual2;
ITsString tssGloss = gloss.GetAlternativeOrBestTss(wsGloss.Handle, out wsActual2);
if (tssGloss.Length == 0)
{
tssGloss = gloss.NotFoundTss;
}
var sb = TsStringUtils.MakeIncStrBldr();
var cache = inflVariantEntryType.Cache;
var wsUser = cache.ServiceLocator.WritingSystemManager.UserWritingSystem;
ITsString tssGlossPrepend = AddTssGlossAffix(sb, inflVariantEntryType.GlossPrepend, wsGloss, wsUser);
sb.AppendTsString(tssGloss);
if (sb.Text.Length == 0)
{
return(null); // TODO: add default value for gloss?
}
ITsString tssGlossAppend = AddTssGlossAffix(sb, inflVariantEntryType.GlossAppend, wsGloss, wsUser);
if ((tssGlossPrepend == null || tssGlossPrepend.Length == 0) &&
(tssGlossAppend == null || tssGlossAppend.Length == 0))
{
return(MakeGlossWithReverseAbbrs(gloss, wsGloss, new[] { variantEntryType }));
}
return(sb.GetString());
}
/// <summary>
/// extracts the variant and component from the dialog, depending upon whether we're
/// called from an "Insert Variant" or "Variant Of..." context.
/// </summary>
/// <param name="variant"></param>
/// <param name="componentLexeme"></param>
private void GetVariantAndComponentAndSelectedEntryType(out ILexEntry variant, out IVariantComponentLexeme componentLexeme, out ILexEntryType selectedEntryType)
{
variant = null;
componentLexeme = null;
if (m_fBackRefToVariant)
{
// in "Insert Variant" contexts,
// we're calling the dialog from the component lexeme, so consider SelectedID as the variant.
componentLexeme = m_startingEntry;
variant = LexEntry.CreateFromDBObject(m_cache, SelectedID);
}
else
{
// in "Variant of..." contexts,
// we're calling the dialog from the variant, so consider SelectedID the componentLexeme.
variant = m_startingEntry;
componentLexeme = CmObject.CreateFromDBObject(m_cache, SelectedID) as IVariantComponentLexeme;
}
if (m_fGetVariantEntryTypeFromTreeCombo)
selectedEntryType = LexEntryType.CreateFromDBObject(m_cache, SelectedVariantEntryTypeHvo);
else
selectedEntryType = null;
}
/// <summary>
/// creates a variant entry from this (main) sense,
/// and links the variant to this (main) sense via
/// EntryRefs.ComponentLexemes
/// </summary>
/// <param name="variantType">the type of the new variant</param>
/// <param name="tssVariantLexemeForm">the lexeme form of the new variant</param>
/// <returns>the new variant entry reference</returns>
public ILexEntryRef CreateVariantEntryAndBackRef(ILexEntryType variantType, ITsString tssVariantLexemeForm)
{
int hvoOwnerEntry = Cache.GetOwnerOfObjectOfClass(this.Hvo, LexEntry.kclsidLexEntry);
LexEntry entry = LexEntry.CreateFromDBObject(Cache, hvoOwnerEntry) as LexEntry;
return entry.CreateVariantEntryAndBackRef(this, variantType, tssVariantLexemeForm);
}
private void cbComplexFormType_SelectedIndexChanged(object sender, EventArgs e)
{
m_complexType = m_cbComplexFormType.SelectedItem as ILexEntryType;
m_fComplexForm = m_complexType != null;
if (!m_fComplexForm)
{
var dum = (DummyEntryType)m_cbComplexFormType.SelectedItem;
m_fComplexForm = dum.IsComplexForm;
}
}
/// <summary>
///
/// </summary>
/// <param name="mainEntryOrSense"></param>
/// <param name="variantEntryType"></param>
/// <param name="targetVariantLexemeForm"></param>
/// <returns></returns>
public static ILexEntryRef FindMatchingVariantEntryBackRef(IVariantComponentLexeme mainEntryOrSense,
ILexEntryType variantEntryType, ITsString targetVariantLexemeForm)
{
ILexEntryRef matchingEntryRef = null;
foreach (int hvoLexEntryRef in mainEntryOrSense.VariantFormEntryBackRefs)
{
ILexEntryRef ler = LexEntryRef.CreateFromDBObject((mainEntryOrSense as ICmObject).Cache, hvoLexEntryRef);
// this only handles matching single component lexemes,
// so we only try to match those.
if (ler.ComponentLexemesRS.Count == 1)
{
// next see if we can match on the same variant lexeme form
ILexEntry variantEntry = (ler as CmObject).Owner as ILexEntry;
if (variantEntry.LexemeFormOA == null || variantEntry.LexemeFormOA.Form == null)
continue;
int wsTargetVariant = StringUtils.GetWsAtOffset(targetVariantLexemeForm, 0);
if (targetVariantLexemeForm.Equals(variantEntry.LexemeFormOA.Form.GetAlternativeTss(wsTargetVariant)))
{
// consider this a possible match. we'll use the last such possibility
// if we can't find a matching variantEntryType (below.)
matchingEntryRef = ler;
// next see if we can also match against the type, we'll just 'use' that one.
// otherwise keep going just in case we can find one that does match.
if (variantEntryType != null && ler.VariantEntryTypesRS.Contains(variantEntryType))
break;
}
// continue...
}
}
return matchingEntryRef;
}
/// <summary>
/// creates a variant entry from this (main) sense,
/// and links the variant to this (main) sense via
/// EntryRefs.ComponentLexemes
///
/// NOTE: The caller will need to supply the lexemeForm subsequently.
/// </summary>
/// <param name="variantType">the type of the new variant</param>
/// <returns>the new variant entry reference</returns>
public ILexEntryRef CreateVariantEntryAndBackRef(ILexEntryType variantType)
{
return this.CreateVariantEntryAndBackRef(variantType, null);
}
/// <summary>
/// Make this entry a variant of the given componentLexeme (primary entry) with
/// the given variantType
/// </summary>
/// <param name="componentLexeme"></param>
/// <param name="variantType"></param>
public ILexEntryRef MakeVariantOf(IVariantComponentLexeme componentLexeme, ILexEntryType variantType)
{
ILexEntryRef ler = this.EntryRefsOS.Append(new LexEntryRef());
ler.RefType = LexEntryRef.krtVariant; // variant by default, but good to be explicit here.
ler.HideMinorEntry = 0;
ler.ComponentLexemesRS.Append(componentLexeme);
if (variantType != null)
ler.VariantEntryTypesRS.Append(variantType);
return ler;
}
/// <summary>
/// Find a LexEntryRef matching the given targetComponent (exlusively), and variantEntryType.
/// If we can't match on variantEntryType, we'll just return the reference with the matching component.
/// </summary>
/// <param name="targetComponent">match on the LexEntryRef that contains this, and only this component.</param>
/// <param name="variantEntryType"></param>
/// <returns></returns>
public ILexEntryRef FindMatchingVariantEntryRef(IVariantComponentLexeme targetComponent, ILexEntryType variantEntryType)
{
ILexEntryRef matchingEntryRef = null;
foreach (ILexEntryRef ler in EntryRefsOS)
{
if (ler.RefType == LexEntryRef.krtVariant &&
ler.ComponentLexemesRS.Count == 1 &&
ler.ComponentLexemesRS.Contains(targetComponent))
{
matchingEntryRef = ler;
// next see if we can also match against the type, we'll just 'use' that one.
// otherwise keep going just in case we can find one that does match.
if (variantEntryType != null && ler.VariantEntryTypesRS.Contains(variantEntryType))
break;
}
}
return matchingEntryRef;
}
private void cbComplexFormType_SelectedIndexChanged(object sender, EventArgs e)
{
m_complexType = cbComplexFormType.SelectedItem as ILexEntryType;
m_fComplexForm = m_complexType != null;
if (!m_fComplexForm)
{
DummyEntryType dum = cbComplexFormType.SelectedItem as DummyEntryType;
Debug.Assert(dum != null);
m_fComplexForm = dum.IsComplexForm;
}
}
/// <summary>
/// creates a variant entry from this (main) entry using its lexemeForm information,
/// and links the variant to the given componentLexeme entry via
/// EntryRefs.ComponentLexemes
/// </summary>
/// <param name="variantType">the type of the new variant</param>
/// <param name="componentLexeme">the entry or sense of which the new variant entry is a variant</param>
/// <param name="tssVariantLexemeForm">the lexeme form of the new variant</param>
/// <returns>the new variant entry reference</returns>
internal ILexEntryRef CreateVariantEntryAndBackRef(IVariantComponentLexeme componentLexeme, ILexEntryType variantType, ITsString tssVariantLexemeForm)
{
using (new UndoRedoTaskHelper(Cache, Strings.ksUndoCreateVariantEntry, Strings.ksRedoCreateVariantEntry))
{
ILexEntry variantEntry = new LexEntry();
Cache.LangProject.LexDbOA.EntriesOC.Add(variantEntry);
if (this.LexemeFormOA is IMoAffixAllomorph)
variantEntry.LexemeFormOA = new MoAffixAllomorph();
else
variantEntry.LexemeFormOA = new MoStemAllomorph();
if (this.LexemeFormOA != null)
variantEntry.LexemeFormOA.MorphTypeRAHvo = this.LexemeFormOA.MorphTypeRAHvo;
if (tssVariantLexemeForm != null)
variantEntry.LexemeFormOA.FormMinusReservedMarkers = tssVariantLexemeForm;
(variantEntry as LexEntry).UpdateHomographNumbersAccountingForNewEntry();
return (variantEntry as LexEntry).MakeVariantOf(componentLexeme, variantType);
}
}
private static ILexEntryRef CreateComplexForm(LcmCache cache, ICmObject main, ILexEntry complexForm, bool subentry, ILexEntryType complexEntryType)
{
var complexEntryRef = cache.ServiceLocator.GetInstance <ILexEntryRefFactory>().Create();
complexForm.EntryRefsOS.Add(complexEntryRef);
var complexEntryTypeAbbrText = complexEntryType.Abbreviation.BestAnalysisAlternative.Text;
var complexEntryTypeRevAbbr = complexEntryType.ReverseAbbr;
// If there is no reverseAbbr, generate one from the forward abbr (e.g. "comp. of") by trimming the trailing " of"
if (complexEntryTypeRevAbbr.BestAnalysisAlternative.Equals(complexEntryTypeRevAbbr.NotFoundTss))
{
complexEntryTypeRevAbbr.SetAnalysisDefaultWritingSystem(complexEntryTypeAbbrText.Substring(0, complexEntryTypeAbbrText.Length - 3));
}
complexEntryRef.ComplexEntryTypesRS.Add(complexEntryType);
complexEntryRef.RefType = LexEntryRefTags.krtComplexForm;
complexEntryRef.ComponentLexemesRS.Add(main);
if (subentry)
{
complexEntryRef.PrimaryLexemesRS.Add(main);
}
else
{
complexEntryRef.ShowComplexFormsInRS.Add(main);
}
return(complexEntryRef);
}
private ILexEntryRef FindMatchingEntryRef(ILexEntry variant, IVariantComponentLexeme componentLexeme, ILexEntryType selectedEntryType)
{
ILexEntryRef matchingEntryRef = null;
if (variant != null)
{
// see if the starting entry has the SelectedID already as a ComponentLexeme
matchingEntryRef = (variant as LexEntry).FindMatchingVariantEntryRef(componentLexeme,
selectedEntryType);
}
else
{
// determine whether the selected entry or sense is already
// linked to an existing variant with the given lexeme form.
matchingEntryRef = LexEntry.FindMatchingVariantEntryBackRef(componentLexeme,
selectedEntryType, m_tssVariantLexemeForm);
}
return matchingEntryRef;
}
/// <summary>
/// create a variant and link it to the given leMain entry
/// and confirm this analysis on the given (monomorphemic) cba.
/// </summary>
/// <param name="iSegment"></param>
/// <param name="iSegForm"></param>
/// <param name="leMain"></param>
/// <param name="variantType"></param>
/// <returns>hvo of the resulting LexEntryRef</returns>
virtual public ILexEntryRef SetVariantOf(int iSegment, int iSegForm, ILexEntry leMain, ILexEntryType variantType)
{
if (variantType == null)
throw new ArgumentNullException("requires non-null variantType parameter.");
// for now, just create the variant entry and the variant of target, treating the wordform as monomorphemic.
ITsString tssVariantLexemeForm = GetBaselineText(iSegment, iSegForm);
ILexEntryRef ler = leMain.CreateVariantEntryAndBackRef(variantType, tssVariantLexemeForm);
ILexEntry variant = ler.Owner as ILexEntry;
ArrayList morphs = new ArrayList(1);
morphs.Add(variant.LexemeFormOA);
BreakIntoMorphs(iSegment, iSegForm, morphs);
ILexEntry mainEntry;
ILexSense mainSense;
MorphServices.GetMainEntryAndSenseStack(ler.ComponentLexemesRS.First() as IVariantComponentLexeme, out mainEntry, out mainSense);
SetMorphSense(iSegment, iSegForm, 0, mainSense);
return ler;
}
private void ExportLexEntryTypeFields(TextWriter w, ILexEntryType item)
{
if (item != null)
ExportMultiUnicode(w, item.ReverseAbbr);
}
private ILexEntryRef FindMatchingEntryRef(ILexEntry variant, IVariantComponentLexeme componentLexeme, ILexEntryType selectedEntryType)
{
ILexEntryRef matchingEntryRef;
if (variant != null)
{
// see if the starting entry has the SelectedID already as a ComponentLexeme
matchingEntryRef = variant.FindMatchingVariantEntryRef(componentLexeme,
selectedEntryType);
}
else
{
// determine whether the selected entry or sense is already
// linked to an existing variant with the given lexeme form.
matchingEntryRef = componentLexeme.FindMatchingVariantEntryBackRef(selectedEntryType, m_tssVariantLexemeForm);
}
return(matchingEntryRef);
}
/// <summary>
/// extracts the variant and component from the dialog, depending upon whether we're
/// called from an "Insert Variant" or "Variant Of..." context.
/// </summary>
/// <param name="variant">The variant.</param>
/// <param name="componentLexeme">The component lexeme.</param>
/// <param name="selectedEntryType">Type of the selected entry.</param>
private void GetVariantAndComponentAndSelectedEntryType(out ILexEntry variant, out IVariantComponentLexeme componentLexeme, out ILexEntryType selectedEntryType)
{
if (m_fBackRefToVariant)
{
// in "Insert Variant" contexts,
// we're calling the dialog from the component lexeme, so consider SelectedID as the variant.
componentLexeme = m_startingEntry;
variant = SelectedObject as ILexEntry;
}
else
{
// in "Variant of..." contexts,
// we're calling the dialog from the variant, so consider SelectedID the componentLexeme.
variant = m_startingEntry;
componentLexeme = SelectedObject as IVariantComponentLexeme;
}
selectedEntryType = m_fGetVariantEntryTypeFromTreeCombo
? m_cache.ServiceLocator.GetInstance <ILexEntryTypeRepository>().GetObject(SelectedVariantEntryTypeHvo) : null;
}
/// <summary>
/// extracts the variant and component from the dialog, depending upon whether we're
/// called from an "Insert Variant" or "Variant Of..." context.
/// </summary>
/// <param name="variant">The variant.</param>
/// <param name="componentLexeme">The component lexeme.</param>
/// <param name="selectedEntryType">Type of the selected entry.</param>
private void GetVariantAndComponentAndSelectedEntryType(out ILexEntry variant, out IVariantComponentLexeme componentLexeme, out ILexEntryType selectedEntryType)
{
if (m_fBackRefToVariant)
{
// in "Insert Variant" contexts,
// we're calling the dialog from the component lexeme, so consider SelectedID as the variant.
componentLexeme = m_startingEntry;
variant = SelectedObject as ILexEntry;
}
else
{
// in "Variant of..." contexts,
// we're calling the dialog from the variant, so consider SelectedID the componentLexeme.
variant = m_startingEntry;
componentLexeme = SelectedObject as IVariantComponentLexeme;
}
selectedEntryType = m_fGetVariantEntryTypeFromTreeCombo
? m_cache.ServiceLocator.GetInstance<ILexEntryTypeRepository>().GetObject(SelectedVariantEntryTypeHvo) : null;
}
/// <summary>
/// creates a variant entry from this (main) entry,
/// and links the variant to this (main) entry via
/// EntryRefs.ComponentLexemes
/// </summary>
/// <param name="variantType">the type of the new variant</param>
/// <param name="tssVariantLexemeForm">the lexeme form of the new variant</param>
/// <returns>the new variant entry reference</returns>
public ILexEntryRef CreateVariantEntryAndBackRef(ILexEntryType variantType, ITsString tssVariantLexemeForm)
{
return CreateVariantEntryAndBackRef(this, variantType, tssVariantLexemeForm);
}
/// <summary>
/// extracts the variant and component from the dialog, depending upon whether we're
/// called from an "Insert Variant" or "Variant Of..." context.
/// </summary>
/// <param name="variant"></param>
/// <param name="componentLexeme"></param>
private void GetVariantAndComponentAndSelectedEntryType(out ILexEntry variant, out IVariantComponentLexeme componentLexeme, out ILexEntryType selectedEntryType)
{
variant = null;
componentLexeme = null;
if (m_fBackRefToVariant)
{
// in "Insert Variant" contexts,
// we're calling the dialog from the component lexeme, so consider SelectedID as the variant.
componentLexeme = m_startingEntry;
variant = LexEntry.CreateFromDBObject(m_cache, SelectedID);
}
else
{
// in "Variant of..." contexts,
// we're calling the dialog from the variant, so consider SelectedID the componentLexeme.
variant = m_startingEntry;
componentLexeme = CmObject.CreateFromDBObject(m_cache, SelectedID) as IVariantComponentLexeme;
}
if (m_fGetVariantEntryTypeFromTreeCombo)
{
selectedEntryType = LexEntryType.CreateFromDBObject(m_cache, SelectedVariantEntryTypeHvo);
}
else
{
selectedEntryType = null;
}
}
