protected override TreeNode MakeMenuItems(PopupTree popupTree, int hvoTarget) { int tagNamePOS = UseAbbr ? CmPossibilityTags.kflidAbbreviation : CmPossibilityTags.kflidName; List<HvoTreeNode> relevantPartsOfSpeech = new List<HvoTreeNode>(); GatherPartsOfSpeech(Cache, List.Hvo, CmPossibilityListTags.kflidPossibilities, CmPossibilityTags.kflidSubPossibilities, PartOfSpeechTags.kflidInflectionClasses, tagNamePOS, WritingSystem, relevantPartsOfSpeech); relevantPartsOfSpeech.Sort(); int tagNameClass = UseAbbr ? MoInflClassTags.kflidAbbreviation : MoInflClassTags.kflidName; TreeNode match = null; foreach(HvoTreeNode item in relevantPartsOfSpeech) { popupTree.Nodes.Add(item); TreeNode match1 = AddNodes(item.Nodes, item.Hvo, PartOfSpeechTags.kflidInflectionClasses, MoInflClassTags.kflidSubclasses, hvoTarget, tagNameClass); if (match1 != null) match = match1; } return match; }
protected override TreeNode MakeMenuItems(PopupTree popupTree, int hvoTarget) { int tagNamePOS = UseAbbr ? (int)CmPossibility.CmPossibilityTags.kflidAbbreviation : (int)CmPossibility.CmPossibilityTags.kflidName; List<HvoTreeNode> relevantPartsOfSpeech = new List<HvoTreeNode>(); InflectionClassPopupTreeManager.GatherPartsOfSpeech(Cache, List.Hvo, (int)CmPossibilityList.CmPossibilityListTags.kflidPossibilities, (int)CmPossibility.CmPossibilityTags.kflidSubPossibilities, (int)PartOfSpeech.PartOfSpeechTags.kflidInflectableFeats, tagNamePOS, WritingSystem, relevantPartsOfSpeech); relevantPartsOfSpeech.Sort(); TreeNode match = null; foreach(HvoTreeNode item in relevantPartsOfSpeech) { popupTree.Nodes.Add(item); IPartOfSpeech pos = (IPartOfSpeech)PartOfSpeech.CreateFromDBObject(Cache, item.Hvo, false); foreach(IFsFeatStruc fs in pos.ReferenceFormsOC) { // Note: beware of using fs.ShortName. That can be // absolutely EMPTY (if the user has turned off the 'Show Abbreviation as its label' // field for both the feature category and value). // ChooserName shows the short name if it is non-empty, otherwise the long name. HvoTreeNode node = new HvoTreeNode(fs.ChooserNameTS, fs.Hvo); item.Nodes.Add(node); if (fs.Hvo == hvoTarget) match = node; } item.Nodes.Add(new HvoTreeNode(Cache.MakeUserTss(LexTextControls.ksChooseInflFeats), kMore)); } return match; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Load tool bar settings from the registry, if available. /// </summary> /// ------------------------------------------------------------------------------------ private bool LoadBarSettings() { if (m_appsRegKeyPath == null) return false; List<InitialBarProps> ibpList = new List<InitialBarProps>(); foreach (ToolStrip bar in m_bars.Values) { int dx = (int)m_appsRegKeyPath.GetValue(bar.Name + "X", -1); if (dx == -1) return false; InitialBarProps ibp = new InitialBarProps(); ibp.Name = bar.Name; ibp.Side = m_appsRegKeyPath.GetValue(bar.Name + "Side", "Top") as string; ibp.Location = new Point(dx, (int)m_appsRegKeyPath.GetValue(bar.Name + "Y", bar.Top)); string strVal = m_appsRegKeyPath.GetValue(bar.Name + "Visible") as string; bool visible; ibp.Visible = (bool.TryParse(strVal, out visible) ? visible : false); m_displayedBars[bar.Name] = ibp.Visible; ibpList.Add(ibp); } // Sort the bar information read from the registry by visibility and location. ibpList.Sort(InitialBarPropsComparer); foreach (InitialBarProps sbp in ibpList) { ToolStrip bar = m_bars[sbp.Name]; bar.Visible = sbp.Visible; bar.Location = sbp.Location; if (m_tsContainer == null) m_tsPanel.Controls.Add(bar); else { switch (sbp.Side) { case "Bottom": m_tsContainer.BottomToolStripPanel.Controls.Add(bar); break; case "Right": m_tsContainer.RightToolStripPanel.Controls.Add(bar); break; case "Left": m_tsContainer.LeftToolStripPanel.Controls.Add(bar); break; default: m_tsContainer.TopToolStripPanel.Controls.Add(bar); break; } } } return true; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Positions the toolbars to the positions specified in the xml deffinition file. /// This method only gets called when tool bar locations and visibilities cannot be /// found in the registry. /// </summary> /// ------------------------------------------------------------------------------------ private void LoadDefaultToolbarLayout() { List<InitialBarProps> ibpList = new List<InitialBarProps>(); foreach (ToolStrip bar in m_bars.Values) { InitialBarProps ibp = new InitialBarProps(); ibp.Name = bar.Name; ibp.Location = bar.Location = m_barLocations[bar]; ibp.Side = "Top"; bool isBarDisplayed; ibp.Visible = (m_displayedBars.TryGetValue(bar.Name, out isBarDisplayed) ? isBarDisplayed : false); ibpList.Add(ibp); } // Sort bars by visibility and location. ibpList.Sort(InitialBarPropsComparer); // Now add the bars to the top panel, arranging them accordingly. int prevRow = 0; int dx = 0; foreach (InitialBarProps ibp in ibpList) { ToolStrip bar = m_bars[ibp.Name]; bar.Visible = ibp.Visible; int barRow = bar.Top; if (barRow != prevRow) { prevRow = barRow; dx = 0; } bar.Top = (barRow * bar.Height); bar.Left = dx; if (m_tsContainer != null) m_tsContainer.TopToolStripPanel.Controls.Add(bar); else m_tsPanel.Controls.Add(bar); dx += (bar.Left + bar.Width); } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Fill the Style menu the "No style" item, plus a an alphabetized list of all /// character styles in stylesheet of the last Fw Edit Box to have focus. The style of /// the current selection (if there is exactly one) will be checked. If the selection /// contains no style, then "No style" will be checked. If the selection covers multiple /// styles, nothing will be checked. /// </summary> /// ------------------------------------------------------------------------------------ protected void PopulateStyleMenu() { // TODO: Convert this method to use StyleListHelper. // First clear any items added previously mnuStyle.MenuItems.Clear(); EventHandler clickEvent = new EventHandler(StyleMenu_Click); string sSelectedStyle = LastTextBoxInFocus.SelectedStyle; MenuItem mnuItem = new MenuItem(FwCoreDlgs.kstidNoStyle, clickEvent); mnuItem.Checked = (sSelectedStyle == string.Empty); mnuStyle.MenuItems.Add(mnuItem); mnuItem = new MenuItem(FdoResources.DefaultParaCharsStyleName, clickEvent); mnuItem.Checked = (sSelectedStyle == FwStyleSheet.kstrDefaultCharStyle); mnuStyle.MenuItems.Add(mnuItem); int count = 0; if (LastTextBoxInFocus.StyleSheet != null) count = LastTextBoxInFocus.StyleSheet.CStyles; string styleName; List<string> styleNames = new List<string>(count / 2); for (int i = 0; i < count; i++) { styleName = LastTextBoxInFocus.StyleSheet.get_NthStyleName(i); if (LastTextBoxInFocus.StyleSheet.GetType(styleName) == 1) // character style { ContextValues context = (ContextValues)LastTextBoxInFocus.StyleSheet.GetContext(styleName); // Exclude Internal and InternalMappable style contexts if (context != ContextValues.Internal && context != ContextValues.InternalMappable) { styleNames.Add(styleName); } } } styleNames.Sort(); foreach (string s in styleNames) { mnuItem = new MenuItem(s, clickEvent); mnuItem.Checked = (sSelectedStyle == s); mnuStyle.MenuItems.Add(mnuItem); } }
protected override void OnNextButton() { if (CurrentStepNumber == 0) { // Populate m_mappingsList based on the selected files. var sfmcounts = new Dictionary<string, int>(); var sfmOrder = new Dictionary<int, string>(); // key is 100000*fileNum + orderInFile, value is a marker int fileNum = 0; foreach (var pathName in InputFiles) { var reader = new SfmFileReaderEx(pathName); followedBy = reader.GetFollowedByInfo(); foreach (string marker in reader.SfmInfo) { int oldVal; if (!sfmcounts.TryGetValue(marker, out oldVal)) { // first time we've seen it: this file determines order; sfmOrder[fileNum * 100000 + reader.GetSFMOrder(marker)] = marker; } sfmcounts[marker] = oldVal + reader.GetSFMCount(marker); } fileNum++; } // Read the map file (unless we've been to this pane before...then use the saved settings), integrate with the sfmcount info. var savedMappings = new Dictionary<string, InterlinearMapping>(); m_oldMappings = m_firstTimeInMappingsPane ? LoadSettings() : new List<InterlinearMapping>((m_mappings)); m_firstTimeInMappingsPane = false; foreach (var mapping in m_oldMappings) savedMappings[mapping.Marker] = mapping; m_mappings.Clear(); var keys = new List<int>(sfmOrder.Keys); keys.Sort(); foreach (var key in keys) { var marker = sfmOrder[key]; InterlinearMapping mapping; if (savedMappings.TryGetValue(marker, out mapping)) { mapping = new InterlinearMapping(mapping); if (string.IsNullOrEmpty(mapping.WritingSystem)) { var ws = GetDefaultWs(mapping); if (ws != 0) mapping.WritingSystem = m_cache.WritingSystemFactory.GetStrFromWs(ws); } else if (mapping.WritingSystem == "{vern}") mapping.WritingSystem = m_cache.WritingSystemFactory.GetStrFromWs(m_cache.DefaultVernWs); } else mapping = new InterlinearMapping() {Marker = marker}; mapping.Count = sfmcounts[marker].ToString(); m_mappings.Add(mapping); } m_mappingsList.SuspendLayout(); m_mappingsList.Items.Clear(); foreach (var mapping in m_mappings) { var item = new ListViewItem("\\" + mapping.Marker); item.SubItems.Add(mapping.Count); item.SubItems.Add(GetDestinationName(mapping.Destination)); item.SubItems.Add(mapping.WritingSystem != null ? GetWritingSystemName(mapping.WritingSystem) : ""); item.SubItems.Add(mapping.Converter ?? ""); m_mappingsList.Items.Add(item); } if (m_mappingsList.Items.Count > 0) m_mappingsList.SelectedIndices.Add(0); m_mappingsList.ResumeLayout(); } else if(CurrentStepNumber == 1) { ICollection<IWritingSystem> currentVernacWSs = m_cache.LanguageProject.VernacularWritingSystems; ICollection<IWritingSystem> currentAnalysWSs = m_cache.LanguageProject.AnalysisWritingSystems; var vernToAdd = new ArrayList(); var analysToAdd = new ArrayList(); int textCount = CalculateTextCount(m_mappings, followedBy); foreach(var mapping in m_mappings) { if (mapping.Destination == InterlinDestination.Ignored) continue; // may well have no WS, in any case, we don't care whether it's in our list. bool creationCancelled = false; var ws = (IWritingSystem)m_cache.WritingSystemFactory.get_Engine(mapping.WritingSystem); if (mapping.Destination == InterlinDestination.Baseline || mapping.Destination == InterlinDestination.Wordform) { if(!currentVernacWSs.Contains(ws) && !vernToAdd.Contains(ws)) { //Show creation dialog for Vernacular var result = MessageBox.Show(this, String.Format(ITextStrings.ksImportSFMInterlinNewVernac, ws), String.Format(ITextStrings.ksImportSFMInterlinNewWSTitle, ws), MessageBoxButtons.YesNo); if(result == DialogResult.Yes) { vernToAdd.Add(ws); } else //if they bail out we won't add any writing systems, they might change them all { return; } } } else { if(!currentAnalysWSs.Contains(ws) && !analysToAdd.Contains(ws)) { var result = MessageBox.Show(this, String.Format(ITextStrings.ksImportSFMInterlinNewAnalysis, ws), String.Format(ITextStrings.ksImportSFMInterlinNewWSTitle, ws), MessageBoxButtons.YesNo); if (result == DialogResult.Yes) { analysToAdd.Add(ws); } else //if they bail out we won't add any writing systems, they might change them all { return; } } } } NonUndoableUnitOfWorkHelper.DoUsingNewOrCurrentUOW(m_cache.ActionHandlerAccessor, () => //Add all the collected new languages into the project in their proper section. { foreach (IWritingSystem analysLang in analysToAdd) { m_cache.LanguageProject.AddToCurrentAnalysisWritingSystems(analysLang); } foreach (IWritingSystem vernLang in vernToAdd) { m_cache.LanguageProject.AddToCurrentVernacularWritingSystems(vernLang); } }); if(textCount > 1) { numberOfTextsLabel.Text = String.Format(ITextStrings.ksImportSFMInterlinTextCount, textCount); } else { numberOfTextsLabel.Text = String.Empty; } } base.OnNextButton(); }
/// <summary> /// Merge the underling objects. This method handles the confirm dialog, then delegates /// the actual merge to ReallyMergeUnderlyingObject. If the flag is true, we merge /// strings and owned atomic objects; otherwise, we don't change any that aren't null /// to begin with. /// </summary> /// <param name="fLoseNoTextData"></param> public void MergeUnderlyingObject(bool fLoseNoTextData) { CheckDisposed(); var mainWindow = (Form) m_mediator.PropertyTable.GetValue("window"); using (new WaitCursor(mainWindow)) { using (var dlg = new MergeObjectDlg(m_mediator.HelpTopicProvider)) { var wp = new WindowParams(); var mergeCandidates = new List<DummyCmObject>(); string guiControl, helpTopic; DummyCmObject dObj = GetMergeinfo(wp, mergeCandidates, out guiControl, out helpTopic); mergeCandidates.Sort(); dlg.SetDlgInfo(m_cache, m_mediator, wp, dObj, mergeCandidates, guiControl, helpTopic); if (DialogResult.OK == dlg.ShowDialog(mainWindow)) ReallyMergeUnderlyingObject(dlg.Hvo, fLoseNoTextData); } } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Fill the Writing Systems menu with an alphebetized list of all writing systems /// defined in this language project. The writing system of the current selection /// (if there is exactly one) will be checked; otherwise, nothing will be checked. /// </summary> /// ------------------------------------------------------------------------------------ protected void PopulateWritingSystemMenu() { // First clear any items added previously mnuWritingSystem.MenuItems.Clear(); EventHandler clickEvent = new EventHandler(WritingSystemMenu_Click); m_htNamedWS.Clear(); // Convert from Set to List, since the Set can't sort. List<NamedWritingSystem> writingSystems = new List<NamedWritingSystem>(m_cache.LangProject.GetActiveNamedWritingSystems().ToArray()); writingSystems.Sort(); string sCurrentWs = GetCurrentWS(LastTextBoxInFocus); foreach (NamedWritingSystem nws in writingSystems) { // Writing systems come from vernacular and analysis lists and can exist in both. // Do not try to add the same WS twice. if (!m_htNamedWS.ContainsKey(nws.Name)) { m_htNamedWS.Add(nws.Name, nws); MenuItem mi = new MenuItem(nws.Name, clickEvent); mi.Checked = (sCurrentWs == nws.Name); mnuWritingSystem.MenuItems.Add(mi); } } }
/// <summary> /// This will remove the given hvosToRemove (if they exist in our sort items) and any items that refer to invalid objects. /// Reload the view if there were any changes, and adjust the CurrentIndex /// </summary> protected internal void RemoveUnwantedSortItems(List<int> hvosToRemove) { if (m_sortedObjects == null) return; // nothing to remove. bool fUpdatingListOrig = m_fUpdatingList; m_fUpdatingList = true; try { int currentIndex = CurrentIndex; int cOrigSortObjects = m_sortedObjects.Count; // Note: We start with a Set, since it can't have duplicates. // First remove the given hvos from our sort items. Set<int> unwantedIndices = new Set<int>(IndicesOfSortItems(hvosToRemove)); // then remove any remaining items that point to invalid objects. unwantedIndices.AddRange(IndicesOfInvalidSortItems()); // Put the now unique indices into a list, // so we can make sure they are processed in reverse order. List<int> sortedIndices = new List<int>(unwantedIndices.ToArray()); sortedIndices.Sort(); sortedIndices.Reverse(); foreach (int indexOfSortItem in sortedIndices) { if (indexOfSortItem >= 0) { m_sortedObjects.RemoveAt(indexOfSortItem); if (indexOfSortItem < currentIndex || SortedObjects.Count <= currentIndex) currentIndex--; } } if (m_sortedObjects.Count == 0) currentIndex = -1; else if (currentIndex >= m_sortedObjects.Count) currentIndex = m_sortedObjects.Count - 1; CurrentIndex = currentIndex; if (m_sortedObjects.Count != cOrigSortObjects) { SendPropChangedOnListChange(CurrentIndex, SortedObjects, ListChangedEventArgs.ListChangedActions.Normal); } } finally { m_fUpdatingList = fUpdatingListOrig; } }
public void ModifyOverlay(bool fApplyTag, IVwOverlay pvo, int itag) { CheckDisposed(); if (m_rootb == null) return; Debug.WriteLine("WARNING: RootSite.ModifyOverlay() isn't tested yet"); int hvo; uint clrFore; uint clrBack; uint clrUnder; int unt; bool fHidden; string uid; using (ArrayPtr arrayPtr = MarshalEx.StringToNative((int)VwConst1.kcchGuidRepLength + 1, true)) { pvo.GetDbTagInfo(itag, out hvo, out clrFore, out clrBack, out clrUnder, out unt, out fHidden, arrayPtr); uid = MarshalEx.NativeToString(arrayPtr, (int)VwConst1.kcchGuidRepLength, false); } IVwSelection vwsel; ITsTextProps[] vttp; IVwPropertyStore[] vvps; if (EditingHelper.GetCharacterProps(out vwsel, out vttp, out vvps)) { int cttp = vttp.Length; for (int ittp = 0; ittp < cttp; ittp++) { string strGuid = vttp[ittp].GetStrPropValue( (int)FwTextPropType.ktptTags); // REVIEW (EberhardB): I'm not sure if this works int cGuids = strGuid.Length / Marshal.SizeOf(typeof(Guid)); List<string> guids = new List<string>(); for (int i = 0; i < cGuids; i++) guids.Add(strGuid.Substring(i, Marshal.SizeOf(typeof(Guid)))); if (fApplyTag) { // Add the tag if it does not exist if (guids.BinarySearch(uid) >= 0) { // The tag has already been applied to the textprop, so it doesn't // need to be modified. vttp[ittp] = null; continue; } else { // We need to add the tag to the textprop. guids.Add(uid); guids.Sort(); } } else { // Remove the tag from the textprop. guids.Remove(uid); } ITsPropsBldr tpb = vttp[ittp].GetBldr(); tpb.SetStrPropValue((int)FwTextPropType.ktptTags, guids.ToString()); vttp[ittp] = tpb.GetTextProps(); } vwsel.SetSelectionProps(cttp, vttp); /* * ENHANCE (EberhardB): Implement this if we need it. It probably should be * implemented in a derived class (view class for DataNotebook?) // Update the RnGenericRec_PhraseTags table as necessary. // (Yes, this is special case code!) AfDbInfo * pdbi = NULL; AfMainWnd * pamw = m_pwndSubclass->MainWindow(); if (pamw) { AfMdiMainWnd * pammw = dynamic_cast<AfMdiMainWnd *>(pamw); AfLpInfo * plpi = NULL; if (pammw) { plpi = pammw->GetLpInfo(); if (plpi) pdbi = plpi->GetDbInfo(); } } if (pdbi) { int clevEnd; int clevAnchor; HVO hvoEnd; HVO hvoAnchor; PropTag tagEnd; PropTag tagAnchor; int ihvo; int cpropPrev; IVwPropertyStorePtr qvps; CheckHr(qvwsel->CLevels(true, &clevEnd)); Assert(clevEnd >= 1); CheckHr(qvwsel->CLevels(false, &clevAnchor)); Assert(clevAnchor >= 1); CheckHr(qvwsel->PropInfo(true, clevEnd - 1, &hvoEnd, &tagEnd, &ihvo, &cpropPrev, &qvps)); CheckHr(qvwsel->PropInfo(false, clevAnchor - 1, &hvoAnchor, &tagAnchor, &ihvo, &cpropPrev, &qvps)); IOleDbEncapPtr qode; pdbi->GetDbAccess(&qode); DbStringCrawler::UpdatePhraseTagsTable(kflidRnGenericRec_PhraseTags, fApplyTag, qode, hvo, hvoEnd, hvoAnchor); } */ } if (FindForm() == Form.ActiveForm) Focus(); }
private void FixLexRelationTypeList(LayoutTreeNode ltn) { // Get the canonical list from the project. if (m_rgRelationTypes == null) { m_rgRelationTypes = m_cache.LangProject.LexDbOA.ReferencesOA.PossibilitiesOS.ToList(); m_rgRelationTypes.Sort(ComparePossibilitiesByName); } // Add any new types to our ordered list (or fill in an empty list). var setSortedGuids = new Set<GuidAndSubClass>(); foreach (var lri in ltn.RelTypeList) setSortedGuids.Add(new GuidAndSubClass(lri.ItemGuid, lri.SubClass)); foreach (var poss in m_rgRelationTypes) { var lrt = (ILexRefType)poss; if (ltn.LexRelType == "sense") { if (lrt.MappingType == (int)LexRefTypeTags.MappingTypes.kmtEntryAsymmetricPair || lrt.MappingType == (int)LexRefTypeTags.MappingTypes.kmtEntryCollection || lrt.MappingType == (int)LexRefTypeTags.MappingTypes.kmtEntryPair || lrt.MappingType == (int)LexRefTypeTags.MappingTypes.kmtEntrySequence || lrt.MappingType == (int)LexRefTypeTags.MappingTypes.kmtEntryTree) { continue; } } else { if (lrt.MappingType == (int)LexRefTypeTags.MappingTypes.kmtSenseAsymmetricPair || lrt.MappingType == (int)LexRefTypeTags.MappingTypes.kmtSenseCollection || lrt.MappingType == (int)LexRefTypeTags.MappingTypes.kmtSensePair || lrt.MappingType == (int)LexRefTypeTags.MappingTypes.kmtSenseSequence || lrt.MappingType == (int)LexRefTypeTags.MappingTypes.kmtSenseTree) { continue; } } var gsc = new GuidAndSubClass(poss.Guid, LexReferenceInfo.TypeSubClass.Normal); if (lrt.MappingType == (int)LexRefTypeTags.MappingTypes.kmtEntryAsymmetricPair || lrt.MappingType == (int)LexRefTypeTags.MappingTypes.kmtEntryOrSenseAsymmetricPair || lrt.MappingType == (int)LexRefTypeTags.MappingTypes.kmtSenseAsymmetricPair || lrt.MappingType == (int)LexRefTypeTags.MappingTypes.kmtEntryTree || lrt.MappingType == (int)LexRefTypeTags.MappingTypes.kmtEntryOrSenseTree || lrt.MappingType == (int)LexRefTypeTags.MappingTypes.kmtSenseTree) { gsc.SubClass = LexReferenceInfo.TypeSubClass.Forward; } if (!setSortedGuids.Contains(gsc)) { var lri = new LexReferenceInfo(true, poss.Guid) { SubClass = gsc.SubClass }; ltn.RelTypeList.Add(lri); } if (gsc.SubClass == LexReferenceInfo.TypeSubClass.Forward) { gsc.SubClass = LexReferenceInfo.TypeSubClass.Reverse; if (!setSortedGuids.Contains(gsc)) { var lri = new LexReferenceInfo(true, poss.Guid) { SubClass = gsc.SubClass }; ltn.RelTypeList.Add(lri); } } } // Remove any obsolete types from our ordered list. var mapGuidType = new Dictionary<GuidAndSubClass, ILexRefType>(); foreach (var poss in m_rgRelationTypes) { var lrt = (ILexRefType)poss; var gsc = new GuidAndSubClass(lrt.Guid, LexReferenceInfo.TypeSubClass.Normal); if (lrt.MappingType == (int)LexRefTypeTags.MappingTypes.kmtEntryAsymmetricPair || lrt.MappingType == (int)LexRefTypeTags.MappingTypes.kmtEntryOrSenseAsymmetricPair || lrt.MappingType == (int)LexRefTypeTags.MappingTypes.kmtSenseAsymmetricPair || lrt.MappingType == (int)LexRefTypeTags.MappingTypes.kmtEntryTree || lrt.MappingType == (int)LexRefTypeTags.MappingTypes.kmtEntryOrSenseTree || lrt.MappingType == (int)LexRefTypeTags.MappingTypes.kmtSenseTree) { gsc.SubClass = LexReferenceInfo.TypeSubClass.Forward; } mapGuidType.Add(gsc, lrt); if (gsc.SubClass == LexReferenceInfo.TypeSubClass.Forward) { var gsc2 = new GuidAndSubClass(lrt.Guid, LexReferenceInfo.TypeSubClass.Reverse); mapGuidType.Add(gsc2, lrt); } } var obsoleteItems = ltn.RelTypeList.Where( lri => !mapGuidType.ContainsKey(new GuidAndSubClass(lri.ItemGuid, lri.SubClass))).ToList(); foreach (var lri in obsoleteItems) ltn.RelTypeList.Remove(lri); // Add the names to the items in the ordered list. foreach (var lri in ltn.RelTypeList) { var lrt = mapGuidType[new GuidAndSubClass(lri.ItemGuid, lri.SubClass)]; if (lri.SubClass == LexReferenceInfo.TypeSubClass.Reverse) lri.Name = lrt.ReverseName.BestAnalysisVernacularAlternative.Text; else lri.Name = lrt.Name.BestAnalysisVernacularAlternative.Text; } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Loads the list view, sorted by the current sort column. /// </summary> /// ------------------------------------------------------------------------------------ private void LoadListView(List<ListViewItem> list) { m_lvModel.SuspendLayout(); m_lvModel.Items.Clear(); bool sortAscending = (bool)m_lvModel.Columns[m_sortCol].Tag; list.Sort((x, y) => sortAscending ? x.SubItems[m_sortCol].Text.CompareTo(y.SubItems[m_sortCol].Text) : y.SubItems[m_sortCol].Text.CompareTo(x.SubItems[m_sortCol].Text)); m_lvModel.Items.AddRange(list.ToArray()); m_lvModel.ResumeLayout(true); }
protected void SetDlgInfo(FdoCache cache, IMoMorphType morphType, int wsVern, MorphTypeFilterType filter) { try { IVwStylesheet stylesheet = FontHeightAdjuster.StyleSheetFromMediator(m_mediator); var xnWindow = (XmlNode) m_mediator.PropertyTable.GetValue("WindowConfiguration"); XmlNode configNode = xnWindow.SelectSingleNode("controls/parameters/guicontrol[@id=\"matchingEntries\"]/parameters"); SearchEngine searchEngine = SearchEngine.Get(m_mediator, "InsertEntrySearchEngine", () => new InsertEntrySearchEngine(cache)); m_matchingObjectsBrowser.Initialize(cache, stylesheet, m_mediator, configNode, searchEngine); m_cache = cache; m_fNewlyCreated = false; m_oldForm = ""; // Set fonts for the two edit boxes. if (stylesheet != null) { m_tbLexicalForm.StyleSheet = stylesheet; m_tbGloss.StyleSheet = stylesheet; } // Set writing system factory and code for the two edit boxes. IWritingSystemContainer wsContainer = cache.ServiceLocator.WritingSystems; IWritingSystem defAnalWs = wsContainer.DefaultAnalysisWritingSystem; IWritingSystem defVernWs = wsContainer.DefaultVernacularWritingSystem; m_tbLexicalForm.WritingSystemFactory = cache.WritingSystemFactory; m_tbGloss.WritingSystemFactory = cache.WritingSystemFactory; m_tbLexicalForm.AdjustStringHeight = false; m_tbGloss.AdjustStringHeight = false; if (wsVern <= 0) wsVern = defVernWs.Handle; // initialize to empty TsStrings ITsStrFactory tsf = cache.TsStrFactory; //we need to use the wsVern so that tbLexicalForm is sized correctly for the font size. //In Interlinear text the baseline can be in any of the vernacular writing systems, not just //the defaultVernacularWritingSystem. ITsString tssForm = tsf.MakeString("", wsVern); ITsString tssGloss = tsf.MakeString("", defAnalWs.Handle); using (m_updateTextMonitor.Enter()) { m_tbLexicalForm.WritingSystemCode = wsVern; m_tbGloss.WritingSystemCode = defAnalWs.Handle; TssForm = tssForm; TssGloss = tssGloss; } // start building index m_matchingObjectsBrowser.SearchAsync(BuildSearchFieldArray(tssForm, tssGloss)); ((ISupportInitialize)(m_tbLexicalForm)).EndInit(); ((ISupportInitialize)(m_tbGloss)).EndInit(); if (WritingSystemServices.GetWritingSystemList(m_cache, WritingSystemServices.kwsVerns, false).Count > 1) { msLexicalForm = ReplaceTextBoxWithMultiStringBox(m_tbLexicalForm, WritingSystemServices.kwsVerns, stylesheet); msLexicalForm.TextChanged += tbLexicalForm_TextChanged; } else { // See if we need to adjust the height of the lexical form AdjustTextBoxAndDialogHeight(m_tbLexicalForm); } // JohnT addition: if multiple analysis writing systems, replace tbGloss with msGloss if (WritingSystemServices.GetWritingSystemList(m_cache, WritingSystemServices.kwsAnals, false).Count > 1) { msGloss = ReplaceTextBoxWithMultiStringBox(m_tbGloss, WritingSystemServices.kwsAnals, stylesheet); m_lnkAssistant.Top = msGloss.Bottom - m_lnkAssistant.Height; msGloss.TextChanged += tbGloss_TextChanged; } else { // See if we need to adjust the height of the gloss AdjustTextBoxAndDialogHeight(m_tbGloss); } m_msaGroupBox.Initialize(cache, m_mediator, m_lnkAssistant, this); // See if we need to adjust the height of the MSA group box. int oldHeight = m_msaGroupBox.Height; int newHeight = Math.Max(m_msaGroupBox.PreferredHeight, oldHeight); GrowDialogAndAdjustControls(newHeight - oldHeight, m_msaGroupBox); m_msaGroupBox.AdjustInternalControlsAndGrow(); Text = GetTitle(); m_lnkAssistant.Enabled = false; // Set font for the combobox. m_cbMorphType.Font = new Font(defAnalWs.DefaultFontName, 10); // Populate morph type combo. // first Fill ComplexFormType combo, since cbMorphType controls // whether it gets enabled and which index is selected. m_cbComplexFormType.Font = new Font(defAnalWs.DefaultFontName, 10); var rgComplexTypes = new List<ICmPossibility>(m_cache.LangProject.LexDbOA.ComplexEntryTypesOA.ReallyReallyAllPossibilities.ToArray()); rgComplexTypes.Sort(); m_idxNotComplex = m_cbComplexFormType.Items.Count; m_cbComplexFormType.Items.Add(new DummyEntryType(LexTextControls.ksNotApplicable, false)); m_idxUnknownComplex = m_cbComplexFormType.Items.Count; m_cbComplexFormType.Items.Add(new DummyEntryType(LexTextControls.ksUnknownComplexForm, true)); for (int i = 0; i < rgComplexTypes.Count; ++i) { var type = (ILexEntryType)rgComplexTypes[i]; m_cbComplexFormType.Items.Add(type); } m_cbComplexFormType.SelectedIndex = 0; m_cbComplexFormType.Visible = true; m_cbComplexFormType.Enabled = true; // Convert from Set to List, since the Set can't sort. var al = new List<IMoMorphType>(); foreach (IMoMorphType mType in m_cache.LanguageProject.LexDbOA.MorphTypesOA.ReallyReallyAllPossibilities.Cast<IMoMorphType>()) { switch (filter) { case MorphTypeFilterType.Prefix: if (mType.IsPrefixishType) al.Add(mType); break; case MorphTypeFilterType.Suffix: if (mType.IsSuffixishType) al.Add(mType); break; case MorphTypeFilterType.Any: al.Add(mType); break; } } al.Sort(); for (int i = 0; i < al.Count; ++i) { m_cbMorphType.Items.Add(al[i]); if (al[i] == morphType) m_cbMorphType.SelectedIndex = i; } m_morphType = morphType; // Is this still needed? m_msaGroupBox.MorphTypePreference = m_morphType; // Now position the searching animation /* * This position put the animation over the Glossing Assistant button. LT-9146 m_searchAnimation.Top = groupBox2.Top - m_searchAnimation.Height - 5; m_searchAnimation.Left = groupBox2.Right - m_searchAnimation.Width - 10; */ /* This position puts the animation over the top left corner, but will that * look okay with right-to-left? m_searchAnimation.Top = groupBox2.Top + 40; m_searchAnimation.Left = groupBox2.Left + 10; */ // This position puts the animation close to the middle of the list. m_searchAnimation.Top = m_matchingEntriesGroupBox.Top + (m_matchingEntriesGroupBox.Height / 2) - (m_searchAnimation.Height / 2); m_searchAnimation.Left = m_matchingEntriesGroupBox.Left + (m_matchingEntriesGroupBox.Width / 2) - (m_searchAnimation.Width / 2); } catch(Exception e) { MessageBox.Show(e.ToString()); MessageBox.Show(e.StackTrace); } }
protected void SetDlgInfo(FdoCache cache, IMoMorphType morphType, int wsVern, MorphTypeFilterType filter) { ReplaceMatchingEntriesControl(); IVwStylesheet stylesheet = null; if (m_mediator != null) { stylesheet = FontHeightAdjuster.StyleSheetFromMediator(m_mediator); if (matchingEntries != null) matchingEntries.Initialize(cache, stylesheet, m_mediator); } m_cache = cache; m_fNewlyCreated = false; m_oldForm = ""; if (m_types == null) m_types = new MoMorphTypeCollection(cache); // Set fonts for the two edit boxes. if (stylesheet != null) { tbLexicalForm.StyleSheet = stylesheet; tbGloss.StyleSheet = stylesheet; } // Set writing system factory and code for the two edit boxes. tbLexicalForm.WritingSystemFactory = cache.LanguageWritingSystemFactoryAccessor; if (wsVern <= 0) wsVern = cache.LangProject.DefaultVernacularWritingSystem; tbLexicalForm.WritingSystemCode = wsVern; tbLexicalForm.AdjustStringHeight = false; tbGloss.WritingSystemFactory = cache.LanguageWritingSystemFactoryAccessor; tbGloss.WritingSystemCode = cache.LangProject.DefaultAnalysisWritingSystem; tbGloss.AdjustStringHeight = false; // initialize to empty TsStrings ITsStrFactory tsf = TsStrFactoryClass.Create(); //we need to use the weVern so that tbLexicalForm is sized correctly for the font size. //In Interlinear text the baseline can be in any of the vernacular writing systems, not just //the defaultVernacularWritingSystem. TssForm = tsf.MakeString("", wsVern); TssGloss = tsf.MakeString("", cache.LangProject.DefaultAnalysisWritingSystem); ((System.ComponentModel.ISupportInitialize)(this.tbLexicalForm)).EndInit(); ((System.ComponentModel.ISupportInitialize)(this.tbGloss)).EndInit(); int cVern = LabeledMultiStringView.GetWritingSystemList(m_cache, LangProject.kwsVerns, false).Length; if (cVern > 1) { msLexicalForm = ReplaceTextBoxWithMultiStringBox(tbLexicalForm, LangProject.kwsVerns, stylesheet); msLexicalForm.TextChanged += new EventHandler(tbLexicalForm_TextChanged); } else { // See if we need to adjust the height of the lexical form AdjustTextBoxAndDialogHeight(tbLexicalForm); } // JohnT addition: if multiple analysis writing systems, replace tbGloss with msGloss int cWritingSystem = LabeledMultiStringView.GetWritingSystemList(m_cache, LangProject.kwsAnals, false).Length; if (cWritingSystem > 1) { msGloss = ReplaceTextBoxWithMultiStringBox(tbGloss, LangProject.kwsAnals, stylesheet); m_lnkAssistant.Top = msGloss.Bottom - m_lnkAssistant.Height; msGloss.TextChanged += new System.EventHandler(this.tbGloss_TextChanged); } else { // See if we need to adjust the height of the gloss AdjustTextBoxAndDialogHeight(tbGloss); } m_msaGroupBox.Initialize(cache, m_mediator, m_lnkAssistant, this); // See if we need to adjust the height of the MSA group box. int oldHeight = m_msaGroupBox.Height; int newHeight = Math.Max(m_msaGroupBox.PreferredHeight, oldHeight); GrowDialogAndAdjustControls(newHeight - oldHeight, m_msaGroupBox); m_msaGroupBox.AdjustInternalControlsAndGrow(); Text = GetTitle(); m_lnkAssistant.Enabled = false; // Set font for the combobox. cbMorphType.Font = new Font(cache.LangProject.DefaultAnalysisWritingSystemFont, 10); // Populate morph type combo. // first Fill ComplexFormType combo, since cbMorphType controls // whether it gets enabled and which index is selected. cbComplexFormType.Font = new Font(cache.LangProject.DefaultAnalysisWritingSystemFont, 10); List<ICmPossibility> rgComplexTypes = new List<ICmPossibility>(m_cache.LangProject.LexDbOA.ComplexEntryTypesOA.ReallyReallyAllPossibilities.ToArray()); rgComplexTypes.Sort(); m_idxNotComplex = cbComplexFormType.Items.Count; cbComplexFormType.Items.Add(new DummyEntryType(LexTextControls.ksNotApplicable, false)); m_idxUnknownComplex = cbComplexFormType.Items.Count; cbComplexFormType.Items.Add(new DummyEntryType(LexTextControls.ksUnknownComplexForm, true)); for (int i = 0; i < rgComplexTypes.Count; ++i) { ILexEntryType type = (ILexEntryType)rgComplexTypes[i]; cbComplexFormType.Items.Add(type); } cbComplexFormType.SelectedIndex = 0; cbComplexFormType.Visible = true; cbComplexFormType.Enabled = true; // Convert from Set to List, since the Set can't sort. List<ICmPossibility> al = new List<ICmPossibility>(); foreach (ICmPossibility mType in m_cache.LangProject.LexDbOA.MorphTypesOA.ReallyReallyAllPossibilities) { switch (filter) { case MorphTypeFilterType.prefix: if (MoMorphType.IsPrefixishType(m_cache, mType.Hvo)) al.Add(mType); break; case MorphTypeFilterType.suffix: if (MoMorphType.IsSuffixishType(m_cache, mType.Hvo)) al.Add(mType); break; case MorphTypeFilterType.any: al.Add(mType); break; } } al.Sort(); for (int i = 0; i < al.Count; ++i) { IMoMorphType type = (IMoMorphType)al[i]; cbMorphType.Items.Add(type); //previously had "if (type == morphType)" which was always false if (type.Equals(morphType)) cbMorphType.SelectedIndex = i; } m_morphType = morphType; // Is this still needed? m_msaGroupBox.MorphTypePreference = m_morphType; // Now position the searching animation /* * This position put the animation over the Glossing Assistant button. LT-9146 m_searchAnimtation.Top = groupBox2.Top - m_searchAnimtation.Height - 5; m_searchAnimtation.Left = groupBox2.Right - m_searchAnimtation.Width - 10; */ /* This position puts the animation over the top left corner, but will that * look okay with right-to-left? m_searchAnimtation.Top = groupBox2.Top + 40; m_searchAnimtation.Left = groupBox2.Left + 10; */ // This position puts the animation close to the middle of the list. m_searchAnimtation.Top = groupBox2.Top + (groupBox2.Top / 2); m_searchAnimtation.Left = groupBox2.Left + (groupBox2.Right / 2); }
public static void Report() { // Can't use StringCollection, because it can't sort. List<string> items = new List<string>(); foreach (KeyValuePair<string, TimeVal> kvp in s_dict) { items.Add(kvp.Key); } items.Sort(); foreach(string key in items) { Debug.WriteLine(key + ": " + s_dict[key].duration.ToString()); } s_dict.Clear(); s_blockname = ""; // just to be sure }
/// ------------------------------------------------------------------------------------ /// <summary> /// Updates the key term equivalents. /// </summary> /// <param name="progressDlg">The progress dialog box.</param> /// ------------------------------------------------------------------------------------ protected void UpdateKeyTermEquivalentsInternal(IProgress progressDlg) { List<InvalidRendering> invalidRenderings = new List<InvalidRendering>(); try { // first build a map from verses to the keyterms that should have renderings. Set<IChkTerm> chkTerms = m_ktTree.ChkTermsWithRefs; if (progressDlg != null) { progressDlg.Message = TeResourceHelper.GetResourceString("kstidUpdateKeyTermEquivalentsProgressLoading"); progressDlg.Minimum = 0; progressDlg.Maximum = chkTerms.Count; } Dictionary<int, List<KeyTermRef>> bcvToChkRefs = new Dictionary<int, List<KeyTermRef>>(); foreach (IChkTerm keyTerm in chkTerms) { AddChkRefsToBCVmap(keyTerm, ref bcvToChkRefs); if (progressDlg != null) progressDlg.Step(0); } // set progress bar to the number of verses to step through. if (progressDlg != null) { progressDlg.Minimum = 0; progressDlg.Maximum = bcvToChkRefs.Count; } // for each keyterm occurrences in each verse, make sure renderings are up to date. List<int> sortedKeys = new List<int>(bcvToChkRefs.Keys); sortedKeys.Sort(); foreach (int bcv in sortedKeys) { // REVIEW (TE-6532): For now, all Key Term Refs in the DB use the Original // versisifcation. Should we support other versifications? ScrReference currentVerse = new ScrReference(bcv, ScrVers.Original, m_scr.Versification); if (progressDlg != null) { progressDlg.Message = String.Format(TeResourceHelper.GetResourceString("kstidUpdateKeyTermEquivalentsProgressMessage"), currentVerse.AsString); } List<KeyTermRef> chkRefsForVerse = bcvToChkRefs[bcv]; foreach (KeyTermRef keyRef in chkRefsForVerse) { // skip doing anything about references that have been marked as "Ignore" if (keyRef.RenderingStatus == KeyTermRenderingStatus.Ignored) continue; if (keyRef.ChkRef.RenderingRA != null) { if (CanFindTextInVerse(keyRef.ChkRef.RenderingRA, currentVerse)) { if (keyRef.RenderingStatus == KeyTermRenderingStatus.Missing) keyRef.RenderingStatus = KeyTermRenderingStatus.Assigned; continue; } } // if an expected rendering is not found (or there was no previous assignment) // see if we can find an alternative rendering to AutoAssign. IChkTerm parentKeyTerm = (IChkTerm)keyRef.ChkRef.Owner; bool fFound = false; foreach (IChkRendering rendering in parentKeyTerm.RenderingsOC) { if (rendering.SurfaceFormRA == null) { // We found a surface form that is not defined. Later we'll need to // remove this rendering, but for now we'll continue to the next one. invalidRenderings.Add(new InvalidRendering(parentKeyTerm, rendering)); continue; } if (CanFindTextInVerse(rendering.SurfaceFormRA, currentVerse)) { try { keyRef.ChkRef.RenderingRA = rendering.SurfaceFormRA; if (keyRef.RenderingStatus != KeyTermRenderingStatus.AutoAssigned) keyRef.RenderingStatus = KeyTermRenderingStatus.AutoAssigned; fFound = true; break; } catch { // Unable to set rendering because it is invalid. invalidRenderings.Add(new InvalidRendering(parentKeyTerm, rendering)); continue; } } } if (!fFound) { if (keyRef.RenderingStatus == KeyTermRenderingStatus.Assigned && keyRef.ChkRef.RenderingRA != null) { // keep RenderingsRA info, so we know what is missing. keyRef.RenderingStatus = KeyTermRenderingStatus.Missing; } else { if (keyRef.ChkRef.RenderingRA != null) keyRef.ChkRef.RenderingRA = null; if (keyRef.RenderingStatus != KeyTermRenderingStatus.Unassigned) keyRef.RenderingStatus = KeyTermRenderingStatus.Unassigned; } } } if (progressDlg != null) progressDlg.Step(0); } } finally { if (invalidRenderings.Count > 0) { // We found at least one invalid surface form, so we need to search through our // renderings and remove any that are invalid. foreach (InvalidRendering rendering in invalidRenderings) { // Rendering may be in list twice, so only delete the valid objects if (rendering.m_rendering.IsValidObject) rendering.m_parentKeyTerm.RenderingsOC.Remove(rendering.m_rendering); } } } }
/// <summary> /// Replace SortObjects corresponding to hvoToReplace with new SortObjects for newObj. /// </summary> /// <param name="newObj"></param> /// <param name="hvoToReplace"></param> /// <param name="fAssumeSame">if true, we'll try to replace sort objects for hvoToReplace with newObj at the same indices. /// if false, we'll rely upon sorter to merge the new item into the right index, or else add to the end. /// Enhance: Is there some way we can compare the sort/filter results for newObj and hvoToReplace that is hvo indepedendent?</param> /// <returns>resulting list of newSortItems added to SortedObjects</returns> protected ArrayList ReplaceListItem(ICmObject newObj, int hvoToReplace, bool fAssumeSame) { ArrayList newSortItems = new ArrayList(); // Note: don't check NeedToReloadVirtualProperty here, so we can update the list, even if we need to // reload it at a later time. This allows joining/breaking wordforms in the Concordance tools, without // necessarily having to reload the entire list. Typically replacements will be with real ids, and those // should be stable to add in the new view. //if (NeedToReloadVirtualProperty) // return newSortItems; // we don't need to update the list, if we're planning to reload the whole thing. List<int> indicesOfSortItemsToRemove = new List<int>(IndicesOfSortItems(new List<int>(new int[] { hvoToReplace }))); ArrayList remainingInsertItems = new ArrayList(); int hvoNewObject = 0; if (newObj != null) { hvoNewObject = newObj.Hvo; // we don't want to add new sort items, if we've already added them, but we do want to allow // a replacement. if (hvoToReplace == hvoNewObject || IndexOfFirstSortItem(new List<int>(new int[] { hvoNewObject })) < 0) MakeItemsFor(newSortItems, newObj); remainingInsertItems = (ArrayList)newSortItems.Clone(); if (fAssumeSame) { //assume we're converting a dummy item to a real one. //In that case, the real item should have same basic content as the dummy item we are replacing, //so we can replace the item at the same sortItem indices. foreach (object itemToInsert in newSortItems) { if (indicesOfSortItemsToRemove.Count > 0) { int iToReplace = indicesOfSortItemsToRemove[0]; SortedObjects.RemoveAt(iToReplace); SortedObjects.Insert(iToReplace, itemToInsert); indicesOfSortItemsToRemove.RemoveAt(0); remainingInsertItems.RemoveAt(0); } else { break; } } } } // Although, ideally, during a dummy conversion there should be a one-to-one correspondence between // the sort items found for the dummy object, and the sort items generated for its real object, // it's possible that at the time we added the dummy item to the record sort list, it didn't // have the same properties matching a filter or sorter as the real item. Try to do the best we // can by removing remaining sort items for the dummy object and then adding any additional sort items // for the real object. // remove the remaining items. indicesOfSortItemsToRemove.Sort(); indicesOfSortItemsToRemove.Reverse(); foreach (int iToRemove in indicesOfSortItemsToRemove) { SortedObjects.RemoveAt(iToRemove); } // add the remaining items. if (m_sorter != null) { m_sorter.MergeInto(SortedObjects, remainingInsertItems); } else { // Add at the end. SortedObjects.AddRange(remainingInsertItems); } // update our current selected hvo, if necessary if (m_hvoCurrent == hvoToReplace) m_hvoCurrent = hvoNewObject; return newSortItems; }
private void AddWritingSystemList(UIListDisplayProperties display, Set<NamedWritingSystem> set) { List<NamedWritingSystem> list = new List<NamedWritingSystem>(set.ToArray()); // A Set doesn't know about sorting, so use a list. list.Sort(); foreach(NamedWritingSystem ws in list) { display.List.Add(ws.Name, ws.Hvo.ToString(), null, null); } }
private static List<string> GetDriveMountList() { // TODO-Linux: GetDrives() on Mono is only implemented for Linux. DriveInfo[] allDrives = DriveInfo.GetDrives(); List<string> driveMounts = new List<string>(); foreach (DriveInfo d in allDrives) { // TODO-Linux: IsReady always returns true on Mono if (!d.IsReady || d.AvailableFreeSpace == 0) continue; switch (d.DriveType) { case DriveType.Fixed: case DriveType.Network: case DriveType.Removable: if (MiscUtils.IsUnix) driveMounts.Add(d.Name + (d.Name.EndsWith("/") ? "" : "/")); // ensure terminated with a slash else driveMounts.Add(d.Name.ToLowerInvariant()); // Windows produces C:\ D:\ etc. break; } } driveMounts.Sort(longestFirst); return driveMounts; }