///// ------------------------------------------------------------------------------------ ///// <summary> ///// Append a picture to the end of the paragraph using the given writing system. ///// </summary> ///// <param name="ws">given writing system</param> ///// <param name="strBldr">The string builder for the paragraph being composed</param> ///// ------------------------------------------------------------------------------------ //public void AppendPicture(int ws, ITsStrBldr strBldr) //{ // // Make a TsTextProps with the relevant object data and the same ws as its // // context. // byte[] objData = MiscUtils.GetObjData(this.Guid, // (byte)FwObjDataTypes.kodtGuidMoveableObjDisp); // ITsPropsBldr propsBldr = TsStringUtils.MakePropsBldr(); // propsBldr.SetStrPropValueRgch((int)FwTextPropType.ktptObjData, // objData, objData.Length); // propsBldr.SetIntPropValues((int)FwTextPropType.ktptWs, 0, ws); // // Insert the orc with the resulting properties. // strBldr.Replace(strBldr.Length, strBldr.Length, // new string(TsStringUtils.kChObject, 1), propsBldr.GetTextProps()); //} /// ------------------------------------------------------------------------------------ /// <summary> /// Update the properties of a CmPicture with the given file, caption, and folder. /// </summary> /// <param name="srcFilename">The full path to the filename (this might be an "internal" /// copy of the original the user chose)</param> /// <param name="captionTss">The caption</param> /// <param name="sFolder">The name of the CmFolder where picture should be stored</param> /// <param name="ws">The WS for the location in the caption MultiUnicode to put the /// caption</param> /// ------------------------------------------------------------------------------------ public void UpdatePicture(string srcFilename, ITsString captionTss, string sFolder, int ws) { // Set the caption first since creating the CmFile will throw if srcFilename is empty. if (ws != 0) { Caption.set_String(ws, captionTss); } ICmFile file = PictureFileRA; if (file == null) { ICmFolder folder = DomainObjectServices.FindOrCreateFolder(m_cache, LangProjectTags.kflidPictures, sFolder); PictureFileRA = DomainObjectServices.FindOrCreateFile(folder, srcFilename); } else { Debug.Assert(sFolder == CmFolderTags.LocalPictures, "TODO: If we ever actually support use of different folders, we need to handle folder changes."); if (srcFilename != null && !FileUtils.PathsAreEqual(srcFilename, file.AbsoluteInternalPath)) { file.InternalPath = srcFilename; } } // We shouldn't need to this in the new LCM. //m_cache.PropChanged(null, PropChangeType.kpctNotifyAll, Hvo, // (int)CmPicture.CmPictureTags.kflidCaption, ws, 0 , 0); //m_cache.PropChanged(null, PropChangeType.kpctNotifyAll, file.Hvo, // (int)CmFile.CmFileTags.kflidInternalPath, 0, 1, 1); }
/// <summary> /// this is called when XCore wants to display something that relies on the list with the id "WritingSystemList" /// </summary> /// <param name="parameter">The parameter.</param> /// <param name="display">The display.</param> /// <returns></returns> public bool OnDisplayWritingSystemList(object parameter, ref UIListDisplayProperties display) { CheckDisposed(); display.List.Clear(); FdoCache cache = (FdoCache)m_mediator.PropertyTable.GetValue("cache"); string wsSet = parameter as string; WritingSystemSet setToUse = m_currentSet; if (wsSet != null) { // JohnT: This is a patch to fix LT-5059. The problem is that the WritingSystemList set // (with the pronunciation subset) is used in the Pronuciation field pull-down menu. // All other code that I can find currently does not specify it. Therefore, after this // menu is displayed once, m_currentSet is set to pronunciation and stays there. // It seems that we actually have no current use for any other subset, nor for remembering // the most recent one specified. However, in the interests of making the change minimal, // and in case there is some anticipated application of tracking the current set which // I am not aware of, I made a way for that one menu item to get the list it needs // without making a persistent change. string tempPrefix = "temp:"; bool fTemp = wsSet.StartsWith(tempPrefix); if (fTemp) { setToUse = DecodeSetName(wsSet.Substring(tempPrefix.Length)); } else { m_currentSet = setToUse = DecodeSetName(wsSet); } } switch (setToUse) { default: throw new NotImplementedException("That writing system set needs to be implemented"); case WritingSystemSet.All: AddWritingSystemList(display, cache.ServiceLocator.WritingSystemManager.LocalWritingSystems); break; case WritingSystemSet.AllCurrent: AddWritingSystemList(display, cache.ServiceLocator.WritingSystems.AllWritingSystems); break; case WritingSystemSet.CurrentAnalysis: AddWritingSystemList(display, cache.ServiceLocator.WritingSystems.CurrentAnalysisWritingSystems); break; case WritingSystemSet.CurrentVernacular: AddWritingSystemList(display, cache.ServiceLocator.WritingSystems.CurrentVernacularWritingSystems); break; case WritingSystemSet.CurrentPronounciation: AddWritingSystemList(display, cache.ServiceLocator.WritingSystems.CurrentPronunciationWritingSystems); string sValue = DomainObjectServices.JoinIds(cache.ServiceLocator.WritingSystems.CurrentPronunciationWritingSystems.Select(ws => ws.Handle).ToArray(), ","); m_mediator.PropertyTable.SetProperty("PronunciationWritingSystemHvos", sValue); break; } return(true); //we handled this, no need to ask anyone else. }
private void GetMainEntryAndSense(ILexEntry entryOrVariant, out ILexEntry mainEntry, out ILexSense sense) { sense = null; // first see if this is a variant of another entry. var entryRef = DomainObjectServices.GetVariantRef(entryOrVariant, true); if (entryRef != null) { // get the main entry or sense. var component = entryRef.ComponentLexemesRS[0] as IVariantComponentLexeme; if (component is ILexSense) { sense = component as ILexSense; mainEntry = sense.Entry; } else { mainEntry = component as ILexEntry; // consider using the sense of the variant, if it has one. (LT-9681) } } else { mainEntry = entryOrVariant; } }
private int GetHvoCommonAncestor(int hvoBeforeListChange, int prevListItemsClass, int newListItemsClass) { XmlNode prevClassNode = GetTreeNode(prevListItemsClass); XmlNode newClassNode = GetTreeNode(newListItemsClass); int hvoCommonAncestor = 0; // NOTE: the class of hvoBeforeListChange could be different then prevListItemsClass, if the item is a ghost (owner). int classOfHvoBeforeListChange = Cache.ServiceLocator.GetInstance <ICmObjectRepository>().GetObject(hvoBeforeListChange).ClassID; // so go up the parent of the previous one until it's an ancestor of the newClass. XmlNode ancestorOfPrev = prevClassNode.ParentNode; while (ancestorOfPrev != null) { if (newClassNode.SelectSingleNode("ancestor::" + ancestorOfPrev.Name) != null) { XmlNode commonAncestor = ancestorOfPrev; var classCommonAncestor = Cache.MetaDataCacheAccessor.GetClassId(commonAncestor.Name); if (DomainObjectServices.IsSameOrSubclassOf(Cache.DomainDataByFlid.MetaDataCache, classOfHvoBeforeListChange, classCommonAncestor)) { hvoCommonAncestor = hvoBeforeListChange; } else { var obj = Cache.ServiceLocator.GetInstance <ICmObjectRepository>().GetObject(hvoBeforeListChange); hvoCommonAncestor = obj.OwnerOfClass(classCommonAncestor).Hvo; } break; } ancestorOfPrev = ancestorOfPrev.ParentNode; } return(hvoCommonAncestor); }
private IEnumerable <IMoInflAffixSlot> GetSlots() { if (m_morphType == null) { // Not called by InsertEntryDlg; need to figure out the morphtype(s) var lex = m_mediator.PropertyTable.GetValue("ActiveClerkSelectedObject") as ILexEntry; if (lex != null) { return(DomainObjectServices.GetSlots(m_cache, lex, m_selectedMainPOS)); } else { return(m_selectedMainPOS.AllAffixSlots); } } else { // Called by InsertEntryDlg so we know the morphtype bool fIsPrefixal = MorphServices.IsPrefixishType(m_cache, m_morphType.Hvo); bool fIsSuffixal = MorphServices.IsSuffixishType(m_cache, m_morphType.Hvo); if (fIsPrefixal && fIsSuffixal) { return(m_selectedMainPOS.AllAffixSlots); } else { return(DomainObjectServices.GetSomeSlots(m_cache, m_selectedMainPOS.AllAffixSlots, fIsPrefixal)); } } }
public void CmFileFinder_OrigFilesMatch() { // Setup ICmFolder folder = DomainObjectServices.FindOrCreateFolder(Cache, LangProjectTags.kflidPictures, CmFolderTags.LocalPictures); ICmFile file = DomainObjectServices.FindOrCreateFile(folder, m_internalPath); Assert.AreEqual(m_pict.PictureFileRA, file); }
public void CmFileFinder_OrigFileMissing() { // Setup ICmFolder folder = DomainObjectServices.FindOrCreateFolder(Cache, LangProjectTags.kflidPictures, CmFolderTags.LocalPictures); FileUtils.Delete(m_internalPath); Assert.IsFalse(FileUtils.IsFileReadable(m_internalPath), "Test cannot proceed. Unable to delete Original file."); // Test Assert.DoesNotThrow(() => DomainObjectServices.FindOrCreateFile(folder, m_internalPath)); }
private void SetupCacheToTestAgainst() { var lp = Cache.LangProject; lp.LinkedFilesRootDir = m_linkedFilesRootDir; ICmFolder picturesfolder = DomainObjectServices.FindOrCreateFolder(Cache, LangProjectTags.kflidPictures, CmFolderTags.LocalPictures); ICmFolder mediafolder = DomainObjectServices.FindOrCreateFolder(Cache, LangProjectTags.kflidMedia, CmFolderTags.LocalMedia); ICmFolder tsStringsfolder = Cache.ServiceLocator.GetInstance <ICmFolderFactory>().Create(); lp.FilePathsInTsStringsOA = tsStringsfolder; tsStringsfolder.Name.AnalysisDefaultWritingSystem = Cache.TsStrFactory.MakeString(CmFolderTags.LocalFilePathsInTsStrings, WritingSystemServices.FallbackUserWs(Cache)); AddCmFileToCmFolder(picturesfolder, Path.Combine("Pictures", "JudeAndMeWithBeard.jpg")); AddCmFileToCmFolder(tsStringsfolder, Path.Combine("Others", "Chic Skype.png")); AddCmFileToCmFolder(mediafolder, Path.Combine("AudioVisual", "Untitled0.WMV")); }
public void CmFileFinder_NoPreExistingCmFile() { // Setup string sNewFile = Path.DirectorySeparatorChar + Path.GetRandomFileName(); m_fileOs.AddFile(sNewFile, "456", Encoding.Default); ICmFolder folder = DomainObjectServices.FindOrCreateFolder(Cache, LangProjectTags.kflidPictures, CmFolderTags.LocalPictures); // Test ICmFile file = DomainObjectServices.FindOrCreateFile(folder, sNewFile); Assert.IsNotNull(file, "null CmFile returned"); Assert.AreEqual(sNewFile, file.InternalPath, "Internal path not set correctly"); Assert.AreEqual(sNewFile, file.AbsoluteInternalPath, "Files outside LangProject.LinkedFilesRootDir are stored as absolute paths"); Assert.AreNotEqual(m_pict.PictureFileRA, file); FileUtils.Delete(sNewFile); }
private RelationshipOfRelatives FindTreeRelationship(int prevListItemsClass, int newListItemsClass) { RelationshipOfRelatives relationshipOfTarget; if (DomainObjectServices.IsSameOrSubclassOf(Cache.DomainDataByFlid.MetaDataCache, prevListItemsClass, newListItemsClass)) { relationshipOfTarget = RelationshipOfRelatives.Sibling; } else { // lookup new class in ownership tree and decide how to select the most related object string newClassName = Cache.DomainDataByFlid.MetaDataCache.GetClassName(newListItemsClass); string prevClassName = Cache.DomainDataByFlid.MetaDataCache.GetClassName(prevListItemsClass); XmlNode prevClassNode = m_classOwnershipTree.SelectSingleNode(".//" + prevClassName); XmlNode newClassNode = m_classOwnershipTree.SelectSingleNode(".//" + newClassName); // determine if prevClassName is owned (has anscestor) by the new. bool fNewIsAncestorOfPrev = prevClassNode.SelectSingleNode("ancestor::" + newClassName) != null; if (fNewIsAncestorOfPrev) { relationshipOfTarget = RelationshipOfRelatives.Ancestor; } else { // okay, now find most related object in new items list. bool fNewIsChildOfPrev = newClassNode.SelectSingleNode("ancestor::" + prevClassName) != null; if (fNewIsChildOfPrev) { relationshipOfTarget = RelationshipOfRelatives.Descendent; } else { relationshipOfTarget = RelationshipOfRelatives.Cousin; } } } return(relationshipOfTarget); }
private void AddCmFileToCmFolder(ICmFolder cmFolder, string fileInsideLinkedFiles) { var file = DomainObjectServices.FindOrCreateFile(cmFolder, fileInsideLinkedFiles); }
/// <summary> /// If OK, then make FS have the selected feature value(s). /// JohnT: This is a really ugly kludge, which I have only partly repaired. /// We need the dialog to return with m_fs set to an FsFeatStruc (if OK was clicked), /// since that is what the bulk edit bar wants to copy to MoStemMsas for any items /// it is asked to modify. Also, the new FsFeatStruc needs to be in the ReferenceForms /// (which is what m_owningFlid apparently always is, currently) so that it will become /// one of the items in the combo list and can be selected. However, Andy says this is /// not the intended use of ReferenceForms at all. /// A further ugliness is that we always make a new FsFeatStruc (unless one was passed /// in to one of the SegDlgInfo methods, but AFAIK that override is never used), but /// we then delete it if it turns out to be a duplicate. There is no other straightforward /// way to detect that the current choices in the dialog correspond to an existing item. /// This may cause problems in the new world, where we can't do this "suppress sub tasks" /// trick without losing our Undo stack. /// It may be possible in the new world to create an object without initially giving it an /// owner, and only persist it if it is NOT a duplicate. But even that we don't really want /// to be undoable, nor should it clear the undo stack. Really the list of possible choices /// for the combo should not be separately persisted as model data, but it should be persisted /// somehow... /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void MsaInflectionFeatureListDlg_Closing(object sender, System.ComponentModel.CancelEventArgs e) { if (DialogResult == DialogResult.OK) { // making and maybe then deleting the new item for the combo is not undoable NonUndoableUnitOfWorkHelper.Do(m_cache.ActionHandlerAccessor, () => { if (m_fs == null) { // Didn't have one to begin with. See whether we want to create one. if (CheckFeatureStructure(m_tvMsaFeatureList.Nodes)) { var repo = m_cache.ServiceLocator.GetInstance <IFsFeatStrucRepository>(); // FsFeatStruc may be owned atomically or in a colllection. See which fake insertion index we need. int where = m_cache.MetaDataCacheAccessor.GetFieldType(m_owningFlid) == (int)CellarPropertyType.OwningAtomic ? -2: -1; int hvoNew = m_cache.DomainDataByFlid.MakeNewObject(FsFeatStrucTags.kClassId, m_hvoOwner, m_owningFlid, where); m_fs = repo.GetObject(hvoNew); } else { return; // leave it null. } } // clean out any extant features in the feature structure foreach (var spec in m_fs.FeatureSpecsOC) { m_fs.FeatureSpecsOC.Remove(spec); } UpdateFeatureStructure(m_tvMsaFeatureList.Nodes); // The (usually) newly created one may be a duplicate. If we find a duplicate // delete the one we just made (or were passed) and return the duplicate. int cpt = m_cache.MetaDataCacheAccessor.GetFieldType(m_owningFlid); if (m_hvoOwner != 0 && cpt != (int)CellarPropertyType.OwningAtomic) { int chvo = m_cache.DomainDataByFlid.get_VecSize(m_hvoOwner, m_owningFlid); for (int ihvo = 0; ihvo < chvo; ihvo++) { int hvo = m_cache.DomainDataByFlid.get_VecItem(m_hvoOwner, m_owningFlid, ihvo); if (hvo == m_fs.Hvo) { continue; } IFsFeatStruc fs = m_cache.ServiceLocator.GetInstance <IFsFeatStrucRepository>().GetObject(hvo); if (DomainObjectServices.AreEquivalent(fs, m_fs)) { m_cache.DomainDataByFlid.DeleteObj(m_fs.Hvo); m_fs = fs; break; } } } // If the user emptied all the FeatureSpecs (i.e. chose "None of the above" in each area), // then we need to delete the FsFeatStruc. (LT-13596) if (FS.FeatureSpecsOC.Count == 0) { if (m_fs.CanDelete) { m_fs.Delete(); } m_fs = null; } }); } if (m_propertyTable != null) { m_propertyTable.SetProperty("msaInflFeatListDlgLocation", Location, true); m_propertyTable.SetProperty("msaInflFeatListDlgSize", Size, true); } }