public void SetDlgInfo(FdoCache cache, Mediator mediator, ICmObject owner) { CheckDisposed(); m_cache = cache; m_owner = owner; m_helpTopic = "khtpDataNotebook-InsertRecordDlg"; m_helpTopicProvider = mediator.HelpTopicProvider; if (m_helpTopicProvider != null) // Will be null when running tests { m_helpProvider.HelpNamespace = m_helpTopicProvider.HelpFile; m_helpProvider.SetHelpKeyword(this, m_helpTopicProvider.GetHelpString(m_helpTopic)); m_helpProvider.SetHelpNavigator(this, HelpNavigator.Topic); } IVwStylesheet stylesheet = FontHeightAdjuster.StyleSheetFromMediator(mediator); m_titleTextBox.StyleSheet = stylesheet; m_titleTextBox.WritingSystemFactory = m_cache.WritingSystemFactory; m_titleTextBox.WritingSystemCode = m_cache.DefaultAnalWs; AdjustControlAndDialogHeight(m_titleTextBox, m_titleTextBox.PreferredHeight); m_typeCombo.StyleSheet = stylesheet; m_typeCombo.WritingSystemFactory = m_cache.WritingSystemFactory; m_typeCombo.WritingSystemCode = m_cache.DefaultAnalWs; AdjustControlAndDialogHeight(m_typeCombo, m_typeCombo.PreferredHeight); ICmPossibilityList recTypes = m_cache.LanguageProject.ResearchNotebookOA.RecTypesOA; m_typePopupTreeManager = new PossibilityListPopupTreeManager(m_typeCombo, m_cache, mediator, recTypes, cache.DefaultAnalWs, false, this); m_typePopupTreeManager.LoadPopupTree(m_cache.ServiceLocator.GetObject(RnResearchNbkTags.kguidRecObservation).Hvo); // Ensure that we start out focused in the Title text box. See FWR-2731. m_titleTextBox.Select(); }
public void Init(Mediator mediator, XmlNode configurationNode, ICmObject sourceObject) { CheckDisposed(); m_cache = sourceObject.Cache; // Find the sense we want examples for, which depends on the kind of source object. if (sourceObject is ILexExampleSentence) { m_les = sourceObject as ILexExampleSentence; m_owningSense = (ILexSense)m_les.Owner; } else if (sourceObject is ILexSense) { m_owningSense = sourceObject as ILexSense; } else { throw new ArgumentException("Invalid object type for sourceObject."); } m_mediator = mediator; m_configurationNode = configurationNode; helpProvider.SetHelpNavigator(this, HelpNavigator.Topic); helpProvider.SetShowHelp(this, true); if (m_mediator.HelpTopicProvider != null) { helpProvider.HelpNamespace = m_mediator.HelpTopicProvider.HelpFile; helpProvider.SetHelpKeyword(this, m_mediator.HelpTopicProvider.GetHelpString(m_helpTopic)); btnHelp.Enabled = true; } AddConfigurableControls(); }
public void Initialize(ICmObject rootObj, int rootFlid, FdoCache cache, string displayNameProperty, XCore.Mediator mediator, string displayWs) { CheckDisposed(); m_displayWs = displayWs; base.Initialize(rootObj, rootFlid, cache, displayNameProperty, mediator); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Insert a new check result annotation at its correct position in the list. /// </summary> /// <param name="startRef">beginning reference note refers to</param> /// <param name="endRef">ending reference note refers to</param> /// <param name="beginObject">id of beginning object note refers to</param> /// <param name="endObject">id of ending object note refers to</param> /// <param name="checkId">The check id.</param> /// <param name="bldrQuote">Para builder to use for the cited text paragraph</param> /// <param name="bldrDiscussion">Para builder to use to build the Discussion /// paragraph</param> /// <returns>note inserted into annotation list</returns> /// ------------------------------------------------------------------------------------ public IScrScriptureNote InsertErrorAnnotation(BCVRef startRef, BCVRef endRef, ICmObject beginObject, ICmObject endObject, Guid checkId, StTxtParaBldr bldrQuote, StTxtParaBldr bldrDiscussion) { return InsertNote(startRef, endRef, beginObject, endObject, checkId, -1, 0, 0, bldrQuote, bldrDiscussion, null, null, GetInsertIndexForRef(startRef)); }
/// <summary> /// Construct one, using the "part ref" element (caller) that /// invoked the "slice" node that specified this editor. /// </summary> /// <param name="caller"></param> /// <param name="node"></param> public SummarySlice(ICmObject obj, XmlNode caller, XmlNode node, StringTable stringTbl) : base() { string paramType = XmlUtils.GetOptionalAttributeValue(node.ParentNode, "paramType"); if (paramType == "LiteralString") { // Instead of the parameter being a layout name, it is literal text which will be // the whole contents of the slice, with standard properties. string text = XmlUtils.GetManditoryAttributeValue(caller, "label"); if (stringTbl != null) text = stringTbl.LocalizeAttributeValue(text); m_view = new LiteralLabelView(text, this); m_fLiteralString = true; } else { string layout = XmlUtils.GetOptionalAttributeValue(caller, "param"); if (layout == null) layout = XmlUtils.GetManditoryAttributeValue(node, "layout"); m_view = new SummaryXmlView(obj.Hvo, layout, stringTbl, this); } UserControl mainControl = new UserControl(); m_view.Dock = DockStyle.Left; m_view.LayoutSizeChanged += new EventHandler(m_view_LayoutSizeChanged); mainControl.Height = m_view.Height; Control = mainControl; m_commandControl = new SummaryCommandControl(this); m_commandControl.Dock = DockStyle.Fill; m_commandControl.Visible = XmlUtils.GetOptionalBooleanAttributeValue(caller, "commandVisible", false); mainControl.Controls.Add(m_commandControl); mainControl.Dock = DockStyle.Fill; mainControl.Controls.Add(m_view); }
public void RunMacro(ICmObject target, int targetField, int wsId, int startOffset, int length) { var example = target as ILexExampleSentence ?? target.OwnerOfClass<ILexExampleSentence>(); var sense = example.OwnerOfClass<ILexSense>(); var entry = sense.Entry; if (!(entry.LexemeFormOA is IMoStemAllomorph)) { MessageBox.Show("This macro only works on stems"); return; } var newEntry = entry.Services.GetInstance<ILexEntryFactory>().Create(); var newSense = entry.Services.GetInstance<ILexSenseFactory>().Create(); newEntry.SensesOS.Add(newSense); newSense.ExamplesOS.Add(example); // moves the chosen example // Would be nice to use CopyObject, but currently not public newEntry.LexemeFormOA = entry.Services.GetInstance<IMoStemAllomorphFactory>().Create(); foreach (var ws in entry.LexemeFormOA.Form.AvailableWritingSystemIds) newEntry.LexemeFormOA.Form.set_String(ws, entry.LexemeFormOA.Form.get_String(ws)); foreach (var ws in sense.Gloss.AvailableWritingSystemIds) newSense.Gloss.set_String(ws, sense.Gloss.get_String(ws)); foreach (var ws in sense.Definition.AvailableWritingSystemIds) newSense.Definition.set_String(ws, sense.Gloss.get_String(ws)); // Enhance JohnT: maybe there is more stuff we want to copy? //Now make it a subentry var ler = entry.Services.GetInstance<ILexEntryRefFactory>().Create(); newEntry.EntryRefsOS.Add(ler); ler.RefType = LexEntryRefTags.krtComplexForm; // must be a complex form to be a subentry ler.ComponentLexemesRS.Add(entry); ler.PrimaryLexemesRS.Add(entry); }
/// <summary> /// Validate the object, before it goes into the collection, /// as it may not be in the DB yet. /// </summary> /// <param name="obj">Object to validate.</param> /// <returns>The same object as was being validated, but with a good ID.</returns> protected ICmObject ValidateObject(ICmObject obj) { Debug.Assert(m_fdoCache != null); if (obj.Hvo == (int)CmObject.SpecialHVOValues.kHvoOwnerPending) (obj as CmObject).InitNew(m_fdoCache); return obj; }
public GhostLexRefLauncher(ICmObject obj, XmlNode configNode) { m_obj = obj; m_configurationNode = configNode; // Makes the rest of the control look like content, though empty. BackColor = System.Drawing.SystemColors.Window; }
/// <summary> /// Construct one. For the index, pass -1 for a collection and -2 for atomic. /// </summary> public AddObjectEventArgs(ICmObject newby, int flid, int index) { if (newby == null) throw new ArgumentNullException("newby"); ObjectAdded = newby; Flid = flid; m_index = index; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Constructor. /// </summary> /// <param name="cache">FDO cache.</param> /// <param name="obj">CmObject that is being displayed.</param> /// <param name="flid">The field identifier for the attribute we are displaying.</param> /// <param name="persistenceProvider">The persistence provider.</param> /// ------------------------------------------------------------------------------------ public MSAReferenceComboBoxSlice(FdoCache cache, ICmObject obj, int flid, IPersistenceProvider persistenceProvider) : base(new UserControl(), cache, obj, flid) { IWritingSystem defAnalWs = m_cache.ServiceLocator.WritingSystems.DefaultAnalysisWritingSystem; m_persistProvider = persistenceProvider; m_tree = new TreeCombo(); m_tree.WritingSystemFactory = cache.WritingSystemFactory; m_tree.Font = new System.Drawing.Font(defAnalWs.DefaultFontName, 10); if (!Application.RenderWithVisualStyles) m_tree.HasBorder = false; m_tree.WritingSystemCode = defAnalWs.Handle; // We embed the tree combo in a layer of UserControl, so it can have a fixed width // while the parent window control is, as usual, docked 'fill' to work with the splitter. m_tree.Dock = DockStyle.Left; m_tree.Width = 240; m_tree.DropDown += m_tree_DropDown; Control.Controls.Add(m_tree); m_tree.SizeChanged += m_tree_SizeChanged; if (m_cache != null) m_cache.DomainDataByFlid.AddNotification(this); m_treeBaseWidth = m_tree.Width; // m_tree has sensible PreferredHeight once the text is set, UserControl does not. //we need to set the Height after m_tree.Text has a value set to it. Control.Height = m_tree.PreferredHeight; }
public void Init(Mediator mediator, XmlNode configurationNode, ICmObject sourceObject) { CheckDisposed(); m_cache = sourceObject.Cache; // Find the sense owning our LexExampleSentence if (sourceObject is LexExampleSentence) { m_les = sourceObject as LexExampleSentence; m_owningSense = LexSense.CreateFromDBObject(m_cache, m_les.OwnerHVO); } else if (sourceObject is LexSense) { m_owningSense = sourceObject as ILexSense; } else { throw new ArgumentException("Invalid object type for sourceObject."); } m_mediator = mediator; m_configurationNode = configurationNode; AddConfigurableControls(); m_virtFlidReference = BaseVirtualHandler.GetInstalledHandlerTag(m_cache, "CmBaseAnnotation", "Reference"); }
public void Initialize(ICmObject rootObj, int rootFlid, string rootFieldName, FdoCache cache, string displayNameProperty, Mediator mediator, string displayWs) { CheckDisposed(); m_displayWs = displayWs; Initialize(rootObj, rootFlid, rootFieldName, cache, displayNameProperty, mediator); }
protected BsonDocument GetCustomFieldValues(FdoCache cache, ICmObject obj, string objectType = "entry") { // The objectType parameter is used in the names of the custom fields (and nowhere else). var convertCustomField = new ConvertFdoToMongoCustomField(cache, new LfMerge.Logging.NullLogger()); Dictionary<string, LfConfigFieldBase> lfCustomFieldList = new Dictionary<string, LfConfigFieldBase>(); return convertCustomField.GetCustomFieldsForThisCmObject(obj, objectType, _listConverters, lfCustomFieldList); }
protected InterlinearExporter(FdoCache cache, XmlWriter writer, ICmObject objRoot, InterlinLineChoices lineChoices, InterlinVc vc) : base(null, cache.MainCacheAccessor, objRoot.Hvo) { m_cache = cache; m_writer = writer; m_flidStTextTitle = m_cache.MetaDataCacheAccessor.GetFieldId("StText", "Title", false); m_flidStTextSource = m_cache.MetaDataCacheAccessor.GetFieldId("StText", "Source", false); m_vc = vc; SetTextTitleAndMetadata(objRoot as IStText); // Get morphtype information that we need later. (plus stuff we don't...) See LT-8288. IMoMorphType mmtStem; IMoMorphType mmtPrefix; IMoMorphType mmtSuffix; IMoMorphType mmtInfix; IMoMorphType mmtBoundStem; IMoMorphType mmtSimulfix; IMoMorphType mmtSuprafix; m_cache.ServiceLocator.GetInstance<IMoMorphTypeRepository>().GetMajorMorphTypes( out mmtStem, out mmtPrefix, out mmtSuffix, out mmtInfix, out mmtBoundStem, out m_mmtProclitic, out m_mmtEnclitic, out mmtSimulfix, out mmtSuprafix); m_wsManager = m_cache.ServiceLocator.WritingSystemManager; m_repoObj = m_cache.ServiceLocator.GetInstance<ICmObjectRepository>(); }
public List<XmlImportData.PendingLink> LinksForField(ICmObject owner, int flid) { List<XmlImportData.PendingLink> linksForOwner; if (!m_lookupLinks.TryGetValue(owner, out linksForOwner)) return new List<XmlImportData.PendingLink>(); // nothing is linked from this owner. return (from link in linksForOwner where link.FieldInformation.FieldId == flid select link).ToList(); }
/// <summary> /// We want the persistence provider, and the easiest way to get it is to get all /// this other stuff we don't need or use. /// </summary> /// <param name="cache"></param> /// <param name="editor"></param> /// <param name="flid"></param> /// <param name="node"></param> /// <param name="obj"></param> /// <param name="stringTbl"></param> /// <param name="persistenceProvider"></param> /// <param name="ws"></param> public PhEnvStrRepresentationSlice(FdoCache cache, string editor, int flid, System.Xml.XmlNode node, ICmObject obj, StringTable stringTbl, IPersistenceProvider persistenceProvider, int ws) : base(new StringRepSliceView(obj.Hvo), obj, StringRepSliceVc.Flid) { m_persistenceProvider = persistenceProvider; }
/// <summary> /// The user selected an item; now we actually need a LexEntryRef. /// </summary> /// <param name="hvoNew"></param> private void AddItem(ICmObject newObj) { CheckDisposed(); bool fForVariant = XmlUtils.GetOptionalBooleanAttributeValue(m_configurationNode, "forVariant", false); string sUndo, sRedo; if (fForVariant) { sUndo = LexEdStrings.ksUndoVariantOf; sRedo = LexEdStrings.ksRedoVariantOf; } else { sUndo = LexEdStrings.ksUndoAddComponent; sRedo = LexEdStrings.ksRedoAddComponent; } try { UndoableUnitOfWorkHelper.Do(sUndo, sRedo, m_obj, () => { ILexEntry ent = m_obj as ILexEntry; // Adapted from part of DtMenuHandler.AddNewLexEntryRef. ILexEntryRef ler = ent.Services.GetInstance<ILexEntryRefFactory>().Create(); ent.EntryRefsOS.Add(ler); if (fForVariant) { // The slice this is part of should only be displayed for lex entries with no VariantEntryRefs. Debug.Assert(ent.VariantEntryRefs.Count() == 0); ler.VariantEntryTypesRS.Add(ent.Cache.LangProject.LexDbOA.VariantEntryTypesOA.PossibilitiesOS[0] as ILexEntryType); ler.RefType = LexEntryRefTags.krtVariant; ler.HideMinorEntry = 0; } else { // The slice this is part of should only be displayed for lex entries with no ComplexEntryRefs. Debug.Assert(ent.ComplexFormEntryRefs.Count() == 0); //ler.ComplexEntryTypesRS.Append(ent.Cache.LangProject.LexDbOA.ComplexEntryTypesOA.PossibilitiesOS[0].Hvo); ler.RefType = LexEntryRefTags.krtComplexForm; ler.HideMinorEntry = 0; // LT-10928 // Logic similar to this is in EntrySequenceReferenceLauncher.AddNewObjectsToProperty() // (when LER already exists so slice is not ghost) ler.PrimaryLexemesRS.Add(newObj); // Since it's a new LER, we can't know it to be a derivative, so by default it is visible. // but do NOT do that here, it's now built into the process of adding it to PrimaryLexemes, // and we don't want to do it twice. // ler.ShowComplexFormsInRS.Add(newObj); ent.ChangeRootToStem(); } // Must do this AFTER setting the RefType (so dependent virtual properties can be updated properly) ler.ComponentLexemesRS.Add(newObj); }); } catch (ArgumentException) { MessageBoxes.ReportLexEntryCircularReference((ILexEntry)m_obj, newObj, true); } }
/// <summary> /// add any subitems to the tree. Note! This assumes that the list has been preloaded /// (e.g., using PreLoadList), so it bypasses normal load operations for speed purposes. /// Withoug preloading, it took almost 19,000 queries to start FW showing semantic domain /// list. With preloading it reduced the number to 200 queries. /// </summary> /// <param name="obj"></param> /// <param name="parentsCollection"></param> protected override void AddSubNodes(ICmObject obj, TreeNodeCollection parentsCollection) { var pss = (ICmPossibility) obj; foreach (var subPss in pss.SubPossibilitiesOS) { AddTreeNode(subPss, parentsCollection); } }
/// <summary> /// Report failure to make target a component of parent. If startedFromComplex is true, the user is looking /// at parent, and tried to make target a component. Otherwise, the user is looking at target, and /// tried to make parent a complex form. /// </summary> public static void ReportLexEntryCircularReference(ILexEntry parent, ICmObject target, bool startedFromComplex) { var itemString = target is ILexEntry ? FwCoreDlgs.ksEntry : FwCoreDlgs.ksSense; var msgTemplate = startedFromComplex ? FwCoreDlgs.ksComponentIsComponent : FwCoreDlgs.ksComplexFormIsComponent; var startedFrom = startedFromComplex ? parent.HeadWord.Text : target.ShortName; var msg = String.Format(msgTemplate, itemString, startedFrom); MessageBox.Show(Form.ActiveForm, msg, FwCoreDlgs.ksWhichIsComponent, MessageBoxButtons.OK, MessageBoxIcon.Error); }
/// <summary> /// Initialize the launcher. /// </summary> /// <param name="cache"></param> /// <param name="obj"></param> /// <param name="flid"></param> /// <param name="fieldName"></param> public override void Initialize(FdoCache cache, ICmObject obj, int flid, string fieldName, IPersistenceProvider persistProvider, Mediator mediator, string displayNameProperty, string displayWs) { CheckDisposed(); base.Initialize(cache, obj, flid, fieldName, persistProvider, mediator, displayNameProperty, displayWs); m_msaInflectionFeatureListDlgLauncherView.Init(mediator, obj as IFsFeatStruc); }
#pragma warning restore 0414 public ReversalIndexEntryFormSlice(FdoCache cache, string editor, int flid, XmlNode node, ICmObject obj, StringTable stringTbl, IPersistenceProvider persistenceProvider, int ws) : base(obj, flid, WritingSystemServices.kwsAllReversalIndex, 0, false, true, true) { m_configNode = node; m_stringTbl = stringTbl; m_persistProvider = persistenceProvider; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Create a new (empty) StFootnote and add it to the owner's collection. /// This method provides a way to create a new footnote object in the db for any generic /// CmObject owner. /// </summary> /// <param name="owner">The owner CmObject.</param> /// <param name="flid">The flid of the owner's footnote collection.</param> /// <param name="footnoteIndex">Index to insert the footnote at in the collection.</param> /// <returns>the new footnote object</returns> /// ------------------------------------------------------------------------------------ public StFootnote(ICmObject owner, int flid, int footnoteIndex) : this() { // add this new (empty) footnote to the owner's collection FdoOwningSequence<IStFootnote> footnotes = new FdoOwningSequence<IStFootnote>(owner.Cache, owner.Hvo, flid); footnotes.InsertAt(this, footnoteIndex); }
/// ----------------------------------------------------------------------------------- /// <summary> /// Initializes a new instance of the <see cref="AtomicReferenceSlice"/> class. /// </summary> /// ----------------------------------------------------------------------------------- public AtomicReferenceSlice(FdoCache cache, ICmObject obj, int flid, XmlNode configurationNode, IPersistenceProvider persistenceProvider, Mediator mediator, StringTable stringTbl) : base(cache, obj, flid, configurationNode, persistenceProvider, mediator, stringTbl) { m_sda = m_cache.MainCacheAccessor; m_sda.AddNotification(this); }
/// <summary> /// Initialize the launcher. /// </summary> /// <param name="cache"></param> /// <param name="obj"></param> /// <param name="flid"></param> /// <param name="fieldName"></param> public override void Initialize(FdoCache cache, ICmObject obj, int flid, string fieldName, IPersistenceProvider persistProvider, Mediator mediator, string displayNameProperty, string displayWs) { CheckDisposed(); base.Initialize(cache, obj, flid, fieldName, persistProvider, mediator, displayNameProperty, displayWs); m_msaDlglauncherView.Init(mediator, obj as MoMorphSynAnalysis); }
/// <summary> /// Constructor invoked via the editor="customWithParams" slice XML configuration /// </summary> /// <param name="cache"></param> /// <param name="editor"></param> /// <param name="flid"></param> /// <param name="node"></param> /// <param name="obj"></param> /// <param name="stringTbl"></param> /// <param name="persistenceProvider"></param> /// <param name="ws"></param> public BasicIPASymbolSlice(FdoCache cache, string editor, int flid, System.Xml.XmlNode node, ICmObject obj, StringTable stringTbl, IPersistenceProvider persistenceProvider, int ws) : base(obj, flid, ws) { var phoneme = (IPhPhoneme)m_obj; phoneme.BasicIPASymbolChanged += UpdatePhoneme; }
private ILexEntry MakeCompound(string lf, string gloss, ICmObject[] components) { var result = MakeEntry(lf, gloss); var ler = MakeLexEntryRef(result, LexEntryRefTags.krtComplexForm); foreach (var obj in components) ler.ComponentLexemesRS.Add(obj); return result; }
public PhoneEnvReferenceSlice(FdoCache cache, ICmObject obj, int flid, XmlNode configurationNode, IPersistenceProvider persistenceProvider, Mediator mediator, StringTable stringTbl) : base(cache, obj, flid,configurationNode, persistenceProvider, mediator, stringTbl) { Debug.Assert(obj is MoAffixAllomorph || obj is MoStemAllomorph); m_persistenceProvider = persistenceProvider; }
public override void Initialize(FdoCache cache, ICmObject obj, int flid, string fieldName, IPersistenceProvider persistProvider, Mediator mediator, string displayNameProperty, string displayWs) { CheckDisposed(); base.Initialize(cache, obj, flid, fieldName, persistProvider, mediator, displayNameProperty, displayWs); m_atomicRefView.Initialize(obj, flid, cache, displayNameProperty, mediator); }
/// <summary> /// Constructor. /// </summary> /// <param name="cache">FDO cache.</param> /// <param name="obj">CmObject that is being displayed.</param> /// <param name="flid">The field identifier for the attribute we are displaying.</param> public MSAReferenceComboBoxSlice(FdoCache cache, ICmObject obj, int flid, IPersistenceProvider persistenceProvider, Mediator mediator) : base(new UserControl(), cache, obj, flid) { m_mediator = mediator; m_persistProvider = persistenceProvider; m_tree = new TreeCombo(); m_tree.WritingSystemFactory = cache.LanguageWritingSystemFactoryAccessor; m_tree.Font = new System.Drawing.Font(cache.LangProject.DefaultAnalysisWritingSystemFont, 10); if (!Application.RenderWithVisualStyles) m_tree.HasBorder = false; //Set the stylesheet and writing system information so that the font size for the IVwStylesheet stylesheet = FontHeightAdjuster.StyleSheetFromMediator(mediator); m_tree.WritingSystemCode = cache.LangProject.DefaultAnalysisWritingSystem; m_tree.StyleSheet = stylesheet; // We embed the tree combo in a layer of UserControl, so it can have a fixed width // while the parent window control is, as usual, docked 'fill' to work with the splitter. m_tree.Dock = DockStyle.Left; m_tree.Width = 240; m_tree.DropDown += new EventHandler(m_tree_DropDown); Control.Controls.Add(m_tree); m_tree.SizeChanged += new EventHandler(m_tree_SizeChanged); if (m_MSAPopupTreeManager == null) { ICmPossibilityList list = m_cache.LangProject.PartsOfSpeechOA; int ws = m_cache.LangProject.DefaultAnalysisWritingSystem; m_tree.WritingSystemCode = ws; m_MSAPopupTreeManager = new MSAPopupTreeManager(m_tree, m_cache, list, ws, true, mediator, (Form)mediator.PropertyTable.GetValue("window")); m_MSAPopupTreeManager.AfterSelect += new TreeViewEventHandler(m_MSAPopupTreeManager_AfterSelect); m_MSAPopupTreeManager.Sense = m_obj as ILexSense; m_MSAPopupTreeManager.PersistenceProvider = m_persistProvider; } try { m_handlingMessage = true; m_MSAPopupTreeManager.MakeTargetMenuItem(); //m_MSAPopupTreeManager.LoadPopupTree(0); } finally { m_handlingMessage = false; } if (m_cache != null) { m_sda = m_cache.MainCacheAccessor; m_sda.AddNotification(this); } m_treeBaseWidth = m_tree.Width; Control.Height = m_tree.PreferredHeight; // m_tree has sensible PreferredHeight once the text is set, UserControl does not. //we need to set the Height after m_tree.Text has a value set to it. }
private IPartOfSpeech CheckPos(string guid, ICmObject owner) { IPartOfSpeech pos; Assert.That(Cache.ServiceLocator.GetInstance<IPartOfSpeechRepository>().TryGetObject(new Guid(guid), out pos), Is.True, "expected POS should be created with the right guid"); Assert.That(pos.Owner, Is.EqualTo(owner), "POS should be created at the right place in the hierarchy"); return pos; }
/// <summary> /// Determine if the object really has data to be shown in the slice /// </summary> /// <param name="obj">object to check; should be an IFsFeatStruc</param> /// <returns>true if the feature structure has content in FeatureSpecs; false otherwise</returns> public static bool ShowSliceForVisibleIfData(XmlNode node, ICmObject obj) { //FDO.Cellar.IFsFeatStruc fs = obj as FDO.Cellar.IFsFeatStruc; int flid = GetFlid(node, obj); IFsFeatStruc fs; if (flid != 0) { fs = GetFeatureStructureFromMSA(obj, flid); } else { fs = obj as IFsFeatStruc; } if (fs != null) { if (fs.FeatureSpecsOC.Count > 0) { return(true); } } return(false); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Links to lexicon. /// </summary> /// ------------------------------------------------------------------------------------ internal void LinkToLexicon() { CheckDisposed(); int hvo = m_hvoSelected; if (hvo == 0 && m_rghvo != null && m_rghvo.Count > 0) { hvo = m_rghvo[0]; } // REVIEW: THIS SHOULD NEVER HAPPEN, BUT IF IT DOES, SHOULD WE TELL THE USER ANYTHING? if (hvo == 0) { return; } ICmObject cmo = m_cache.ServiceLocator.GetInstance <ICmObjectRepository>().GetObject(hvo); FwAppArgs link = new FwAppArgs(FwUtils.ksFlexAppName, m_cache.ProjectId.Handle, m_cache.ProjectId.ServerName, "lexiconEdit", cmo.Guid); Debug.Assert(m_mediator != null, "The program must pass in a mediator to follow a link in the same application!"); IApp app = (IApp)m_mediator.PropertyTable.GetValue("App"); app.HandleOutgoingLink(link); }
protected override void RemoveFromPropertyAt(int index, ICmObject oldObj) { string fieldName = m_obj.Cache.MetaDataCacheAccessor.GetFieldName(m_flid); switch (fieldName) { case "VisibleComplexFormEntries": ChangeItemsInLexEntryRefs(new [] { oldObj }, ler => ler.ShowComplexFormsInRS.Remove(m_obj)); break; case "Subentries": ChangeItemsInLexEntryRefs(new[] { oldObj }, ler => ler.PrimaryLexemesRS.Remove(m_obj)); break; case "VisibleComplexFormBackRefs": ((ILexEntryRef)oldObj).ShowComplexFormsInRS.Remove(m_obj); break; default: base.RemoveFromPropertyAt(index, oldObj); break; } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Inserts a note referencing the currently selected paragraph. /// </summary> /// <param name="noteType">Type of note</param> /// <param name="startRef">reference at beginning of selection</param> /// <param name="endRef">reference at end of selection</param> /// <param name="topObj">The object where quoted text begins.</param> /// <param name="bottomObj">The object where quoted text ends.</param> /// <param name="startOffset">The starting character offset.</param> /// <param name="endOffset">The ending character offset.</param> /// <param name="tssQuote">The text of the quote.</param> /// <returns>The inserted note</returns> /// ------------------------------------------------------------------------------------ public virtual IScrScriptureNote InsertNote(ICmAnnotationDefn noteType, BCVRef startRef, BCVRef endRef, ICmObject topObj, ICmObject bottomObj, int startOffset, int endOffset, ITsString tssQuote) { CheckDisposed(); int iPos; IScrBookAnnotations annotations = m_scr.BookAnnotationsOS[startRef.Book - 1]; StTxtParaBldr quoteParaBldr = new StTxtParaBldr(m_cache); quoteParaBldr.ParaStyleName = ScrStyleNames.Remark; quoteParaBldr.StringBuilder.ReplaceTsString(0, 0, tssQuote); IScrScriptureNote annotation = annotations.InsertNote(startRef, endRef, topObj, bottomObj, noteType.Guid, startOffset, endOffset, quoteParaBldr, null, null, null, out iPos); RegisterScrollCallBack(startRef.Book, iPos); // REVIEW: Do we need to create a synch record? return(annotation); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Determine where in the annotation list to insert a new annotation having the /// specified startRef, beginning object and beginning offset. /// </summary> /// <param name="startRef">The start ref.</param> /// <param name="beginObject">The begin object.</param> /// <param name="begOffset">The beg offset.</param> /// ------------------------------------------------------------------------------------ private int GetNewNotesInsertIndex(BCVRef startRef, ICmObject beginObject, int begOffset) { // Get the index within the book of the section containing the paragraph // containing the reference to which the new annotation corresponds. int iNewNoteSection; int iNewNotePara; GetLocationInfoForObj(beginObject, out iNewNoteSection, out iNewNotePara); IFdoOwningSequence <IScrScriptureNote> notes = NotesOS; int insertIndex = notes.Count; // Go backward through the list of existing annotations. for (int i = notes.Count - 1; i >= 0; i--) { IScrScriptureNote note = notes[i]; int iSect, iPara; GetLocationInfoForObj(note.BeginObjectRA, out iSect, out iPara); // If the annotation is for text that follows the text associated // with the new annotation we're adding, then decrement the index // of where to insert the new annotation. if (note.BeginRef > startRef || iSect > iNewNoteSection || (iSect == iNewNoteSection && iPara > iNewNotePara) || (iSect == iNewNoteSection && iPara == iNewNotePara && note.BeginOffset > begOffset)) { insertIndex--; } else { break; // found first spot for note } } return(insertIndex); }
protected void CreateMsaXmlElement(XmlNode node, XmlDocument doc, XmlNode morphNode, string sHvo) { XmlNode attr; // morphname contains the hvo of the msa attr = node.SelectSingleNode(sHvo); if (attr != null) { ICmObject obj = CmObject.CreateFromDBObject(m_cache, Convert.ToInt32(attr.Value)); switch (obj.GetType().Name) { default: throw new ApplicationException(String.Format("Invalid MSA type: {0}.", obj.GetType().Name)); case "MoStemMsa": IMoStemMsa stemMsa = obj as IMoStemMsa; CreateStemMsaXmlElement(doc, morphNode, stemMsa); break; case "MoInflAffMsa": IMoInflAffMsa inflMsa = obj as IMoInflAffMsa; CreateInflectionClasses(doc, morphNode); CreateInflMsaXmlElement(doc, morphNode, inflMsa); break; case "MoDerivAffMsa": IMoDerivAffMsa derivMsa = obj as IMoDerivAffMsa; CreateDerivMsaXmlElement(doc, morphNode, derivMsa); break; case "MoUnclassifiedAffixMsa": IMoUnclassifiedAffixMsa unclassMsa = obj as IMoUnclassifiedAffixMsa; CreateUnclassifedMsaXmlElement(doc, morphNode, unclassMsa); break; } } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Inserts a Scriture annotation for the book currently being imported. /// </summary> /// <param name="bcvStartReference">The starting BCV reference.</param> /// <param name="bcvEndReference">The ending BCV reference.</param> /// <param name="obj">The object being annotated (either a paragraph or a IScrBook)</param> /// <param name="bldr">The paragraph builder containing the guts of the annotation /// description</param> /// <param name="guidNoteType">The GUID representing the CmAnnotationDefn to use for /// the type</param> /// <returns>The newly created annotation</returns> /// ------------------------------------------------------------------------------------ public IScrScriptureNote InsertNote(int bcvStartReference, int bcvEndReference, ICmObject obj, StTxtParaBldr bldr, Guid guidNoteType) { bool fOpenedTransaction = false; if (m_cache.DatabaseAccessor != null && !m_cache.DatabaseAccessor.IsTransactionOpen()) { fOpenedTransaction = true; m_cache.DatabaseAccessor.BeginTrans(); } try { IScrScriptureNote note = m_annotations.InsertImportedNote( bcvStartReference, bcvEndReference, obj, obj, guidNoteType, bldr); m_suppressor.Dispose(); m_suppressor = null; m_cache.ActionHandlerAccessor.AddAction(new UndoImportObjectAction(note)); if (fOpenedTransaction) { m_cache.DatabaseAccessor.CommitTrans(); } m_suppressor = new SuppressSubTasks(m_cache); return(note); } catch { if (fOpenedTransaction) { m_cache.DatabaseAccessor.RollbackTrans(); } throw; } }
protected void ShowDialogAndConvert(int targetClassId) { // maybe there's a better way, but // this creates a temporary LexEntryRef in a temporary LexEntry var leFactory = m_cache.ServiceLocator.GetInstance <ILexEntryFactory>(); var entry = leFactory.Create(); var lerFactory = m_cache.ServiceLocator.GetInstance <ILexEntryRefFactory>(); var ler = lerFactory.Create(); entry.EntryRefsOS.Add(ler); m_flid = LexEntryRefTags.kflidVariantEntryTypes; m_obj = ler; var labels = ObjectLabel.CreateObjectLabels(m_cache, m_obj.ReferenceTargetCandidates(m_flid), "LexEntryType" /*"m_displayNameProperty*/, "best analysis"); using (SimpleListChooser chooser = GetChooser(labels, targetClassId)) { chooser.Cache = m_cache; chooser.SetObjectAndFlid(m_obj.Hvo, m_flid); chooser.SetHelpTopic(s_helpTopic); var tv = chooser.TreeView; DisableNodes(tv.Nodes, targetClassId); m_dlg.Visible = false; // no reason to show the utility dialog, too var res = chooser.ShowDialog(m_dlg.FindForm()); if (res == DialogResult.OK && chooser.ChosenObjects.Any()) { var itemsToChange = (from lexEntryType in chooser.ChosenObjects where lexEntryType.ClassID != targetClassId select lexEntryType).Cast <ILexEntryType>(); Convert(itemsToChange); } } entry.Delete(); // remove the temporary LexEntry m_dlg.Visible = true; // now we show the utility dialog again }
public void SetDlgInfo(FdoCache cache, Mediator mediator, ICmObject owner) { CheckDisposed(); m_cache = cache; m_owner = owner; m_helpTopic = "khtpDataNotebook-InsertRecordDlg"; m_helpTopicProvider = mediator.HelpTopicProvider; if (m_helpTopicProvider != null) // Will be null when running tests { m_helpProvider.HelpNamespace = m_helpTopicProvider.HelpFile; m_helpProvider.SetHelpKeyword(this, m_helpTopicProvider.GetHelpString(m_helpTopic)); m_helpProvider.SetHelpNavigator(this, HelpNavigator.Topic); } IVwStylesheet stylesheet = FontHeightAdjuster.StyleSheetFromMediator(mediator); m_titleTextBox.StyleSheet = stylesheet; m_titleTextBox.WritingSystemFactory = m_cache.WritingSystemFactory; m_titleTextBox.WritingSystemCode = m_cache.DefaultAnalWs; AdjustControlAndDialogHeight(m_titleTextBox, m_titleTextBox.PreferredHeight); m_typeCombo.StyleSheet = stylesheet; m_typeCombo.WritingSystemFactory = m_cache.WritingSystemFactory; m_typeCombo.WritingSystemCode = m_cache.DefaultAnalWs; AdjustControlAndDialogHeight(m_typeCombo, m_typeCombo.PreferredHeight); ICmPossibilityList recTypes = m_cache.LanguageProject.ResearchNotebookOA.RecTypesOA; m_typePopupTreeManager = new PossibilityListPopupTreeManager(m_typeCombo, m_cache, mediator, recTypes, cache.DefaultAnalWs, false, this); m_typePopupTreeManager.LoadPopupTree(m_cache.ServiceLocator.GetObject(RnResearchNbkTags.kguidRecObservation).Hvo); // Ensure that we start out focused in the Title text box. See FWR-2731. m_titleTextBox.Select(); }
// protected string m_helpId; /// <summary> /// constructor using a simple string explanation. Also creates an annotation on the object. /// </summary> public ConstraintFailure(ICmObject problemObject, int flid, string explanation, bool createAnnotation) { m_cache = problemObject.Cache; m_object = problemObject; m_flid = flid; m_explanation = explanation; // m_explanation = new StText(); // StTxtParaBldr paraBldr = new StTxtParaBldr(m_cache); // //review: I have no idea what this is as to be // paraBldr.ParaProps = StyleUtils.ParaStyleTextProps("Paragraph"); // //todo: this pretends that the default analysis writing system is also the user interface 1. // //but I don't really know what's the right thing to do. // paraBldr.AppendRun(m_explanation, StyleUtils.CharStyleTextProps(null, m_cache.DefaultAnalWs)); // paraBldr.CreateParagraph(annotation.TextOAHvo); //we do this because, if it is missing this annotation, then we really should annotate it //so that when the user goes looking to see why something didn't work, the error message //is sure to be there. //enhance: we are wasting time building an annotation repeatedly, if the correct one is already there if (createAnnotation) { MakeAnnotation(); } }
protected override void HandleSelectionChange(IVwRootBox rootb, IVwSelection vwselNew) { ICmObject selected = SelectedObject; int selectedHvo = 0; if (selected != null) { selectedHvo = selected.Hvo; } if (selectedHvo != m_prevSelectedHvo) { if (DeleteItem()) { m_prevSelectedHvo = selectedHvo; SelectedObject = selected; } else { m_prevSelectedHvo = selectedHvo; vwselNew.ExtendToStringBoundaries(); } } }
public void SetAgentOpinion() { ICmAgent agent = m_fdoCache.LangProject.DefaultComputerAgent; IWfiWordform wf = new WfiWordform(m_fdoCache, WfiWordform.FindOrCreateWordform(m_fdoCache, "xxxyyyzzz12234", m_fdoCache.DefaultVernWs, true)); IWfiAnalysis wa = new WfiAnalysis(); wf.AnalysesOC.Add(wa); ICmObject target = wa; // can pick anything as target for evaluation! m_fdoCache.BeginUndoTask("doit", "undoit"); wa.SetAgentOpinion(agent, Opinions.approves); m_fdoCache.EndUndoTask(); Assert.AreEqual(Opinions.approves, wa.GetAgentOpinion(agent)); m_fdoCache.Undo(); Assert.AreEqual(Opinions.noopinion, wa.GetAgentOpinion(agent)); m_fdoCache.Redo(); Assert.AreEqual(Opinions.approves, wa.GetAgentOpinion(agent)); m_fdoCache.BeginUndoTask("changeit", "unchangeit"); wa.SetAgentOpinion(agent, Opinions.disapproves); m_fdoCache.EndUndoTask(); Assert.AreEqual(Opinions.disapproves, wa.GetAgentOpinion(agent)); m_fdoCache.Undo(); Assert.AreEqual(Opinions.approves, wa.GetAgentOpinion(agent)); m_fdoCache.Redo(); Assert.AreEqual(Opinions.disapproves, wa.GetAgentOpinion(agent)); m_fdoCache.BeginUndoTask("clearit", "unclearit"); wa.SetAgentOpinion(agent, Opinions.noopinion); m_fdoCache.EndUndoTask(); Assert.AreEqual(Opinions.noopinion, wa.GetAgentOpinion(agent)); m_fdoCache.Undo(); Assert.AreEqual(Opinions.disapproves, wa.GetAgentOpinion(agent)); m_fdoCache.Redo(); Assert.AreEqual(Opinions.noopinion, wa.GetAgentOpinion(agent)); }
/// <summary> /// Initialize from the data store (which uses byte arrays). /// </summary> internal void InitializeFromDataStore(LcmCache cache, ICmObjectId objId, string className, byte[] xmlData) { if (cache == null) { throw new ArgumentNullException("cache"); } if (objId == null) { throw new ArgumentNullException("objId"); } if (xmlData == null) { throw new ArgumentNullException("xmlData"); } if (string.IsNullOrEmpty(className)) { throw new ArgumentNullException("className"); } lock (SyncRoot) { m_cache = cache; // Don't do this! If it's a new surrogate, the object is already null, and if not, // and we've already fluffed it, it's an invalid state for the object of the surrogate // to be null when it is fluffed. // m_object = null; // in fact, if we're re-creating a surrogate that got fluffed and garbage collected, // e.g., in Refreshing a surrogate to align it with another client, // we might be making a new object, yet the CmObject might already exist! m_object = ((ICmObjectRepositoryInternal)m_cache.ServiceLocator.ObjectRepository).GetObjectIfFluffed(objId); RawXmlBytes = xmlData; m_guid = objId is CmObjectIdWithHvo ? objId : ((IServiceLocatorInternal)cache.ServiceLocator).IdentityMap.CreateObjectIdWithHvo(objId.Guid); SetClassName(className); } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Constructor. /// </summary> /// <param name="cache">FDO cache.</param> /// <param name="obj">CmObject that is being displayed.</param> /// <param name="flid">The field identifier for the attribute we are displaying.</param> /// <param name="persistenceProvider">The persistence provider.</param> /// ------------------------------------------------------------------------------------ public MSAReferenceComboBoxSlice(FdoCache cache, ICmObject obj, int flid, IPersistenceProvider persistenceProvider) : base(new UserControl(), cache, obj, flid) { IWritingSystem defAnalWs = m_cache.ServiceLocator.WritingSystems.DefaultAnalysisWritingSystem; m_persistProvider = persistenceProvider; m_tree = new TreeCombo(); m_tree.WritingSystemFactory = cache.WritingSystemFactory; m_tree.Font = new System.Drawing.Font(defAnalWs.DefaultFontName, 10); if (!Application.RenderWithVisualStyles) { m_tree.HasBorder = false; } m_tree.WritingSystemCode = defAnalWs.Handle; // We embed the tree combo in a layer of UserControl, so it can have a fixed width // while the parent window control is, as usual, docked 'fill' to work with the splitter. m_tree.Dock = DockStyle.Left; m_tree.Width = 240; m_tree.DropDown += m_tree_DropDown; Control.Controls.Add(m_tree); m_tree.SizeChanged += m_tree_SizeChanged; if (m_cache != null) { m_cache.DomainDataByFlid.AddNotification(this); } m_treeBaseWidth = m_tree.Width; // m_tree has sensible PreferredHeight once the text is set, UserControl does not. //we need to set the Height after m_tree.Text has a value set to it. Control.Height = m_tree.PreferredHeight; }
/// <summary> /// This is the primary combo box. /// When an item is selected, then the secondary combo box can be /// filled with approriate items. /// With the selected itme here, we can also populate the /// left side control (the one below the combo box). /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void m_cbFind_SelectedIndexChanged(object sender, EventArgs e) { Cursor oldState = FindForm().Cursor; m_selectedFinder = null; FindForm().Cursor = Cursors.WaitCursor; FindComboFillerBase fcf = m_cbFind.SelectedItem as FindComboFillerBase; m_cbUsedBy.BeginUpdate(); m_cbUsedBy.Items.Clear(); m_cbUsedBy.Items.AddRange(fcf.List_UBF.ToArray()); m_cbUsedBy.EndUpdate(); fcf.LoadList(m_mediator, m_splitContainer.Panel1); if (m_cbUsedBy.Items.Count > 0) { m_cbUsedBy.SelectedIndex = 0; } else { m_cbUsedBy.SelectedItem = null; } FindForm().Cursor = oldState; }
private void HandlePossibilitySelected(object sender, EventArgs e) { ICmPossibility poss = m_autoComplete.SelectedPossibility; ICmObject curObj = m_vectorRefView.SelectedObject; if (curObj == null) { AddItem(poss); } else if (poss != curObj) { var newTargets = new List <ICmObject>(); foreach (ICmObject target in Targets) { newTargets.Add(target == curObj ? poss : target); } SetItems(newTargets); } else { UpdateDisplayFromDatabase(); } m_vectorRefView.SelectedObject = poss; }
private void AddSenseAndTwoSubsensesToEntry(ICmObject entryOrSense, string gloss) { var senseFactory = Cache.ServiceLocator.GetInstance <ILexSenseFactory>(); var sense = senseFactory.Create(); var entry = entryOrSense as ILexEntry; if (entry != null) { entry.SensesOS.Add(sense); } else { ((ILexSense)entryOrSense).SensesOS.Add(sense); } sense.Gloss.set_String(m_wsEn, TsStringUtils.MakeString(gloss, m_wsEn)); var subSensesOne = senseFactory.Create(); sense.SensesOS.Add(subSensesOne); subSensesOne.Gloss.set_String(m_wsEn, TsStringUtils.MakeString(gloss + "2.1", m_wsEn)); var subSensesTwo = senseFactory.Create(); sense.SensesOS.Add(subSensesTwo); subSensesTwo.Gloss.set_String(m_wsEn, TsStringUtils.MakeString(gloss + "2.2", m_wsEn)); }
/// <summary> /// Attempts to get the ICmObject with the given Guid. /// </summary> /// <param name="hvo">The unique id of an object.</param> /// <param name="obj">The ICmObject with the given Guid, or null, if not in Identity Map.</param> /// <returns>True if the object was found, false otherwise</returns> internal bool TryGetObject(int hvo, out ICmObject obj) { ICmObjectOrId objOrId; bool found; lock (SyncRoot) { found = m_extantObjectsByHvo.TryGetValue(hvo, out objOrId); } if (found) { obj = objOrId as ICmObject; if (obj != null) { return(true); } if (TryGetObject(objOrId.Id.Guid, out obj)) { return(true); } } obj = null; return(false); }
/// <summary> /// Handle the click event for the launcher button. /// </summary> /// <param name="sender"></param> /// <param name="arguments"></param> protected virtual void OnClick(Object sender, EventArgs arguments) { bool fValid; if (m_obj == null && ObjectCreator != null) { m_obj = ObjectCreator(); OnObjectCreated(); } if (m_obj == null) { MessageBox.Show(DetailControlsStrings.ksNotInitialized); fValid = false; } else { fValid = m_obj.IsValidObject; } if (fValid) { HandleChooser(); } }
/// <summary> /// Executes in two distinct scenarios. /// /// 1. If disposing is true, the method has been called directly /// or indirectly by a user's code via the Dispose method. /// Both managed and unmanaged resources can be disposed. /// /// 2. If disposing is false, the method has been called by the /// runtime from inside the finalizer and you should not reference (access) /// other managed objects, as they already have been garbage collected. /// Only unmanaged resources can be disposed. /// </summary> /// <param name="disposing"></param> /// <remarks> /// If any exceptions are thrown, that is fine. /// If the method is being done in a finalizer, it will be ignored. /// If it is thrown by client code calling Dispose, /// it needs to be handled by fixing the bug. /// /// If subclasses override this method, they should call the base implementation. /// </remarks> protected override void Dispose(bool disposing) { //Debug.WriteLineIf(!disposing, "****************** " + GetType().Name + " 'disposing' is false. ******************"); // Must not be run more than once. if (IsDisposed) { return; } base.Dispose(disposing); if (disposing) { // Dispose managed resources here. if (m_vc != null && m_vc is IDisposable) { (m_vc as IDisposable).Dispose(); } } // Dispose unmanaged resources here, whether disposing is true or false. m_obj = null; m_vc = null; }
/// <summary> /// Calls the sort method. /// </summary> /// <param name="cmo">The object.</param> /// <param name="sortedFromEnd">if set to <c>true</c> [sorted from end].</param> /// <returns></returns> private string CallSortMethod(ICmObject cmo, bool sortedFromEnd) { Type typeCmo = cmo.GetType(); try { MethodInfo mi = typeCmo.GetMethod(m_sMethodName); if (mi == null) { return(null); } object obj; if (mi.GetParameters().Length == 2) { // Enhance JohnT: possibly we should seek to evaluate this every time, in case it is a magic WS like // "best vernacular". But interpreting those requires a flid, and we don't have one; indeed, the // method may retrieve information from several. So we may as well just accept that the fancy ones // won't work. if (m_ws == 0 && WritingSystemName != null) { m_ws = LangProject.InterpretWsLabel(cmo.Cache, WritingSystemName, 0, 0, 0, null); } obj = mi.Invoke(cmo, new object[] { sortedFromEnd, m_ws }); } else { obj = mi.Invoke(cmo, new object[] { sortedFromEnd }); } return((string)obj); } catch (Exception) { return(null); } }
/// <summary> /// Get the field values as a dict, keyed by field ID, for any CmObject. /// </summary> /// <returns>A dictionary with integer field ID mapped to values.</returns> /// <param name="cache">LCM cache the object lives in.</param> /// <param name="obj">Object whose fields we're getting.</param> protected IDictionary <int, object> GetFieldValues(LcmCache cache, ICmObject obj) { IFwMetaDataCacheManaged mdc = cache.ServiceLocator.MetaDataCache; ISilDataAccess data = cache.DomainDataByFlid; int[] fieldIds = mdc.GetFields(obj.ClassID, false, (int)CellarPropertyTypeFilter.All); var fieldValues = new Dictionary <int, object>(); foreach (int flid in fieldIds) { if (mdc.IsCustom(flid)) { continue; // Custom fields get processed differently } string fieldName = mdc.GetFieldNameOrNull(flid); if (String.IsNullOrEmpty(fieldName)) { continue; } object value = data.get_Prop(obj.Hvo, flid); fieldValues[flid] = value; } return(fieldValues); }
public PhonologicalFeatureListDlgLauncherSlice(FdoCache cache, ICmObject obj, int flid, System.Xml.XmlNode node, IPersistenceProvider persistenceProvider, Mediator mediator, StringTable stringTbl) { }
public CheckboxRefreshSlice(LcmCache cache, ICmObject obj, int flid, XmlNode node) : base(cache, obj, flid, node) { }
private static IFsFeatStruc GetFeatureStructureFromOwner(ICmObject obj, int flid) { IFsFeatStruc fs = obj.GetObjectInAtomicField(flid) as IFsFeatStruc; return(fs); }
protected SemanticDomainReferenceVectorSlice(Control control, FdoCache cache, ICmObject obj, int flid) : base(control, cache, obj, flid) { }
public SemanticDomainReferenceVectorSlice(FdoCache cache, ICmObject obj, int flid) : base(new SemanticDomainReferenceLauncher(), cache, obj, flid) { }
/// <summary> /// Update the root object. This is currently used when one is created, so it doesn't need to handle null object. /// </summary> /// <param name="root"></param> internal void UpdateRootObject(ICmObject root) { m_rootObj = root; m_rootb.SetRootObject(m_rootObj.Hvo, m_VectorReferenceVc, kfragTargetVector, m_rootb.Stylesheet); }
public override void AddItem(ICmObject obj) { AddItem(obj, string.Format(DetailControlsStrings.ksUndoSet, m_fieldName), string.Format(DetailControlsStrings.ksRedoSet, m_fieldName)); }
/// <summary> /// This method is called when we are creating a new lexical relation slice. /// If the user selects an item it's hvo is returned. /// Otherwise 0 is returned and the lexical relation should not be created. /// </summary> /// <param name="lrt"></param> /// <returns></returns> private ICmObject GetChildObject(ILexRefType lrt) { ICmObject first = null; EntryGoDlg dlg = null; string sTitle = string.Empty; try { switch ((LexRefTypeTags.MappingTypes)lrt.MappingType) { case LexRefTypeTags.MappingTypes.kmtEntryOrSensePair: case LexRefTypeTags.MappingTypes.kmtEntryOrSenseAsymmetricPair: // Entry or sense pair with different Forward/Reverse dlg = new LinkEntryOrSenseDlg(); (dlg as LinkEntryOrSenseDlg).SelectSensesOnly = false; sTitle = String.Format(LexEdStrings.ksIdentifyXLexEntryOrSense, lrt.Name.BestAnalysisAlternative.Text); break; case LexRefTypeTags.MappingTypes.kmtSenseCollection: case LexRefTypeTags.MappingTypes.kmtSensePair: case LexRefTypeTags.MappingTypes.kmtSenseAsymmetricPair: case LexRefTypeTags.MappingTypes.kmtSenseUnidirectional: // Sense pair with different Forward/Reverse names case LexRefTypeTags.MappingTypes.kmtSenseSequence: case LexRefTypeTags.MappingTypes.kmtSenseTree: dlg = new LinkEntryOrSenseDlg(); (dlg as LinkEntryOrSenseDlg).SelectSensesOnly = true; sTitle = String.Format(LexEdStrings.ksIdentifyXSense, lrt.Name.BestAnalysisAlternative.Text); break; case LexRefTypeTags.MappingTypes.kmtEntryCollection: case LexRefTypeTags.MappingTypes.kmtEntryPair: case LexRefTypeTags.MappingTypes.kmtEntryAsymmetricPair: case LexRefTypeTags.MappingTypes.kmtEntryUnidirectional: // Entry pair with different Forward/Reverse names case LexRefTypeTags.MappingTypes.kmtEntrySequence: case LexRefTypeTags.MappingTypes.kmtEntryTree: dlg = new EntryGoDlg(); sTitle = String.Format(LexEdStrings.ksIdentifyXLexEntry, lrt.Name.BestAnalysisAlternative.Text); break; case LexRefTypeTags.MappingTypes.kmtEntryOrSenseCollection: case LexRefTypeTags.MappingTypes.kmtEntryOrSenseSequence: case LexRefTypeTags.MappingTypes.kmtEntryOrSenseTree: case LexRefTypeTags.MappingTypes.kmtEntryOrSenseUnidirectional: dlg = new LinkEntryOrSenseDlg(); sTitle = String.Format(LexEdStrings.ksIdentifyXLexEntryOrSense, lrt.Name.BestAnalysisAlternative.Text); break; default: Debug.Assert(lrt.MappingType == (int)LexRefTypeTags.MappingTypes.kmtSenseAsymmetricPair || lrt.MappingType == (int)LexRefTypeTags.MappingTypes.kmtSenseTree); return(null); } Debug.Assert(dlg != null); var wp = new WindowParams { m_title = sTitle, m_btnText = LexEdStrings.ks_Add }; // Don't display the current entry in the list of matching entries. See LT-2611. ICmObject objEntry = this.Object; while (objEntry.ClassID == LexSenseTags.kClassId) { objEntry = objEntry.Owner; } Debug.Assert(objEntry.ClassID == LexEntryTags.kClassId); dlg.StartingEntry = objEntry as ILexEntry; dlg.SetDlgInfo(m_cache, wp, Mediator); dlg.SetHelpTopic("khtpChooseLexicalRelationAdd"); if (dlg.ShowDialog(FindForm()) == DialogResult.OK) { first = dlg.SelectedObject; } return(first); } finally { if (dlg != null) { dlg.Dispose(); } } }