Exemplo n.º 1
0
        public bool OnConvertAllomorph(object cmd)
        {
            Command   command   = cmd as Command;
            int       toClsid   = (int)m_dataEntryForm.Cache.MetaDataCacheAccessor.GetClassId(command.GetParameter("toClassName"));
            ILexEntry entry     = m_dataEntryForm.Root as ILexEntry;
            Slice     slice     = m_dataEntryForm.CurrentSlice;
            IMoForm   allomorph = slice.Object as IMoForm;

            if (entry != null && allomorph != null && toClsid != 0)
            {
                if (CheckForFormDataLoss(allomorph, toClsid))
                {
                    Form    mainWindow = (Form)m_mediator.PropertyTable.GetValue("window");
                    IMoForm newForm    = null;
                    using (new WaitCursor(mainWindow))
                    {
                        using (UndoRedoCommandHelper undoRedoTask = new UndoRedoCommandHelper(m_dataEntryForm.Cache, cmd as Command))
                        {
                            newForm = CreateNewForm(toClsid);
                            entry.ReplaceMoForm(allomorph, newForm);
                        }
                        m_dataEntryForm.RefreshList(false);
                    }
                    SelectNewFormSlice(newForm);
                }
            }
            return(true);
        }
        private static void WriteInflectionClasses(XmlWriter writer, FdoCache fdoCache, int allomorphHvo)
        {
            if (allomorphHvo <= 0)
            {
                return;
            }
            // use IMoForm instead of IMoAffixForm or IMoAffixAllomorph because it could be an IMoStemAllomorph
            IMoForm form = fdoCache.ServiceLocator.GetInstance <IMoFormRepository>().GetObject(allomorphHvo);

            if (form == null)
            {
                return;
            }
            if (!(form is IMoAffixForm))
            {
                return;
            }
            foreach (IMoInflClass ic in ((IMoAffixForm)form).InflectionClassesRC)
            {
                writer.WriteStartElement("inflectionClass");
                writer.WriteAttributeString("id", ic.Hvo.ToString(CultureInfo.InvariantCulture));
                writer.WriteAttributeString("abbr", ic.Abbreviation.BestAnalysisAlternative.Text);
                writer.WriteEndElement();                 //inflectionClass
            }
        }
Exemplo n.º 3
0
        public bool OnConvertLexemeForm(object cmd)
        {
            var command = cmd as Command;
            var toClsid = m_dataEntryForm.Cache.MetaDataCacheAccessor.GetClassId(command.GetParameter("toClassName"));
            var entry   = m_dataEntryForm.Root as ILexEntry;

            if (entry != null)
            {
                if (CheckForFormDataLoss(entry.LexemeFormOA, toClsid))
                {
                    var     mainWindow = m_propertyTable.GetValue <Form>("window");
                    IMoForm newForm    = null;
                    using (new WaitCursor(mainWindow))
                    {
                        UndoableUnitOfWorkHelper.Do(command.UndoText, command.RedoText, entry, () =>
                        {
                            newForm = CreateNewForm(entry, toClsid);
                            entry.ReplaceMoForm(entry.LexemeFormOA, newForm);
                        });
                        m_dataEntryForm.RefreshList(false);
                    }
                    SelectNewFormSlice(newForm);
                }
            }
            return(true);
        }
Exemplo n.º 4
0
 public EmptyWwfInfo(IMoForm form, IMoMorphSynAnalysis msa, IPartOfSpeech pos, ILexSense sense)
 {
     Form  = form;
     Msa   = msa;
     Pos   = pos;
     Sense = sense;
 }
Exemplo n.º 5
0
        public bool OnConvertAllomorph(object cmd)
        {
            var command   = cmd as Command;
            int toClsid   = (int)m_dataEntryForm.Cache.MetaDataCacheAccessor.GetClassId(command.GetParameter("toClassName"));
            var entry     = m_dataEntryForm.Root as ILexEntry;
            var slice     = m_dataEntryForm.CurrentSlice;
            var allomorph = slice.Object as IMoForm;

            if (entry != null && allomorph != null && toClsid != 0)
            {
                if (CheckForFormDataLoss(allomorph, toClsid))
                {
                    var     mainWindow = (Form)m_mediator.PropertyTable.GetValue("window");
                    IMoForm newForm    = null;
                    using (new WaitCursor(mainWindow))
                    {
                        UndoableUnitOfWorkHelper.Do(command.UndoText, command.RedoText, entry, () =>
                        {
                            newForm = CreateNewForm(entry, toClsid);
                            entry.ReplaceMoForm(allomorph, newForm);
                        });
                        m_dataEntryForm.RefreshList(false);
                    }
                    SelectNewFormSlice(newForm);
                }
            }
            return(true);
        }
Exemplo n.º 6
0
        bool CheckForFormDataLoss(IMoForm origForm, int toClsid)
        {
            string msg = null;

            switch (origForm.ClassID)
            {
            case MoAffixAllomorph.kclsidMoAffixAllomorph:
                IMoAffixAllomorph affAllo = origForm as IMoAffixAllomorph;
                bool loseEnv  = affAllo.PhoneEnvRC.Count > 0;
                bool losePos  = affAllo.PositionRS.Count > 0;
                bool loseGram = affAllo.MsEnvFeaturesOAHvo != 0 || affAllo.MsEnvPartOfSpeechRAHvo != 0;
                if (loseEnv && losePos && loseGram)
                {
                    msg = LexEdStrings.ksConvertFormLoseEnvInfixLocGramInfo;
                }
                else if (loseEnv && losePos)
                {
                    msg = LexEdStrings.ksConvertFormLoseEnvInfixLoc;
                }
                else if (loseEnv && loseGram)
                {
                    msg = LexEdStrings.ksConvertFormLoseEnvGramInfo;
                }
                else if (losePos && loseGram)
                {
                    msg = LexEdStrings.ksConvertFormLoseInfixLocGramInfo;
                }
                else if (loseEnv)
                {
                    msg = LexEdStrings.ksConvertFormLoseEnv;
                }
                else if (losePos)
                {
                    msg = LexEdStrings.ksConvertFormLoseInfixLoc;
                }
                else if (loseGram)
                {
                    msg = LexEdStrings.ksConvertFormLoseGramInfo;
                }
                break;

            case MoAffixProcess.kclsidMoAffixProcess:
                msg = LexEdStrings.ksConvertFormLoseRule;
                break;

            case MoStemAllomorph.kclsidMoStemAllomorph:
                // not implemented
                break;
            }

            if (msg != null)
            {
                DialogResult result = MessageBox.Show(msg, LexEdStrings.ksConvertFormLoseCaption,
                                                      MessageBoxButtons.YesNo, MessageBoxIcon.Warning);
                return(result == DialogResult.Yes);
            }

            return(true);
        }
Exemplo n.º 7
0
 private void SwapAllomorphWithLexeme(ILexEntry entry, IMoForm allomorph, Command cmd)
 {
     using (UndoRedoCommandHelper undoRedoTask = new UndoRedoCommandHelper(m_dataEntryForm.Cache, cmd))
     {
         entry.AlternateFormsOS.InsertAt(entry.LexemeFormOA, allomorph.IndexInOwner);
         entry.LexemeFormOA = allomorph;
     }
 }
Exemplo n.º 8
0
 private void SwapAllomorphWithLexeme(ILexEntry entry, IMoForm allomorph, Command cmd)
 {
     UndoableUnitOfWorkHelper.Do(cmd.UndoText, cmd.RedoText, entry, () =>
     {
         entry.AlternateFormsOS.Insert(allomorph.IndexInOwner, entry.LexemeFormOA);
         entry.LexemeFormOA = allomorph;
     });
 }
Exemplo n.º 9
0
 public void InvalidReduplicationForm(IMoForm form, string reason, IMoMorphSynAnalysis msa)
 {
     m_xmlWriter.WriteStartElement("LoadError");
     m_xmlWriter.WriteAttributeString("type", "invalid-redup-form");
     m_xmlWriter.WriteElementString("Form", form.Form.VernacularDefaultWritingSystem.Text);
     m_xmlWriter.WriteElementString("Hvo", msa.Hvo.ToString(CultureInfo.InvariantCulture));
     m_xmlWriter.WriteElementString("Reason", reason);
     m_xmlWriter.WriteEndElement();
 }
Exemplo n.º 10
0
        internal static XElement CreateAllomorphElement(string name, IMoForm form, IMoMorphSynAnalysis msa, bool circumfix)
        {
            var elem = new XElement(name, new XAttribute("id", form.Hvo), new XAttribute("type", GetMorphTypeString(circumfix ? MoMorphTypeTags.kguidMorphCircumfix : form.MorphTypeRA.Guid)),
                                    new XElement("Form", circumfix ? form.OwnerOfClass <ILexEntry>().HeadWord.Text : form.GetFormWithMarkers(form.Cache.DefaultVernWs)),
                                    new XElement("LongName", form.LongName));

            elem.Add(CreateMorphemeElement(msa));
            return(elem);
        }
Exemplo n.º 11
0
 public void InvalidEnvironment(IMoForm form, IPhEnvironment env, string reason, IMoMorphSynAnalysis msa)
 {
     m_xmlWriter.WriteStartElement("LoadError");
     m_xmlWriter.WriteAttributeString("type", "invalid-environment");
     m_xmlWriter.WriteElementString("Form", form.Form.VernacularDefaultWritingSystem.Text);
     m_xmlWriter.WriteElementString("Env", env.StringRepresentation.Text);
     m_xmlWriter.WriteElementString("Hvo", msa.Hvo.ToString(CultureInfo.InvariantCulture));
     m_xmlWriter.WriteElementString("Reason", reason);
     m_xmlWriter.WriteEndElement();
 }
Exemplo n.º 12
0
 void SelectNewFormSlice(IMoForm newForm)
 {
     foreach (Slice slice in m_dataEntryForm.Controls)
     {
         if (slice.Object.Hvo == newForm.Hvo)
         {
             m_dataEntryForm.ActiveControl = slice;
             break;
         }
     }
 }
Exemplo n.º 13
0
        public virtual bool OnSwapAllomorphWithLexeme(object cmd)
        {
            Slice     slice     = m_dataEntryForm.CurrentSlice;
            ILexEntry entry     = m_dataEntryForm.Root as ILexEntry;
            IMoForm   allomorph = slice.Object as IMoForm;

            if (entry != null && allomorph != null)
            {
                SwapAllomorphWithLexeme(entry, allomorph, cmd as Command);
            }
            return(true);
        }
Exemplo n.º 14
0
        public virtual bool OnDisplayConvertAllomorph(object commandObject, ref UIItemDisplayProperties display)
        {
            Command cmd       = commandObject as Command;
            uint    fromClsid = m_dataEntryForm.Cache.MetaDataCacheAccessor.GetClassId(cmd.GetParameter("fromClassName"));
            Slice   slice     = m_dataEntryForm.CurrentSlice;
            IMoForm allomorph = slice.Object as IMoForm;
            bool    enable    = allomorph != null && fromClsid != 0 && allomorph.ClassID == fromClsid;

            display.Visible = enable;
            display.Enabled = enable;
            return(true);
        }
Exemplo n.º 15
0
 private void SetSelectedObject()
 {
     foreach (ListViewItem lvi in m_lvAlloOptions.Items)
     {
         if (lvi.Selected)
         {
             m_allomorph = lvi.Tag as IMoForm;
             SetBottomMessage();
         }
     }
     btnOK.Enabled = true;
 }
Exemplo n.º 16
0
        /// ------------------------------------------------------------------------------------
        /// <summary>
        /// Find an allomorph with the specified form, if any. Searches both LexemeForm and
        /// AlternateForms properties.
        /// </summary>
        /// <param name="entry"></param>
        /// <param name="tssform">The tssform.</param>
        /// <returns></returns>
        /// ------------------------------------------------------------------------------------
        public static IMoForm FindMatchingAllomorph(ILexEntry entry, ITsString tssform)
        {
            IMoForm lf     = entry.LexemeFormOA;
            int     wsVern = TsStringUtils.GetWsAtOffset(tssform, 0);
            string  form   = tssform.Text;

            if (lf != null && lf.Form.get_String(wsVern).Text == form)
            {
                return(lf);
            }
            return(entry.AlternateFormsOS.FirstOrDefault(mf => mf.Form.get_String(wsVern).Text == form));
        }
Exemplo n.º 17
0
        public void MultilingualStringBasedonStringDictionary()
        {
            FdoReferenceSequence <ILgWritingSystem> systems = Cache.LangProject.CurVernWssRS;
            ILexDb    ld = Cache.LangProject.LexDbOA;
            ILexEntry le = MakeLexEntry(ld, "xyzTest1", "xyzDefn1.1", 0);
            IMoForm   m  = MoForm.MakeMorph(Cache, le, "-is");

            m.Form.SetAlternative("iz", systems[1].Hvo);

            string t      = "<entry><objAtomic objProperty='LexemeFormOA'/></entry>";
            string c      = "<class name='MoForm'><multilingualStringElement name='form' simpleProperty='NamesWithMarkers'/></class>";
            string result = GetResultStringFromEntry(le, t, c);

            Assert.AreEqual("<entry><form ws=\"fr\">-is</form>\r\n<form ws=\"ur\">-iz</form>\r\n</entry>", result.Trim());
        }
Exemplo n.º 18
0
        public void GetActualWs_MorphBundleBehavesLikeMoForm()
        {
            var wsManager = new WritingSystemManager();
            CoreWritingSystemDefinition enWs;

            wsManager.GetOrSet("en", out enWs);
            int wsEng = enWs.Handle;

            CoreWritingSystemDefinition frWs;

            wsManager.GetOrSet("fr", out frWs);
            int wsFrn = frWs.Handle;

            var choices = new InterlinLineChoices(m_lp, wsFrn, wsEng);

            MakeStandardState(choices);
            InterlinLineSpec spec = choices[1];

            Assert.AreEqual(InterlinLineChoices.kflidMorphemes, spec.Flid);
            // The StringFlid for this line spec always corresponds to a MoForm
            Assert.AreEqual(MoFormTags.kflidForm, spec.StringFlid);

            IWfiWordform    wf;
            IWfiAnalysis    wag;
            ITsString       str = TsStringUtils.MakeString("WordForm", spec.WritingSystem);
            IWfiMorphBundle wmb = Cache.ServiceLocator.GetInstance <IWfiMorphBundleFactory>().Create();

            NonUndoableUnitOfWorkHelper.Do(Cache.ActionHandlerAccessor, () =>
            {
                wf  = Cache.ServiceLocator.GetInstance <IWfiWordformFactory>().Create(str);
                wag = WordAnalysisOrGlossServices.CreateNewAnalysisWAG(wf);
                wag.MorphBundlesOS.Add(wmb);
                ILexEntry entry = Cache.ServiceLocator.GetInstance <ILexEntryFactory>().Create();
                IMoForm moForm  = Cache.ServiceLocator.GetInstance <IMoStemAllomorphFactory>().Create();
                entry.AlternateFormsOS.Add(moForm);
                moForm.Form.set_String(spec.WritingSystem, "Morph");
                wmb.MorphRA = moForm;
            });
            // The line spec for displaying the Morpheme must be able to handle getting the ws from both
            // MorphBundles or MoForms
            Assert.True(spec.Flid == InterlinLineChoices.kflidMorphemes);
            int wmbWs = spec.GetActualWs(Cache, wmb.Hvo, spec.WritingSystem);
            int mfWs  = spec.GetActualWs(Cache, wmb.MorphRA.Hvo, spec.WritingSystem);

            Assert.True(wmbWs == spec.WritingSystem);
            Assert.True(mfWs == spec.WritingSystem);
        }
Exemplo n.º 19
0
        public override string GetHvoRepresentation(FdoCache cache, int hvo)
        {
            ICmObject obj  = cache.ServiceLocator.GetInstance <ICmObjectRepository>().GetObject(hvo);
            IMoForm   form = obj as IMoForm;
            string    sResult;

            if (form != null)
            {
                sResult = form.ShortName;
            }
            else
            {
                sResult = ParserUIStrings.ksUnknownAllomorph;                 // in case the user continues...
                throw new ApplicationException(sResult);
            }
            return(sResult);
        }
Exemplo n.º 20
0
        public override string GetHvoRepresentation(FdoCache cache, int hvo)
        {
            ICmObject obj  = CmObject.CreateFromDBObject(cache, hvo);
            IMoForm   form = obj as IMoForm;
            string    sResult;

            if (form != null)
            {
                sResult = form.ShortName;
            }
            else
            {
                sResult = ParserUIStrings.ksUnknownAllomorph;                 // in case the user continues...
                throw new ApplicationException(sResult);
            }
            return(sResult);
        }
Exemplo n.º 21
0
        protected void ConvertAffixAlloFeats(XmlDocument doc, XmlNode node, IMoForm form, XmlNode tempNode)
        {
            IMoAffixAllomorph sallo       = form as IMoAffixAllomorph;
            IFsFeatStruc      fsFeatStruc = sallo.MsEnvFeaturesOA;

            if (fsFeatStruc != null && !fsFeatStruc.IsEmpty)
            {
                tempNode = CreateXmlElement(doc, "affixAlloFeats", node);
                CreateFeatureStructureNodes(doc, tempNode, fsFeatStruc, fsFeatStruc.Hvo);
            }
            else
            {               // There's no overt stem name on this allomorph, but there might be overt stem names
                // on other allomorphs in this lexical entry.  This allomorph, then, cannot bear any
                // of the features of these other stem names.  If so, there will be a property named
                // NotStemNameddd or NotStemNamedddNotStemNamedddd, etc.
                CreateNotAffixAlloFeatsElement(doc, node, tempNode);
            }
        }
Exemplo n.º 22
0
        /// <summary>
        /// Make (two) monomorphemic analyses on our favorite wordform, connected to two entries, one with two glosses.
        /// </summary>
        private void MakeMonoAnalyses()
        {
            string    formLexEntry    = "axx";
            ITsString tssLexEntryForm = Cache.MakeVernTss(formLexEntry);
            int       clsidForm;
            ILexEntry entry = LexEntry.CreateEntry(Cache,
                                                   MoMorphType.FindMorphType(Cache, new MoMorphTypeCollection(Cache), ref formLexEntry, out clsidForm), tssLexEntryForm,
                                                   "axe", null);
            ILexSense senseAxe = entry.SensesOS[0];
            IMoForm   form     = entry.LexemeFormOA;

            m_wfaAxe = new WfiAnalysis();
            m_wfAxx.AnalysesOC.Add(m_wfaAxe);
            IWfiMorphBundle bundle = m_wfaAxe.MorphBundlesOS.Append(new WfiMorphBundle());

            bundle.MorphRA = form;
            bundle.SenseRA = senseAxe;

            m_wgAxe = new WfiGloss();
            m_wfaAxe.MeaningsOC.Add(m_wgAxe);
            m_wgAxe.Form.AnalysisDefaultWritingSystem = "axe";

            m_wgChopper = new WfiGloss();
            m_wfaAxe.MeaningsOC.Add(m_wgChopper);
            m_wgChopper.Form.AnalysisDefaultWritingSystem = "chopper";
            m_wfaAxe.SetAgentOpinion(m_fdoCache.LangProject.DefaultUserAgent, Opinions.approves);

            ILexEntry entryCut = LexEntry.CreateEntry(Cache,
                                                      MoMorphType.FindMorphType(Cache, new MoMorphTypeCollection(Cache), ref formLexEntry, out clsidForm), tssLexEntryForm,
                                                      "cut", null);

            m_wfaCut = new WfiAnalysis();
            m_wfAxx.AnalysesOC.Add(m_wfaCut);
            bundle         = m_wfaCut.MorphBundlesOS.Append(new WfiMorphBundle());
            bundle.MorphRA = entryCut.LexemeFormOA;
            bundle.SenseRA = entryCut.SensesOS[0];

            m_wgCut = new WfiGloss();
            m_wfaCut.MeaningsOC.Add(m_wgCut);
            m_wgCut.Form.AnalysisDefaultWritingSystem = "cut";
            m_wfaCut.SetAgentOpinion(m_fdoCache.LangProject.DefaultUserAgent, Opinions.approves);

            m_cAnalyses += 2;
        }
Exemplo n.º 23
0
        protected void ConvertStemName(XmlDocument doc, XmlNode node, IMoForm form, XmlNode tempNode)
        {
            IMoStemAllomorph sallo = form as IMoStemAllomorph;
            IMoStemName      sn    = sallo.StemNameRA;

            if (sn != null)
            {
                tempNode = CreateXmlElement(doc, "stemName", node);
                CreateXmlAttribute(doc, "id", sn.Hvo.ToString(), tempNode);
                tempNode.InnerXml = CreateEntities(sn.Name.BestAnalysisAlternative.Text);
            }
            else
            {               // There's no overt stem name on this allomorph, but there might be overt stem names
                // on other allomorphs in this lexical entry.  This allomorph, then, cannot bear any
                // of the features of these other stem names.  If so, there will be a property named
                // NotStemNameddd or NotStemNamedddNotStemNamedddd, etc.
                tempNode = CreateNotStemNameElement(doc, node, tempNode);
            }
        }
Exemplo n.º 24
0
        private void SwapValues(ILexEntry entry, IMoForm origForm, IMoForm newForm, int typeHvo,
                                List <IMoMorphSynAnalysis> rgmsaOld)
        {
            DataTree dtree = this.Slice.ContainingDataTree;
            int      idx   = this.Slice.IndexInContainer;

            dtree.DoNotRefresh = true;                  // don't let the datatree repeatedly redraw itself...
            Debug.Assert(entry is LexEntry);
            (entry as LexEntry).ReplaceMoForm(origForm, newForm);
            newForm.MorphTypeRAHvo = typeHvo;
            (entry as LexEntry).ReplaceObsoleteMsas(rgmsaOld);
            // Dispose of any obsolete slices: new ones will replace them automatically in a moment
            // when the datatree is redrawn.
            foreach (Slice slice in this.Slice.ContainingDataTree.Controls)
            {
                if (slice.IsDisposed)
                {
                    continue;
                }
                if (slice.Object is IMoMorphSynAnalysis && rgmsaOld.Contains(slice.Object as IMoMorphSynAnalysis))
                {
                    slice.Dispose();
                }
                else if (slice is MSAReferenceComboBoxSlice)
                {
                    slice.Dispose();
                }
            }
            // now fix the record list, since it may be showing MoForm dependent columns (e.g. MorphType, Homograph, etc...)
            dtree.FixRecordList();
            dtree.DoNotRefresh = false;
            Slice sliceT = dtree.Controls[idx] as Slice;

            if (sliceT != null && sliceT is MorphTypeAtomicReferenceSlice)
            {
                // When the new slice is created, the launch button is placed in the middle of
                // the slice rather than at the end.  This fiddling with the slice width seems
                // to fix that.  Then setting the index restores focus to the new slice.
                sliceT.Width += 1;
                sliceT.Width -= 1;
                dtree.GotoNextSliceAfterIndex(idx - 1);
            }
        }
Exemplo n.º 25
0
        protected override void HandleMatchingSelectionChanged()
        {
            m_fwcbAllomorphs.Items.Clear();
            m_fwcbAllomorphs.Text = String.Empty;
            if (m_selEntryID == 0)
            {
                return;
            }
            m_fwcbAllomorphs.SuspendLayout();
            ILexEntry le = LexEntry.CreateFromDBObject(m_cache, m_selEntryID);

            /* NB: We remove abstract MoForms, because the adhoc allo coprohibiton object wants them removed.
             * If any other client of this dlg comes along that wants them,
             * we will need to feed in a parameter that tells us whether to exclude them or not.
             */
            // Add the lexeme form, if it exists.
            IMoForm lf = le.LexemeFormOA;

            if (lf != null && !lf.IsAbstract)
            {
                m_fwcbAllomorphs.Items.Add(new LAllomorph(le.LexemeFormOA));
            }
            foreach (IMoForm allo in le.AlternateFormsOS)
            {
                if (!allo.IsAbstract)
                {
                    m_fwcbAllomorphs.Items.Add(new LAllomorph(allo));
                }
            }
            if (m_fwcbAllomorphs.Items.Count > 0)
            {
                m_fwcbAllomorphs.SelectedItem = m_fwcbAllomorphs.Items[0];
            }
            btnOK.Enabled = m_fwcbAllomorphs.Items.Count > 0;
            m_fwcbAllomorphs.ResumeLayout();
            // For a resizeable dialog, we don't want AdjustForStylesheet to really change its size,
            // because then it ends up growing every time it launches!
            int oldHeight = this.Height;

            m_fwcbAllomorphs.AdjustForStyleSheet(this, grplbl, m_mediator);
            this.Height = oldHeight;
        }
        private static void WriteStemNameElement(XmlWriter writer, IMoForm form, string props)
        {
            var sallo = form as IMoStemAllomorph;

            Debug.Assert(sallo != null);
            IMoStemName sn = sallo.StemNameRA;

            if (sn != null)
            {
                writer.WriteStartElement("stemName");
                writer.WriteAttributeString("id", sn.Hvo.ToString(CultureInfo.InvariantCulture));
                writer.WriteString(sn.Name.BestAnalysisAlternative.Text);
                writer.WriteEndElement();                 //stemName
            }
            else
            {               // There's no overt stem name on this allomorph, but there might be overt stem names
                // on other allomorphs in this lexical entry.  This allomorph, then, cannot bear any
                // of the features of these other stem names.  If so, there will be a property named
                // NotStemNameddd or NotStemNamedddNotStemNamedddd, etc.
                WriteNotStemNameElement(writer, props);
            }
        }
Exemplo n.º 27
0
        public void TestOwningFlid()
        {
            Assert.AreEqual(0, Cache.LangProject.OwningFlid);             // no owner
            Assert.AreEqual(LangProjectTags.kflidLexDb, Cache.LangProject.LexDbOA.OwningFlid);
            // atomic, on an owner with many
            var         servLoc  = Cache.ServiceLocator;
            ILexEntry   entry    = null;
            ICmResource resource = null;
            ILexSense   sense1   = null;
            ILexSense   sense2   = null;
            ILexSense   sense3   = null;
            IMoForm     form1    = null;
            IMoForm     form2    = null;

            UndoableUnitOfWorkHelper.Do("Undo stuff", "Redo stuff", m_actionHandler, () =>
            {
                resource = servLoc.GetInstance <ICmResourceFactory>().Create();
                Cache.LangProject.LexDbOA.ResourcesOC.Add(resource);
                entry  = servLoc.GetInstance <ILexEntryFactory>().Create();
                sense1 = servLoc.GetInstance <ILexSenseFactory>().Create();
                entry.SensesOS.Add(sense1);
                sense2 = servLoc.GetInstance <ILexSenseFactory>().Create();
                entry.SensesOS.Add(sense2);
                sense3 = servLoc.GetInstance <ILexSenseFactory>().Create();
                entry.SensesOS.Add(sense3);
                form1 = servLoc.GetInstance <IMoStemAllomorphFactory>().Create();
                entry.AlternateFormsOS.Add(form1);
                form2 = servLoc.GetInstance <IMoStemAllomorphFactory>().Create();
                entry.AlternateFormsOS.Add(form2);
            }
                                        );
            Assert.AreEqual(LexDbTags.kflidResources, resource.OwningFlid);           // owning collection
            Assert.AreEqual(LexEntryTags.kflidSenses, sense1.OwningFlid);             // owning sequence
            Assert.AreEqual(LexEntryTags.kflidSenses, sense2.OwningFlid);             // owning sequence, middle
            Assert.AreEqual(LexEntryTags.kflidSenses, sense3.OwningFlid);             // owning sequence, last
            Assert.AreEqual(LexEntryTags.kflidAlternateForms, form1.OwningFlid);      // owning sequence, not longest
            Assert.AreEqual(LexEntryTags.kflidAlternateForms, form2.OwningFlid);      // owning sequence, not longest or first
        }
        private static void WriteAffixAlloFeatsElement(XmlWriter writer, IMoForm form, string propsText)
        {
            var sallo = form as IMoAffixAllomorph;

            if (sallo == null)
            {
                return;                  // the form could be an IMoAffixProcess in which case there are no MsEnvFeatures.
            }
            IFsFeatStruc fsFeatStruc = sallo.MsEnvFeaturesOA;

            if (fsFeatStruc != null && !fsFeatStruc.IsEmpty)
            {
                writer.WriteStartElement("affixAlloFeats");
                WriteFeatureStructureNodes(writer, fsFeatStruc, fsFeatStruc.Hvo);
                writer.WriteEndElement();                 //affixAlloFeats
            }
            else
            {               // There's no overt stem name on this allomorph, but there might be overt stem names
                // on other allomorphs in this lexical entry.  This allomorph, then, cannot bear any
                // of the features of these other stem names.  If so, there will be a property named
                // NotStemNameddd or NotStemNamedddNotStemNamedddd, etc.
                WriteNotAffixAlloFeatsElement(writer, form.Cache, propsText);
            }
        }
Exemplo n.º 29
0
		private static void HandleInfix(ILexEntry entry, IMoForm allomorph)
		{
			const string sDefaultPostionEnvironment = "/#[C]_";
			var infix = allomorph as IMoAffixAllomorph;
			if (infix == null)
				return; // something's wrong...
			var cache = entry.Cache;
			var env = PhEnvironment.DefaultInfixEnvironment(cache, sDefaultPostionEnvironment);
			if (env != null)
			{
				infix.PositionRS.Add(env);
			}
			else
			{
				// create default infix position environment
				var strFact = cache.TsStrFactory;
				var defAnalWs = entry.Services.WritingSystems.DefaultAnalysisWritingSystem;
				var ppd = cache.LangProject.PhonologicalDataOA;
				env = new PhEnvironment();
				ppd.EnvironmentsOS.Add(env);
				env.StringRepresentation = strFact.MakeString(sDefaultPostionEnvironment, cache.DefaultVernWs);
				env.Description.set_String(defAnalWs.Handle, strFact.MakeString("Default infix position environment", defAnalWs.Handle));
				env.Name.set_String(defAnalWs.Handle, strFact.MakeString("After stem-initial consonant", defAnalWs.Handle));
				infix.PositionRS.Add(env);
			}
		}
Exemplo n.º 30
0
        public string ExtractTextSegmentAsANA(ISegment segment)
        {
            BadGlosses.Clear();
            var sb   = new StringBuilder();
            var sbA  = new StringBuilder();
            var sbD  = new StringBuilder();
            var sbC  = new StringBuilder();
            var sbFD = new StringBuilder();
            var sbP  = new StringBuilder();
            var sbW  = new StringBuilder();

            foreach (IAnalysis analysis in segment.AnalysesRS)
            {
                var wordform = analysis.Wordform;
                if (wordform == null)
                {
                    continue;
                }
                sbA.Clear();
                sbA.Append("\\a ");
                sbD.Clear();
                sbD.Append("\\d ");
                sbC.Clear();
                sbC.Append("\\cat ");
                sbFD.Clear();
                sbFD.Append("\\fd ");
                sbP.Clear();
                sbP.Append("\\p ");
                sbW.Clear();
                sbW.Append("\\w ");
                var shape = wordform.Form.VernacularDefaultWritingSystem.Text;
                sbW.Append(shape + "\n");
                int ambiguities = wordform.AnalysesOC.Count;
                if (ambiguities > 1)
                {
                    String ambigs = "%" + ambiguities + "%";
                    sbA.Append(ambigs);
                    sbD.Append(ambigs);
                    sbC.Append(ambigs);
                    sbFD.Append(ambigs);
                    sbP.Append(ambigs);
                }
                foreach (IWfiAnalysis wfiAnalysis in wordform.AnalysesOC)
                {
                    IWfiMorphBundle previous      = null;
                    IMoForm         previousMorph = null;
                    var             maxMorphs     = wfiAnalysis.MorphBundlesOS.Count;
                    int             i             = 0;
                    foreach (IWfiMorphBundle bundle in wfiAnalysis.MorphBundlesOS)
                    {
                        var msa = bundle.MsaRA;
                        if (msa == null)
                        {
                            continue;
                        }
                        var morph = bundle.MorphRA;
                        if (morph == null)
                        {
                            continue;
                        }
                        if (msa is IMoStemMsa && !IsAttachedClitic(morph.MorphTypeRA.Guid, maxMorphs))
                        {
                            if (previous == null)
                            {
                                sbA.Append("< ");
                            }
                            else
                            {
                                if (previousMorph.MorphTypeRA.IsPrefixishType ||
                                    previousMorph.MorphTypeRA.Guid == MoMorphTypeTags.kguidMorphProclitic)
                                {
                                    sbA.Append(" < ");
                                }
                            }
                        }
                        if (msa is IMoStemMsa && !IsAttachedClitic(morph.MorphTypeRA.Guid, maxMorphs))
                        {
                            var cat = msa.PartOfSpeechForWsTSS(Cache.DefaultAnalWs).Text;
                            sbA.Append(cat + " ");
                        }
                        else if (i > 0)
                        {
                            sbA.Append(" ");
                        }
                        if (morph != null)
                        {
                            sbD.Append(morph.Form.VernacularDefaultWritingSystem.Text);
                        }
                        var sense = bundle.SenseRA;
                        if (sense == null)
                        {                         // a sense can be missing from a bundle if the bundle is built by the parser filer
                            var entryOfMsa = (ILexEntry)msa.Owner;
                            sense = entryOfMsa.SensesOS.FirstOrDefault(s => s.MorphoSyntaxAnalysisRA == msa);
                            if (sense != null)
                            {
                                HandleSense(sbA, sbFD, sense);
                            }
                            else if (morph != null)
                            {
                                var entry  = (ILexEntry)morph.Owner;
                                var sense2 = entry.SensesOS.FirstOrDefault();
                                if (sense2 == null)
                                {
                                    sbA.Append("missing_sense");
                                }
                                else
                                {
                                    HandleSense(sbA, sbFD, sense2);
                                }
                            }
                        }
                        else
                        {
                            HandleSense(sbA, sbFD, sense);
                        }
                        if (msa is IMoStemMsa && !IsAttachedClitic(morph.MorphTypeRA.Guid, maxMorphs))
                        {
                            sbA.Append(" ");
                            var next = wfiAnalysis.MorphBundlesOS.ElementAtOrDefault(i + 1);
                            if (next == null)
                            {
                                sbA.Append(">");
                            }
                            else
                            {
                                var nextMorph = next.MorphRA;
                                if (nextMorph == null ||
                                    nextMorph.MorphTypeRA.IsSuffixishType ||
                                    nextMorph.MorphTypeRA.Guid == MoMorphTypeTags.kguidMorphEnclitic)
                                {
                                    sbA.Append(">");
                                }
                            }
                        }
                        sbP.Append(bundle.Guid.ToString());
                        previous      = bundle;
                        previousMorph = morph;
                        i++;
                        if (i < maxMorphs)
                        {
                            sbD.Append("-");
                            sbFD.Append("=");
                            sbP.Append("=");
                        }
                    }
                    sbC.Append(GetOrComputeWordCategory(wfiAnalysis));
                    if (ambiguities > 1)
                    {
                        sbA.Append("%");
                        sbD.Append("%");
                        sbC.Append("%");
                        sbFD.Append("%");
                        sbP.Append("%");
                    }
                }
                sbA.Append("\n");
                sbD.Append("\n");
                sbC.Append("\n");
                sbFD.Append("\n");
                sbP.Append("\n");
                sbW.Append("\n");
                sb.Append(sbA.ToString());
                sb.Append(sbD.ToString());
                sb.Append(sbC.ToString());
                sb.Append(sbP.ToString());
                sb.Append(sbFD.ToString());
                sb.Append(sbW.ToString());
            }
            return(sb.ToString());
        }
Exemplo n.º 31
0
		private static void WriteStemNameElement(XmlWriter writer, IMoForm form, string props)
		{
			var sallo = form as IMoStemAllomorph;
			Debug.Assert(sallo != null);
			IMoStemName sn = sallo.StemNameRA;
			if (sn != null)
			{
				writer.WriteStartElement("stemName");
				writer.WriteAttributeString("id", sn.Hvo.ToString(CultureInfo.InvariantCulture));
				writer.WriteString(sn.Name.BestAnalysisAlternative.Text);
				writer.WriteEndElement(); //stemName
			}
			else
			{   // There's no overt stem name on this allomorph, but there might be overt stem names
				// on other allomorphs in this lexical entry.  This allomorph, then, cannot bear any
				// of the features of these other stem names.  If so, there will be a property named
				// NotStemNameddd or NotStemNamedddNotStemNamedddd, etc.
				WriteNotStemNameElement(writer, props);
			}
		}
Exemplo n.º 32
0
		// Swap values of various attributes between an existing form that is a LexemeForm and
		// a newly created one. Includes adding the new one to the alternate forms of the entry, and
		// the id of the old one to a map of things to delete.
		private void SwapFormValues(ILexEntry entry, IMoForm origForm, IMoForm newForm, int typeHvo, Set<int> idsToDel)
		{
			entry.AlternateFormsOS.Add(newForm);
			origForm.SwapReferences(newForm);
			var muaOrigForm = origForm.Form;
			var muaNewForm = newForm.Form;
			muaNewForm.MergeAlternatives(muaOrigForm);
			newForm.MorphTypeRA = m_cache.ServiceLocator.GetInstance<IMoMorphTypeRepository>().GetObject(typeHvo);
			idsToDel.Add(origForm.Hvo);
		}
		private void SetSelectedObject()
		{
			foreach (ListViewItem lvi in m_lvAlloOptions.Items)
			{
				if (lvi.Selected)
				{
					m_allomorph = lvi.Tag as IMoForm;
					SetBottomMessage();
				}
			}
			btnOK.Enabled = true;
		}
Exemplo n.º 34
0
		private string GetFormWithMarkers(IMoForm alt, int ws)
		{
			if (IsVoiceWritingSystem(ws))
			{
				// The alternative contains a file path. We need to adjust and export and copy the file.
				// We also don't want to decorate the file name with any affix markers.
				// Form is MultiUnicode, so we don't need to check for a single run.
				var internalPath = alt.Form.get_String(ws).Text;
				// usually this will be unchanged, but it is pathologically possible that the file name conflicts.
				var writePath = ExportFile(internalPath,
					Path.Combine(FdoFileHelper.GetMediaDir(m_cache.LangProject.LinkedFilesRootDir), internalPath),
					"audio");
				return writePath;
			}
			return alt.GetFormWithMarkers(ws);
		}
Exemplo n.º 35
0
		/// <summary>
		/// This replaces a MoForm belonging to this LexEntry with another one, presumably
		/// changing from a stem to an affix or vice versa.  (A version of this code originally
		/// appeared in MorphTypeAtomicLauncher.cs, but is also needed for LIFT import.)
		/// </summary>
		/// <param name="mfOld"></param>
		/// <param name="mfNew"></param>
		public void ReplaceMoForm(IMoForm mfOld, IMoForm mfNew)
		{
			// save the environment references, if any.
			int[] envs = null;
			if (mfOld is IMoStemAllomorph)
				envs = (mfOld as IMoStemAllomorph).PhoneEnvRC.HvoArray;
			else if (mfOld is IMoAffixAllomorph)
				envs = (mfOld as IMoAffixAllomorph).PhoneEnvRC.HvoArray;
			else
				envs = new int[0];

			int[] inflClasses = null;
			if (mfOld is IMoAffixForm)
				inflClasses = (mfOld as IMoAffixForm).InflectionClassesRC.HvoArray;
			else
				inflClasses = new int[0];

			// if we are converting from one affix form to another, we should save the morph type
			int oldAffMorphType = 0;
			if (mfOld is IMoAffixForm)
				oldAffMorphType = mfOld.MorphTypeRAHvo;

			if (mfOld.OwningFlid == (int)LexEntry.LexEntryTags.kflidLexemeForm)
			{
				this.AlternateFormsOS.Append(mfNew); // trick to get it to be in DB so SwapReferences works
			}
			else
			{
				// insert the new form in the right location in the sequence.
				Debug.Assert(mfOld.OwningFlid == (int)LexEntry.LexEntryTags.kflidAlternateForms);
				bool fInserted = false;
				for (int i = 0; i < this.AlternateFormsOS.Count; ++i)
				{
					if (this.AlternateFormsOS.HvoArray[i] == mfOld.Hvo)
					{
						this.AlternateFormsOS.InsertAt(mfNew, i);
						fInserted = true;
						break;
					}
				}
				if (!fInserted)
					this.AlternateFormsOS.Append(mfNew);		// This should NEVER happen, but...
			}
			mfOld.SwapReferences(mfNew.Hvo);
			MultiUnicodeAccessor muaOrigForm = mfOld.Form;
			MultiUnicodeAccessor muaNewForm = mfNew.Form;
			muaNewForm.MergeAlternatives(muaOrigForm);
			if (mfOld.OwningFlid == (int)LexEntry.LexEntryTags.kflidLexemeForm)
				this.LexemeFormOA = mfNew;		// do we need to remove it from AlternateFormsOS??
			else
				this.AlternateFormsOS.Remove(mfOld);
			// restore the environment references, if any.
			foreach (int hvo in envs)
			{
				if (mfNew is IMoStemAllomorph)
					(mfNew as IMoStemAllomorph).PhoneEnvRC.Add(hvo);
				else if (mfNew is IMoAffixAllomorph)
					(mfNew as IMoAffixAllomorph).PhoneEnvRC.Add(hvo);
			}

			foreach (int hvo in inflClasses)
			{
				if (mfNew is IMoAffixForm)
					(mfNew as IMoAffixForm).InflectionClassesRC.Add(hvo);
			}

			if (oldAffMorphType != 0 && mfNew is IMoAffixForm)
				mfNew.MorphTypeRAHvo = oldAffMorphType;
		}
Exemplo n.º 36
0
		private void SwapValues(ILexEntry entry, IMoForm origForm, IMoForm newForm, IMoMorphType type,
			List<IMoMorphSynAnalysis> rgmsaOld)
		{
			DataTree dtree = Slice.ContainingDataTree;
			int idx = Slice.IndexInContainer;
			dtree.DoNotRefresh = true;	// don't let the datatree repeatedly redraw itself...
			entry.ReplaceMoForm(origForm, newForm);
			newForm.MorphTypeRA = type;
			entry.ReplaceObsoleteMsas(rgmsaOld);
			// Dispose of any obsolete slices: new ones will replace them automatically in a moment
			// when the datatree is redrawn.
			foreach (Slice slice in Slice.ContainingDataTree.Slices.ToArray())
			{
				if (slice.IsDisposed)
					continue;
				if (slice.Object is IMoMorphSynAnalysis && rgmsaOld.Contains(slice.Object as IMoMorphSynAnalysis))
					slice.Dispose();
				else if (slice is MSAReferenceComboBoxSlice)
					slice.Dispose();
			}
			// now fix the record list, since it may be showing MoForm dependent columns (e.g. MorphType, Homograph, etc...)
			dtree.FixRecordList();
			dtree.DoNotRefresh = false;
			Slice sliceT = dtree.Slices[idx];
			if (sliceT != null && sliceT is MorphTypeAtomicReferenceSlice)
			{
				// When the new slice is created, the launch button is placed in the middle of
				// the slice rather than at the end.  This fiddling with the slice width seems
				// to fix that.  Then setting the index restores focus to the new slice.
				sliceT.Width += 1;
				sliceT.Width -= 1;
				dtree.GotoNextSliceAfterIndex(idx - 1);
			}
		}
Exemplo n.º 37
0
			private static MorphItem GetMorphItem(IMoForm mf, ITsString tssName, ILexSense sense, ITsString tssSense,
				ILexEntryRef ler, int hvoLexEntry, ILexEntryInflType inflType)
			{
				IMoMorphSynAnalysis msa = null;
				string msaText = null;
				if (sense != null)
				{
					msa = sense.MorphoSyntaxAnalysisRA;
					if (msa != null)
						msaText = msa.InterlinearName;
				}

				var options = new MorphItemOptions
				{
					HvoMoForm = HvoOrZero(mf),
					HvoEntry = ler != null ? hvoLexEntry : 0,
					TssName = tssName,
					HvoSense = HvoOrZero(sense),
					SenseName = tssSense != null ? tssSense.Text : null,
					HvoMsa = HvoOrZero(msa),
					MsaName = msaText,
					InflType = inflType,
					EntryRef = ler,
				};
				return new MorphItem(options);
			}
Exemplo n.º 38
0
			private void AddMorphItemToList(IMoForm mf, ILexEntryRef ler, ITsString tssSense, ILexSense sense,
											IWritingSystem wsAnalysis, ITsString tssName, int hvoLexEntry)
			{
				MorphItem mi;
				if (tssSense.Length == 0)
				{
					// If it doesn't have a gloss (e.g., from Categorised Entry), use the definition.
					tssSense = sense.Definition.get_String(wsAnalysis.Handle);
				}
				mi = GetMorphItem(mf, tssName, sense, tssSense, ler, hvoLexEntry, null);
				m_morphItems.Add(mi);
			}
Exemplo n.º 39
0
			/// <summary>
			///
			/// </summary>
			/// <param name="mf"></param>
			/// <param name="le">the entry used in the morph bundle (for sense info). typically
			/// this is an owner of hvoMorph, but if not, it most likely has hvoMorph linked as its variant.</param>
			private void BuildMorphItemsFromEntry(IMoForm mf, ILexEntry le, ILexEntryRef ler)
			{
				int hvoLexEntry = 0;
				if (le != null)
					hvoLexEntry = le.Hvo;
				ITsString tssName = null;
				if (le != null)
				{
					tssName = LexEntryVc.GetLexEntryTss(m_caches.MainCache, le.Hvo, m_wsVern, ler);
				}
				else
				{
					// looks like we're not in a good state, so just use the form for the name.
					int wsActual;
					tssName = mf.Form.GetAlternativeOrBestTss(m_wsVern, out wsActual);
				}
				var wsAnalysis = m_caches.MainCache.ServiceLocator.WritingSystemManager.Get(m_caches.MainCache.DefaultAnalWs);

				// Populate morphItems with Sense/Msa level specifics
				if (le != null)
				{
					foreach (ILexSense sense in le.AllSenses)
					{
						var tssSense = sense.Gloss.get_String(wsAnalysis.Handle);
						if (ler != null)
						{
							MorphItem mi;
							var lexEntryInflTypes =
									ler.VariantEntryTypesRS.Where(let => let is ILexEntryInflType).Select(let => let as ILexEntryInflType);
							if (lexEntryInflTypes.Count() > 0)
							{
								foreach (var inflType in lexEntryInflTypes)
								{
									var glossAccessor = (tssSense.Length == 0 ? (IMultiStringAccessor) sense.Definition : sense.Gloss);
									tssSense = MorphServices.MakeGlossOptionWithInflVariantTypes(inflType, glossAccessor, wsAnalysis);
									mi = GetMorphItem(mf, tssName, sense, tssSense, ler, hvoLexEntry, inflType);
									m_morphItems.Add(mi);
								}
							}
							else
							{
								AddMorphItemToList(mf, ler, tssSense, sense, wsAnalysis, tssName, hvoLexEntry);
							}
						}
						else
						{
							AddMorphItemToList(mf, null, tssSense, sense, wsAnalysis, tssName, hvoLexEntry);
						}
					}
				}
				// Make a LexEntry level item
				m_morphItems.Add(new MorphItem(mf.Hvo, ler != null ? hvoLexEntry : 0, tssName));
			}
Exemplo n.º 40
0
		protected void ConvertAffixAlloFeats(XmlDocument doc, XmlNode node, IMoForm form, XmlNode tempNode)
		{
			MoAffixAllomorph sallo = form as MoAffixAllomorph;
			IFsFeatStruc fsFeatStruc = sallo.MsEnvFeaturesOA;
			if (fsFeatStruc != null && !fsFeatStruc.IsEmpty)
			{
				tempNode = CreateXmlElement(doc, "affixAlloFeats", node);
				CreateFeatureStructureNodes(doc, tempNode, fsFeatStruc, fsFeatStruc.Hvo);
			}
			else
			{   // There's no overt stem name on this allomorph, but there might be overt stem names
				// on other allomorphs in this lexical entry.  This allomorph, then, cannot bear any
				// of the features of these other stem names.  If so, there will be a property named
				// NotStemNameddd or NotStemNamedddNotStemNamedddd, etc.
				CreateNotAffixAlloFeatsElement(doc, node, tempNode);
			}
		}
Exemplo n.º 41
0
		bool CheckForFormDataLoss(IMoForm origForm, int toClsid)
		{
			string msg = null;
			switch (origForm.ClassID)
			{
				case MoAffixAllomorphTags.kClassId:
					IMoAffixAllomorph affAllo = origForm as IMoAffixAllomorph;
					bool loseEnv = affAllo.PhoneEnvRC.Count > 0;
					bool losePos = affAllo.PositionRS.Count > 0;
					bool loseGram = affAllo.MsEnvFeaturesOA != null || affAllo.MsEnvPartOfSpeechRA != null;
					if (loseEnv && losePos && loseGram)
						msg = LexEdStrings.ksConvertFormLoseEnvInfixLocGramInfo;
					else if (loseEnv && losePos)
						msg = LexEdStrings.ksConvertFormLoseEnvInfixLoc;
					else if (loseEnv && loseGram)
						msg = LexEdStrings.ksConvertFormLoseEnvGramInfo;
					else if (losePos && loseGram)
						msg = LexEdStrings.ksConvertFormLoseInfixLocGramInfo;
					else if (loseEnv)
						msg = LexEdStrings.ksConvertFormLoseEnv;
					else if (losePos)
						msg = LexEdStrings.ksConvertFormLoseInfixLoc;
					else if (loseGram)
						msg = LexEdStrings.ksConvertFormLoseGramInfo;
					break;

				case MoAffixProcessTags.kClassId:
					msg = LexEdStrings.ksConvertFormLoseRule;
					break;

				case MoStemAllomorphTags.kClassId:
					// not implemented
					break;
			}

			if (msg != null)
			{
				DialogResult result = MessageBox.Show(msg, LexEdStrings.ksConvertFormLoseCaption,
					MessageBoxButtons.YesNo, MessageBoxIcon.Warning);
				return result == DialogResult.Yes;
			}

			return true;
		}
Exemplo n.º 42
0
		// Swap values of various attributes between an existing form that is a LexemeForm and
		// a newly created one. Includes adding the new one to the alternate forms of the entry, and
		// the id of the old one to a map of things to delete.
		private void SwapFormValues(ILexEntry entry, IMoForm origForm, IMoForm newForm, int typeHvo, Set<int> idsToDel)
		{
			entry.AlternateFormsOS.Append(newForm); // trick to get it to be in DB so SwapReferences works
			origForm.SwapReferences(newForm.Hvo);
			MultiUnicodeAccessor muaOrigForm = origForm.Form;
			MultiUnicodeAccessor muaNewForm = newForm.Form;
			muaNewForm.MergeAlternatives(muaOrigForm);
			newForm.MorphTypeRAHvo = typeHvo;
			idsToDel.Add(origForm.Hvo);
		}
Exemplo n.º 43
0
		public LAllomorph(IMoForm allo) : base(allo.Hvo)
		{
			m_type = allo.ClassID;
			m_form = allo.Form.BestVernacularAlternative;
		}
Exemplo n.º 44
0
		/// <summary>
		/// Swap all references to this MoForm to use the new one
		/// </summary>
		/// <param name="newForm">the hvo of the new MoForm</param>
		public void SwapReferences(IMoForm newForm)
		{
			foreach (var adhocProhib in Services.GetInstance<IMoAlloAdhocProhibRepository>().AllInstances())
			{
				if (adhocProhib.FirstAllomorphRA == this)
					adhocProhib.FirstAllomorphRA = newForm;

				for (int i = 0; i < adhocProhib.RestOfAllosRS.Count; i++)
				{
					if (adhocProhib.RestOfAllosRS[i] == this)
						adhocProhib.RestOfAllosRS.Replace(i, 1, new IMoForm[] { newForm });
				}
			}

			foreach (var mb in Services.GetInstance<IWfiMorphBundleRepository>().AllInstances())
			{
				if (mb.MorphRA == this)
					mb.MorphRA = newForm;
			}
		}
Exemplo n.º 45
0
			internal void CreateNewEntry(bool fCreateNow, out ILexEntry le, out IMoForm allomorph, out ILexSense sense)
			{
				CheckDisposed();

				le = null;
				allomorph = null;
				sense = null;
				FdoCache cache = m_caches.MainCache;
				int hvoMorph = m_caches.DataAccess.get_ObjectProp(m_hvoMorph, ktagSbMorphForm);
				ITsString tssForm = m_caches.DataAccess.get_MultiStringAlt(hvoMorph,
																		   ktagSbNamedObjName, m_sandbox.RawWordformWs);
				// If we don't have a form or it isn't in a current vernacular writing system, give up.
				if (tssForm == null || tssForm.Length == 0 ||
					!WritingSystemServices.GetAllWritingSystems(m_caches.MainCache, "all vernacular", null, 0, 0).Contains(
						 TsStringUtils.GetWsOfRun(tssForm, 0)))
				{
					return;
				}
				var entryComponents = BuildEntryComponents();
				bool fCreateAllomorph = false;
				bool fCreatedEntry = false;
				if (fCreateNow)
				{
				   // just create a new entry based on the given information.
				   le  = cache.ServiceLocator.GetInstance<ILexEntryFactory>().Create(entryComponents);
				}
				else
				{
					using (InsertEntryDlg dlg = InsertEntryNow.CreateInsertEntryDlg(fCreateNow))
					{
						dlg.SetDlgInfo(cache, m_sandbox.GetFullMorphForm(m_hvoMorph), m_sandbox.Mediator);
						dlg.TssGloss = entryComponents.GlossAlternatives.FirstOrDefault();
						foreach (ITsString tss in entryComponents.GlossAlternatives.Skip(1))
							dlg.SetInitialGloss(TsStringUtils.GetWsAtOffset(tss, 0), tss);
						dlg.ChangeUseSimilarToCreateAllomorph();

						if (fCreateNow)
						{
							// just create a new entry based on the given information.
							dlg.CreateNewEntry();
						}
						else
						{
							// bring up the dialog so the user can make further decisions.
							Form mainWnd = m_sandbox.FindForm();
							// Making the form active fixes LT-2344 & LT-2345.
							// I'm (RandyR) not sure what adverse impact might show up by doing this.
							mainWnd.Activate();
							// The combo should be automatically hidden by activating another window.
							// That works on Windows but not on Mono (reported as https://bugzilla.xamarin.com/show_bug.cgi?id=15848).
							// So to prevent the combo hanging around on Mono, we hide it explicitly here.
							HideCombo();
							dlg.SetHelpTopic("khtpInsertEntryFromInterlinear");
							if (dlg.ShowDialog(mainWnd) == DialogResult.OK)
								fCreateAllomorph = true;
						}
						dlg.GetDialogInfo(out le, out fCreatedEntry);
						if (!fCreatedEntry && !fCreateAllomorph)
							return;
					}
				}
				if (fCreateAllomorph && le.SensesOS.Count > 0)
					sense = le.SensesOS[0];

				allomorph = MorphServices.FindMatchingAllomorph(le, tssForm);
				bool fCreatedAllomorph = false;
				if (allomorph == null)
				{
					using (UndoableUnitOfWorkHelper undoHelper = new UndoableUnitOfWorkHelper(
						cache.ServiceLocator.GetInstance<IActionHandler>(), ITextStrings.ksUndoAddAllomorphToSimilarEntry, ITextStrings.ksRedoAddAllomorphToSimilarEntry))
					{
						allomorph = MorphServices.MakeMorph(le, tssForm);
						fCreatedAllomorph = true;
						Debug.Assert(allomorph != null);
						undoHelper.RollBack = false;
					}
					if (fCreatedEntry)
					{
						// Making the entry and the allomorph should feel like one indivisible action to the end user.
						((IActionHandlerExtensions) cache.ActionHandlerAccessor).MergeLastTwoUnitsOfWork();
					}
				}
				var allomorph1 = allomorph;
				var le1 = le;
				var sense1 = sense;
				if (fCreatedEntry || fCreatedAllomorph)
				{
					// If we've created something, then updating the sandbox needs to be undone as a unit with it,
					// so the sandbox isn't left showing something uncreated.
					UndoableUnitOfWorkHelper.Do("join me up", "join me up", cache.ActionHandlerAccessor,
						() => UpdateMorphEntry(allomorph1, le1, sense1));
					((IActionHandlerExtensions)cache.ActionHandlerAccessor).MergeLastTwoUnitsOfWork();
				}
				else
				{
					// Updating the sandbox doesn't need to be undoable, no real data changes.
					UpdateMorphEntry(allomorph1, le1, sense1);
				}
			}
Exemplo n.º 46
0
		private void WriteAllFormsWithMarkers(TextWriter w, string wrappingElementName, string attrs,
			string elementName, IMoForm alt)
		{
			if (alt == null || alt.Form == null || alt.Form.StringCount == 0)
				return;
			if (!String.IsNullOrEmpty(wrappingElementName))
			{
				if (String.IsNullOrEmpty(attrs))
					w.WriteLine("<{0}>", wrappingElementName);
				else
					w.WriteLine("<{0} {1}>", wrappingElementName, attrs);
			}
			for (var i = 0; i < alt.Form.StringCount; ++i)
			{
				int ws;
				var tssForm = alt.Form.GetStringFromIndex(i, out ws);
				var sLang = m_cache.WritingSystemFactory.GetStrFromWs(ws);
				var internalPath = alt.Form.get_String(ws).Text;
				// a deleted audio link can leave an empty string - it's the file path
				// Chorus sometimes tells users "Report this problem to the developers" when missing this element
				// Users should refresh and try to send/receive again.
				if (!String.IsNullOrEmpty(internalPath))
					w.WriteLine("<{0} lang=\"{1}\"><text>{2}</text></{0}>", elementName,
						MakeSafeAndNormalizedAttribute(sLang), MakeSafeAndNormalizedXml(GetFormWithMarkers(alt, ws)));
			}
			if (!String.IsNullOrEmpty(wrappingElementName))
				w.WriteLine("</{0}>", wrappingElementName);
		}
Exemplo n.º 47
0
		private IMoMorphSynAnalysis GetMsaAndMoForm(ILexEntry entry, Guid slotType, string pos, out IMoForm form)
		{
			IMoMorphSynAnalysis msa;
			if (slotType == MoMorphTypeTags.kguidMorphStem)
			{
				form = Cache.ServiceLocator.GetInstance<IMoStemAllomorphFactory>().Create();
				var stemMsa = Cache.ServiceLocator.GetInstance<IMoStemMsaFactory>().Create();
				msa = stemMsa;
				entry.MorphoSyntaxAnalysesOC.Add(msa);
				stemMsa.PartOfSpeechRA = MakePartOfSpeech(pos);
			}
			else
			{
				form = Cache.ServiceLocator.GetInstance<IMoAffixAllomorphFactory>().Create();
				var affixMsa = Cache.ServiceLocator.GetInstance<IMoInflAffMsaFactory>().Create();
				msa = affixMsa;
				entry.MorphoSyntaxAnalysesOC.Add(msa);
				affixMsa.PartOfSpeechRA = MakePartOfSpeech(pos);
			}
			return msa;
		}
Exemplo n.º 48
0
			private void GetMorphInfo(out ITsString tssForm, out ITsString tssFullForm, out IMoForm morphReal, out IMoMorphType morphType)
			{
				morphReal = null;
				int hvoMorph = m_caches.DataAccess.get_ObjectProp(m_hvoMorph, ktagSbMorphForm);
				var hvoMorphReal = m_caches.RealHvo(hvoMorph);
				if (hvoMorphReal != 0)
					morphReal = m_caches.MainCache.ServiceLocator.GetInstance<IMoFormRepository>().GetObject(hvoMorphReal);
				ISilDataAccess sda = m_caches.DataAccess;
				tssForm = m_caches.DataAccess.get_MultiStringAlt(hvoMorph, ktagSbNamedObjName, m_sandbox.RawWordformWs);
				tssFullForm = m_sandbox.GetFullMorphForm(m_hvoMorph);
				string fullForm = tssFullForm.Text;
				morphType = null;
				if (morphReal != null)
				{
					morphType = morphReal.MorphTypeRA;
				}
				else
				{
					// if we don't have a form then we can't derive a type. (cf. LT-1621)
					if (string.IsNullOrEmpty(fullForm))
					{
						morphType = null;
					}
					else
					{
						// Find the type for this morpheme
						int clsidForm;
						string fullFormTmp = fullForm;
						morphType = MorphServices.FindMorphType(m_caches.MainCache, ref fullFormTmp, out clsidForm);
					}
				}
			}
Exemplo n.º 49
0
		private static void HandleInfix(ILexEntry entry, IMoForm allomorph)
		{
			const string sDefaultPostionEnvironment = "/#[C]_";
			IMoAffixAllomorph infix = allomorph as IMoAffixAllomorph;
			if (infix == null)
				return; // something's wrong...
			FdoCache cache = entry.Cache;
			int defaultInfixPositionHvo = PhEnvironment.DefaultInfixEnvironment(cache, sDefaultPostionEnvironment);
			if (defaultInfixPositionHvo > 0)
				infix.PositionRS.Append(defaultInfixPositionHvo);
			else
			{
				// create default infix position environment
				IPhPhonData ppd = cache.LangProject.PhonologicalDataOA;
				PhEnvironment env = new PhEnvironment();
				ppd.EnvironmentsOS.Append(env);
				env.StringRepresentation.Text = sDefaultPostionEnvironment;
				env.Description.AnalysisDefaultWritingSystem.Text = "Default infix position environment";
				env.Name.AnalysisDefaultWritingSystem = "After stem-initial consonant";
				cache.PropChanged(null, PropChangeType.kpctNotifyAll, ppd.Hvo, (int)PhPhonData.PhPhonDataTags.kflidEnvironments, ppd.EnvironmentsOS.Count - 1, 1, 0);
				infix.PositionRS.Append(env);
			}
		}
Exemplo n.º 50
0
			/// <summary>
			/// Update the sandbox cache to reflect a choice of the real MoForm and the
			/// entry indicated by the FdoCache hvos passed.
			/// </summary>
			internal void UpdateMorphEntry(IMoForm moFormReal, ILexEntry entryReal, ILexSense senseReal,
				ILexEntryInflType inflType = null)
			{
				CheckDisposed();

				bool fDirty = m_sandbox.Caches.DataAccess.IsDirty();
				bool fApproved = !m_sandbox.UsingGuess;
				bool fHasApprovedWordGloss = m_sandbox.HasWordGloss() && (fDirty || fApproved);
				bool fHasApprovedWordCat = m_sandbox.HasWordCat() && (fDirty || fApproved);

				var undoAction = new UpdateMorphEntryAction(m_sandbox, m_hvoMorph); // before changes.

				// Make a new morph, if one does not already exist, corresponding to the
				// selected item.  Its form must match what is already displayed.  Store it as
				// the new value.
				int hvoMorph = m_sandbox.CreateSecondaryAndCopyStrings(InterlinLineChoices.kflidMorphemes, moFormReal.Hvo,
					MoFormTags.kflidForm);
				m_caches.DataAccess.SetObjProp(m_hvoMorph, ktagSbMorphForm, hvoMorph);
				m_caches.DataAccess.PropChanged(m_rootb,
					(int)PropChangeType.kpctNotifyAll, m_hvoMorph, ktagSbMorphForm, 0,
					1, 1);

				// Try to establish the sense.  Call this before SetSelectedEntry and LoadSecDataForEntry.
				// reset cached gloss, since we should establish the sense according to the real sense or real entry.
				m_caches.DataAccess.SetObjProp(m_hvoMorph, ktagSbMorphGloss, 0);
				var morphEntry = moFormReal.Owner as ILexEntry;
				ILexSense realDefaultSense = m_sandbox.EstablishDefaultSense(m_hvoMorph, morphEntry, senseReal, inflType);
				// Make and install a secondary object to correspond to the real LexEntry.
				// (The zero says we are not guessing any more, since the user selected this entry.)

				m_sandbox.LoadSecDataForEntry(morphEntry, senseReal != null ? senseReal : realDefaultSense,
					m_hvoSbWord, m_caches.DataAccess as IVwCacheDa,
					m_wsVern, m_hvoMorph, 0, m_caches.MainCache.MainCacheAccessor, null);
				m_caches.DataAccess.PropChanged(m_rootb,
					(int)PropChangeType.kpctNotifyAll, m_hvoMorph, ktagSbMorphEntry, 0,
					1, WasReal());

				// Notify any delegates that the selected Entry changed.
				m_sandbox.SetSelectedEntry(entryReal);
				// fHasApprovedWordGloss: if an approved word gloss already exists -- don't replace it
				// fHasApprovedWordCat: if an approved word category already exists -- don't replace it
				CopyLexEntryInfoToMonomorphemicWordGlossAndPos(!fHasApprovedWordGloss, !fHasApprovedWordCat);
				undoAction.GetNewVals();
				// If we're doing this as part of something undoable, and then undo it, we should undo this also,
				// especially so the Sandbox isn't left displaying something whose creation has been undone. (FWR-3547)
				if (m_caches.MainCache.ActionHandlerAccessor.CurrentDepth > 0)
				{
					m_caches.MainCache.ActionHandlerAccessor.AddAction(undoAction);
				}
				return;
			}
Exemplo n.º 51
0
		private void SetupAllomorphsData(out IMoForm firstAllomorphOut,
			out ILexEntry firstEntryWithAllomorphOut,
			out ILexEntry firstEntryWithoutAllomorphOut,
			out List<ILexEntry> entriesWithoutAllomorphsOut,
			out List<IMoForm> allomorphsOut)
		{
			IMoForm firstAllomorph = null;
			ILexEntry firstEntryWithAllomorph = null;
			ILexEntry firstEntryWithoutAllomorph = null;
			List<ILexEntry> entriesWithoutAllomorphs = new List<ILexEntry>();
			List<IMoForm> allomorphs = new List<IMoForm>();
			UndoableUnitOfWorkHelper.Do("SetupAllomorphsData", "SetupAllomorphsData",
				Cache.ActionHandlerAccessor, () =>
			{
				// find an entry with allomorphs.
				foreach (ILexEntry entry in Cache.LangProject.LexDbOA.Entries)
				{
					if (entry.AlternateFormsOS.Count > 0)
					{
						allomorphs.AddRange(entry.AlternateFormsOS);
						if (firstAllomorph == null)
						{
							firstEntryWithAllomorph = entry;
							firstAllomorph = entry.AlternateFormsOS[0];
							var newAllomorph = Cache.ServiceLocator.GetInstance<IMoStemAllomorphFactory>().Create();
							entry.AlternateFormsOS.Add(newAllomorph);
							allomorphs.Add(newAllomorph);
						}
					}
					else
					{
						entriesWithoutAllomorphs.Add(entry);
						if (firstEntryWithoutAllomorph == null)
							firstEntryWithoutAllomorph = entry;
					}
				}
			});
			firstAllomorphOut = firstAllomorph;
			firstEntryWithAllomorphOut = firstEntryWithAllomorph;
			firstEntryWithoutAllomorphOut = firstEntryWithoutAllomorph;
			entriesWithoutAllomorphsOut = entriesWithoutAllomorphs;
			allomorphsOut = allomorphs;
		}
Exemplo n.º 52
0
		protected void ConvertStemName(XmlDocument doc, XmlNode node, IMoForm form, XmlNode tempNode)
		{
			MoStemAllomorph sallo = form as MoStemAllomorph;
			IMoStemName sn = sallo.StemNameRA;
			if (sn != null)
			{
				tempNode = CreateXmlElement(doc, "stemName", node);
				CreateXmlAttribute(doc, "id", sn.Hvo.ToString(), tempNode);
				tempNode.InnerXml = CreateEntities(sn.Name.BestAnalysisAlternative.Text);
			}
			else
			{   // There's no overt stem name on this allomorph, but there might be overt stem names
				// on other allomorphs in this lexical entry.  This allomorph, then, cannot bear any
				// of the features of these other stem names.  If so, there will be a property named
				// NotStemNameddd or NotStemNamedddNotStemNamedddd, etc.
				tempNode = CreateNotStemNameElement(doc, node, tempNode);
			}
		}
Exemplo n.º 53
0
		internal static XElement CreateAllomorphElement(string name, IMoForm form, IMoMorphSynAnalysis msa, bool circumfix)
		{
			var elem = new XElement(name, new XAttribute("id", form.Hvo), new XAttribute("type", GetMorphTypeString(circumfix ? MoMorphTypeTags.kguidMorphCircumfix : form.MorphTypeRA.Guid)),
				new XElement("Form", circumfix ? form.OwnerOfClass<ILexEntry>().HeadWord.Text : form.GetFormWithMarkers(form.Cache.DefaultVernWs)),
				new XElement("LongName", form.LongName));
			elem.Add(CreateMorphemeElement(msa));
			return elem;
		}
Exemplo n.º 54
0
		private void SwapAllomorphWithLexeme(ILexEntry entry, IMoForm allomorph, Command cmd)
		{
			using (UndoRedoCommandHelper undoRedoTask = new UndoRedoCommandHelper(m_dataEntryForm.Cache, cmd))
			{
				entry.AlternateFormsOS.InsertAt(entry.LexemeFormOA, allomorph.IndexInOwner);
				entry.LexemeFormOA = allomorph;
			}
		}
Exemplo n.º 55
0
		public void Initialize(IMoForm rootObj, int rootFlid, FdoCache cache)
		{
			CheckDisposed();

			Debug.Assert(rootObj is IMoAffixAllomorph || rootObj is IMoStemAllomorph);
			Debug.Assert(cache != null && m_fdoCache == null);
			Cache = cache;
			m_tsf = cache.TsStrFactory;
			ResetValidator();
			m_wsVern = m_fdoCache.ServiceLocator.WritingSystems.DefaultVernacularWritingSystem.Handle;
			m_rootObj = rootObj;
			m_rootFlid = rootFlid;
			if (m_rootb == null)
				MakeRoot();
		}
Exemplo n.º 56
0
		private void SwapAllomorphWithLexeme(ILexEntry entry, IMoForm allomorph, Command cmd)
		{
			UndoableUnitOfWorkHelper.Do(cmd.UndoText, cmd.RedoText, entry, () =>
			{
				entry.AlternateFormsOS.Insert(allomorph.IndexInOwner, entry.LexemeFormOA);
				entry.LexemeFormOA = allomorph;
			});
		}
Exemplo n.º 57
0
		private static void WriteAffixAlloFeatsElement(XmlWriter writer, IMoForm form, string propsText)
		{
			var sallo = form as IMoAffixAllomorph;
			if (sallo == null)
				return;  // the form could be an IMoAffixProcess in which case there are no MsEnvFeatures.
			IFsFeatStruc fsFeatStruc = sallo.MsEnvFeaturesOA;
			if (fsFeatStruc != null && !fsFeatStruc.IsEmpty)
			{
				writer.WriteStartElement("affixAlloFeats");
				WriteFeatureStructureNodes(writer, fsFeatStruc, fsFeatStruc.Hvo);
				writer.WriteEndElement(); //affixAlloFeats
			}
			else
			{   // There's no overt stem name on this allomorph, but there might be overt stem names
				// on other allomorphs in this lexical entry.  This allomorph, then, cannot bear any
				// of the features of these other stem names.  If so, there will be a property named
				// NotStemNameddd or NotStemNamedddNotStemNamedddd, etc.
				WriteNotAffixAlloFeatsElement(writer, form.Cache, propsText);
			}
		}
Exemplo n.º 58
0
		void SelectNewFormSlice(IMoForm newForm)
		{
			foreach (Slice slice in m_dataEntryForm.Slices)
			{
				if (slice.Object.Hvo == newForm.Hvo)
				{
					m_dataEntryForm.ActiveControl = slice;
					break;
				}
			}
		}
Exemplo n.º 59
0
 public LAllomorph(IMoForm allo) : base(allo.Hvo)
 {
     m_type = allo.ClassID;
     m_form = allo.Form.BestVernacularAlternative;
 }
Exemplo n.º 60
0
		private void WriteAlternateForm(TextWriter w, IMoForm alt)
		{
			w.Write("<variant");
			WriteLiftDates(w, alt);
			switch (alt.ClassID)
			{
				case MoStemAllomorphTags.kClassId:
					{
						var stemAllo = alt as IMoStemAllomorph;
						Debug.Assert(stemAllo != null);
						var refer = GetProperty(alt, "LiftRefAttribute") as string;
						if (!String.IsNullOrEmpty(refer))
							w.Write(" ref=\"{0}\"", MakeSafeAndNormalizedAttribute(refer));
						w.WriteLine(">");
						WriteAllFormsWithMarkers(w, null, null, "form", alt);
						foreach (var env in stemAllo.PhoneEnvRC)
							WritePhEnvironment(w, env);
					}
					break;
				case MoAffixAllomorphTags.kClassId:
					{
						var affixAllo = alt as IMoAffixAllomorph;
						Debug.Assert(affixAllo != null);
						var refer = GetProperty(alt, "LiftRefAttribute") as string;
						if (!String.IsNullOrEmpty(refer))
							w.Write(" ref=\"{0}\"", MakeSafeAndNormalizedAttribute(refer));
						w.WriteLine(">");
						WriteAllFormsWithMarkers(w, null, null, "form", alt);
						foreach (var env in affixAllo.PhoneEnvRC)
							WritePhEnvironment(w, env);
					}
					break;
				case MoAffixProcessTags.kClassId:
					{
						w.WriteLine(">");
						WriteAllFormsWithMarkers(w, null, null, "form", alt);
					}
					break;
			}
			if (alt.MorphTypeRA != null)
				WriteTrait(w, RangeNames.sDbMorphTypesOA, alt.MorphTypeRA.Name, m_wsEn);
			WriteCustomFields(w, alt);
			WriteLiftResidue(w, alt);
			w.WriteLine("</variant>");
		}