/// <summary> /// Implement the "Move Down" command. /// </summary> public bool OnMoveItemDownInVector(object argument) { CheckDisposed(); if (this.Object == null) { return(false); } IRnGenericRec rec = this.Object as IRnGenericRec; if (rec == null) { return(false); // shouldn't get here } IRnGenericRec recOwner = rec.Owner as IRnGenericRec; if (recOwner == null) { return(false); // shouldn't get here } int idxOrig = rec.OwnOrd; Debug.Assert(recOwner.SubRecordsOS[idxOrig] == rec); if (idxOrig == recOwner.SubRecordsOS.Count - 1) { return(false); // shouldn't get here. } UndoableUnitOfWorkHelper.DoUsingNewOrCurrentUOW(Resources.DetailControlsStrings.ksUndoMoveDown, Resources.DetailControlsStrings.ksRedoMoveDown, Cache.ActionHandlerAccessor, () => { // idxOrig + 2 looks strange, but it's the correct value to make this work. recOwner.SubRecordsOS.MoveTo(idxOrig, idxOrig, recOwner.SubRecordsOS, idxOrig + 2); }); return(true); }
/// <summary> /// Have the utility do what it does. /// </summary> public void Process() { Debug.Assert(m_dlg != null); var cache = (FdoCache)m_dlg.Mediator.PropertyTable.GetValue("cache"); var homographWsId = cache.LanguageProject.HomographWs; var homographWs = cache.ServiceLocator.WritingSystems.AllWritingSystems.Where(ws => ws.Id == homographWsId); var homographWsLabel = homographWs.First().DisplayLabel; var defaultVernacularWs = cache.LanguageProject.DefaultVernacularWritingSystem; var defaultVernacularWsId = defaultVernacularWs.Id; var changeWs = false; if (homographWsId != defaultVernacularWsId) { var caution = string.Format(LexEdStrings.ksReassignHomographsCaution, homographWsLabel, defaultVernacularWs.DisplayLabel); if (MessageBox.Show(caution, LexEdStrings.ksReassignHomographs, MessageBoxButtons.YesNo) == DialogResult.Yes) { changeWs = true; } } if (changeWs) { UndoableUnitOfWorkHelper.DoUsingNewOrCurrentUOW( LexEdStrings.ksUndoHomographWs, LexEdStrings.ksRedoHomographWs, cache.ActionHandlerAccessor, () => { cache.LanguageProject.HomographWs = defaultVernacularWsId; }); } cache.LanguageProject.LexDbOA.ResetHomographNumbers(new ProgressBarWrapper(m_dlg.ProgressBar)); }
protected override void HandleChooser() { const string displayWs = "best analysis"; var sense = m_obj as ILexSense; if (sense == null) { Debug.Assert(sense != null, "This chooser can only be applied to senses"); // ReSharper disable HeuristicUnreachableCode //reachable in release mode you usually intelligent program. return; // ReSharper restore HeuristicUnreachableCode } var linkCommandNode = m_configurationNode.SelectSingleNode("descendant::chooserLink"); var chooser = new SemanticDomainsChooser { Mediator = m_mediator, Cache = m_cache, DisplayWs = displayWs, Sense = sense, LinkNode = linkCommandNode, HelpTopicProvider = m_mediator.HelpTopicProvider }; var labels = ObjectLabel.CreateObjectLabels(m_cache, m_obj.ReferenceTargetCandidates(m_flid), m_displayNameProperty, displayWs); chooser.Initialize(labels, sense.SemanticDomainsRC); var result = chooser.ShowDialog(); if (result == DialogResult.OK) { UndoableUnitOfWorkHelper.DoUsingNewOrCurrentUOW(Resources.DetailControlsStrings.ksUndoSet, Resources.DetailControlsStrings.ksRedoSet, m_cache.ActionHandlerAccessor, () => sense.SemanticDomainsRC.Replace(sense.SemanticDomainsRC, chooser.SemanticDomains)); } }
//methods public override ObjectLabel Execute() { // Make create lex entry dialog and invoke it. ObjectLabel result = null; using (InsertEntryDlg dlg = new InsertEntryDlg()) { var morphType = GetMorphType(); dlg.SetDlgInfo(m_cache, morphType, MsaType.kInfl, m_slot, m_mediator, m_fPrefix ? InsertEntryDlg.MorphTypeFilterType.Prefix : InsertEntryDlg.MorphTypeFilterType.Suffix); dlg.DisableAffixTypeMainPosAndSlot(); if (dlg.ShowDialog() == DialogResult.OK) { bool fCreated; ILexEntry entry; dlg.GetDialogInfo(out entry, out fCreated); if (entry == null) { throw new ArgumentNullException("Expected entry cannot be null", "entry"); } // TODO: what do to make sure it has an infl affix msa? // this just assumes it will bool fInflAffix = false; foreach (var msa in entry.MorphoSyntaxAnalysesOC) { if (msa is IMoInflAffMsa) { fInflAffix = true; break; } } if (!fInflAffix) { UndoableUnitOfWorkHelper.DoUsingNewOrCurrentUOW(DetailControlsStrings.ksUndoCreatingInflectionalAffixCategoryItem, DetailControlsStrings.ksRedoCreatingInflectionalAffixCategoryItem, m_cache.ActionHandlerAccessor, () => { var newby = m_cache.ServiceLocator.GetInstance <IMoInflAffMsaFactory>().Create(); entry.MorphoSyntaxAnalysesOC.Add(newby); }); } if (entry.MorphoSyntaxAnalysesOC.Count > 0) { result = ObjectLabel.CreateObjectLabel(m_cache, entry.MorphoSyntaxAnalysesOC.First(), ""); } } } return(result); }
/// <summary> /// Implement the "Promote" command. /// </summary> public bool OnPromoteSubitemInVector(object argument) { CheckDisposed(); if (this.Object == null) { return(false); } IRnGenericRec rec = this.Object as IRnGenericRec; if (rec == null) { return(false); // shouldn't get here } IRnGenericRec recOwner = rec.Owner as IRnGenericRec; if (recOwner == null) { return(false); // shouldn't get here } // Grab the mediator now for later use, because this slice may get disposed before we // use it. Mediator mediator = m_mediator; UndoableUnitOfWorkHelper.DoUsingNewOrCurrentUOW(Resources.DetailControlsStrings.ksUndoPromote, Resources.DetailControlsStrings.ksRedoPromote, Cache.ActionHandlerAccessor, () => { if (recOwner.Owner is IRnGenericRec) { (recOwner.Owner as IRnGenericRec).SubRecordsOS.Insert(recOwner.OwnOrd + 1, rec); } else if (recOwner.Owner is IRnResearchNbk) { (recOwner.Owner as IRnResearchNbk).RecordsOC.Add(rec); } else { throw new Exception("RnGenericRec object not owned by either RnResearchNbk or RnGenericRec??"); } }); if (recOwner.Owner is IRnResearchNbk) { // If possible, jump to the newly promoted record. mediator.BroadcastMessageUntilHandled("JumpToRecord", rec.Hvo); } return(true); }
public override ObjectLabel Execute() { ObjectLabel result = null; if (m_lexEntryRef != null) { using (LinkEntryOrSenseDlg dlg = new LinkEntryOrSenseDlg()) { ILexEntry le = null; // assume the owner is the entry (e.g. owner of LexEntryRef) le = m_lexEntryRef.OwnerOfClass <ILexEntry>(); dlg.SetDlgInfo(m_cache, m_mediator, m_propertyTable, le); dlg.SetHelpTopic("khtpChooseLexicalEntryOrSense"); if (dlg.ShowDialog(m_parentWindow) == DialogResult.OK) { ICmObject obj = dlg.SelectedObject; if (obj != null) { if (!m_lexEntryRef.PrimaryLexemesRS.Contains(obj)) { try { UndoableUnitOfWorkHelper.DoUsingNewOrCurrentUOW( LexEdStrings.ksUndoCreatingEntry, LexEdStrings.ksRedoCreatingEntry, Cache.ActionHandlerAccessor, () => { if (!m_lexEntryRef.ComponentLexemesRS.Contains(obj)) { m_lexEntryRef.ComponentLexemesRS.Add(obj); } m_lexEntryRef.PrimaryLexemesRS.Add(obj); }); } catch (ArgumentException) { MessageBoxes.ReportLexEntryCircularReference(m_lexEntryRef.Owner, obj, true); } } } } } } return(result); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Handle the OK button click /// </summary> /// <param name="sender"></param> /// <param name="e"></param> /// ------------------------------------------------------------------------------------ private void m_btnOK_Click(object sender, EventArgs e) { using (new WaitCursor(this)) { string undo, redo; TeResourceHelper.MakeUndoRedoLabels("kstidUndoRedoScriptureProperties", out undo, out redo); UndoableUnitOfWorkHelper.DoUsingNewOrCurrentUOW(undo, redo, m_cache.ServiceLocator.GetInstance <IActionHandler>(), () => { ProcessScriptNumberSettings(); ProcessRefFormattingSettings(); ProcessVersificationSettings(); ProcessFootnoteSettings(); }); } }
/// <summary> /// If OK, then make FS have the selected feature value(s). /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void PhonologicalFeatureChooserDlg_Closing(object sender, System.ComponentModel.CancelEventArgs e) { if (DialogResult == DialogResult.OK) { using (new WaitCursor(this)) { UndoableUnitOfWorkHelper.DoUsingNewOrCurrentUOW(MEStrings.ksUndoSelectionOfPhonologicalFeatures, MEStrings.ksRedoSelectionOfPhonologicalFeatures, m_cache.ActionHandlerAccessor, () => { if (m_fs == null) { // Didn't have one to begin with. See whether we want to create one. if (m_hvoOwner != 0 && CheckFeatureStructure()) { // The last argument is meaningless since we expect this property to be owning // or collection. var hvoFs = m_cache.DomainDataByFlid.MakeNewObject(FsFeatStrucTags.kClassId, m_hvoOwner, m_owningFlid, -2); m_fs = m_cache.ServiceLocator.GetInstance <IFsFeatStrucRepository>().GetObject(hvoFs); } } if (m_fs != null) { // clean out any extant features in the feature structure m_fs.FeatureSpecsOC.Clear(); UpdateFeatureStructure(); } }); } } if (m_mediator != null) { m_mediator.PropertyTable.SetProperty("phonFeatListDlgLocation", Location); m_mediator.PropertyTable.SetProperty("phonFeatListDlgSize", Size); } }
int MakeRealObject(ITsString tssTyped) { // Figure whether owning atomic or owning collection or owning sequence. Throw if none. // Unless we're making an unowned IText for a Notebook Record. ISilDataAccess sdaReal = m_fdoCache.DomainDataByFlid; IFwMetaDataCache mdc = sdaReal.MetaDataCache; CellarPropertyType typeOwning = (CellarPropertyType)(mdc.GetFieldType(m_flidEmptyProp) & (int)CellarPropertyTypeFilter.VirtualMask); // Make a new object of the specified class in the specified property. int ord = 0; switch (typeOwning) { default: if (m_flidEmptyProp != RnGenericRecTags.kflidText) { throw new Exception("ghost string property must be owning object property"); } break; case CellarPropertyType.OwningAtomic: ord = -2; break; case CellarPropertyType.OwningCollection: ord = -1; break; case CellarPropertyType.OwningSequence: // ord = 0 set above (inserting the first and only object at position 0). break; } string sClassRaw = mdc.GetClassName(m_clidDst); string sClass = m_mediator.StringTbl.GetString(sClassRaw, "ClassNames"); string sUndo = String.Format(DetailControlsStrings.ksUndoCreate0, sClass); string sRedo = String.Format(DetailControlsStrings.ksRedoCreate0, sClass); int hvoNewObj = 0; int hvoStringObj = 0; UndoableUnitOfWorkHelper.DoUsingNewOrCurrentUOW(sUndo, sRedo, m_fdoCache.ServiceLocator.GetInstance <IActionHandler>(), () => { // Special case: if we just created a Text in RnGenericRecord, and we want to show the contents // of an StTxtPara, make the intermediate objects if (m_flidEmptyProp == RnGenericRecTags.kflidText) { var servLoc = Cache.ServiceLocator; var text = servLoc.GetInstance <ITextFactory>().Create(); var stText = servLoc.GetInstance <IStTextFactory>().Create(); text.ContentsOA = stText; var para = servLoc.GetInstance <IStTxtParaFactory>().Create(); stText.ParagraphsOS.Add(para); hvoNewObj = text.Hvo; hvoStringObj = para.Hvo; // Set the RnGenericRec's Text property to reference the new text sdaReal.SetObjProp(m_hvoObj, m_flidEmptyProp, hvoNewObj); } else { hvoNewObj = hvoStringObj = sdaReal.MakeNewObject(m_clidDst, m_hvoObj, m_flidEmptyProp, ord); } // Set its property m_flidStringProp to tssTyped. If it is multilingual, choose based on ghostWs. var typeString = (CellarPropertyType)(mdc.GetFieldType(m_flidStringProp) & (int)CellarPropertyTypeFilter.VirtualMask); switch (typeString) { default: throw new Exception("ghost property must store strings!"); case CellarPropertyType.MultiString: case CellarPropertyType.MultiUnicode: sdaReal.SetMultiStringAlt(hvoStringObj, m_flidStringProp, m_wsToCreate, tssTyped); break; case CellarPropertyType.String: sdaReal.SetString(hvoStringObj, m_flidStringProp, tssTyped); break; } string ghostInitMethod = XmlUtils.GetOptionalAttributeValue(m_nodeObjProp, "ghostInitMethod"); if (ghostInitMethod != null) { var obj = m_fdoCache.ServiceLocator.GetInstance <ICmObjectRepository>().GetObject(hvoNewObj); Type objType = obj.GetType(); System.Reflection.MethodInfo mi = objType.GetMethod(ghostInitMethod); mi.Invoke(obj, null); } }); return(hvoNewObj); }
/// <summary> /// Implement the "Demote..." command. /// </summary> public bool OnDemoteSubitemInVector(object argument) { CheckDisposed(); if (this.Object == null) { return(false); } IRnGenericRec rec = this.Object as IRnGenericRec; if (rec == null) { return(false); // shouldn't get here } IRnGenericRec newOwner = null; if (Object.Owner is IRnGenericRec) { IRnGenericRec recOwner = Object.Owner as IRnGenericRec; if (recOwner.SubRecordsOS.Count == 2) { if (Object.OwnOrd == 0) { newOwner = recOwner.SubRecordsOS[1]; } else { newOwner = recOwner.SubRecordsOS[0]; } } else { List <IRnGenericRec> owners = new List <IRnGenericRec>(); foreach (var recT in recOwner.SubRecordsOS) { if (recT != rec) { owners.Add(recT); } } newOwner = ContainingDataTree.ChooseNewOwner(owners.ToArray(), Resources.DetailControlsStrings.ksChooseOwnerOfDemotedSubrecord); } } else { return(false); } if (newOwner == null) { return(true); } if (newOwner == rec) { throw new Exception("RnGenericRec cannot own itself!"); } UndoableUnitOfWorkHelper.DoUsingNewOrCurrentUOW(Resources.DetailControlsStrings.ksUndoDemote, Resources.DetailControlsStrings.ksRedoDemote, Cache.ActionHandlerAccessor, () => { newOwner.SubRecordsOS.Insert(0, rec); }); return(true); }
/// <summary> /// Create configuration file for analysis writing systems in Reversal Index /// </summary> /// <param name="wsMgr">IWritingSystemManager</param> /// <param name="cache">The FDO cache</param> /// <param name="defaultConfigDir">Default Configuration directory</param> /// <param name="projectsDir">Projects directory</param> /// <param name="originalProjectName">Project Name</param> public static void CreateOrRemoveReversalIndexConfigurationFiles(WritingSystemManager wsMgr, LcmCache cache, string defaultConfigDir, string projectsDir, string originalProjectName) { var defaultWsFilePath = Path.Combine(defaultConfigDir, RevIndexDir, AllIndexesFileName + ConfigFileExtension); var newWsFilePath = Path.Combine(projectsDir, originalProjectName, ConfigDir, RevIndexDir); var analysisWsArray = cache.LangProject.AnalysisWss.Trim().Replace(" ", " ").Split(' '); if (Directory.Exists(newWsFilePath)) { //Delete old Configuration Files for WS's that are no longer part of this project var files = Directory.GetFiles(newWsFilePath, "*" + ConfigFileExtension, SearchOption.AllDirectories); foreach (var file in files) { XAttribute wsAtt; GetWsAttributeFromFile(file, out wsAtt); if (wsAtt != null && !string.IsNullOrEmpty(wsAtt.Value) && !analysisWsArray.Contains(wsAtt.Value)) { File.Delete(file); } } } else { // Ensure the directory exists Directory.CreateDirectory(newWsFilePath); } //Create new Configuration File foreach (var curWs in analysisWsArray) { if (curWs.ToLower().Contains("audio")) { continue; } var curWsLabel = wsMgr.Get(curWs).DisplayLabel; var newWsCompleteFilePath = Path.Combine(newWsFilePath, curWs + ConfigFileExtension); if (File.Exists(newWsCompleteFilePath)) { XAttribute wsAtt; var configDoc = GetWsAttributeFromFile(newWsCompleteFilePath, out wsAtt); if (wsAtt == null) { // How did we get here??? Only AllReversalIndexes should have no WS! Best I can figure, this is a pre-wsAtt config var config = configDoc.Element(DictConfigElement); if (config == null || !config.HasAttributes) { File.Delete(newWsCompleteFilePath); // the file is corrupt; delete it and start over } else { config.SetAttributeValue(WsAttribute, curWs); configDoc.Save(newWsCompleteFilePath); continue; } } else if (wsAtt.Value != curWs) { // REVIEW (Hasso) 2016.09: what to do? Rename the conflicting file, or re-WS the config? Can't ask, b/c FDO has no UI // If the user has duplicated some other Reversal Index Config and given it this name, it is possible they were trying // to configure the RI for this WS. Update the Config to point to this WS wsAtt.Value = curWs; configDoc.Save(newWsCompleteFilePath); continue; } else { continue; // the file was already in the correct state; nothing to do } } File.Copy(defaultWsFilePath, newWsCompleteFilePath, false); File.SetAttributes(newWsCompleteFilePath, FileAttributes.Normal); var xmldoc = XDocument.Load(newWsCompleteFilePath); var xAttribute = xmldoc.XPathSelectElement(DictConfigElement).Attribute("name"); xAttribute.Value = curWsLabel; xAttribute = xmldoc.XPathSelectElement(DictConfigElement).Attribute(WsAttribute); xAttribute.Value = curWs; xmldoc.Save(newWsCompleteFilePath); var wsObj = wsMgr.Get(curWs); if (wsObj != null && wsObj.DisplayLabel.ToLower().IndexOf("audio", StringComparison.Ordinal) == -1) { UndoableUnitOfWorkHelper.DoUsingNewOrCurrentUOW("Undo Adding reversal Guid", "Redo Adding reversal Guid", cache.ActionHandlerAccessor, () => GetOrCreateWsGuid(wsObj, cache)); } } }