private void DrawTreeNodeRecursive(Graphics g, LayoutTreeNode node) { g.DrawRectangle(Pens.Black, Rectangle.Round(node.Extent)); node.Draw(g); foreach (LayoutTreeNode childNode in node.Children) { DrawTreeNodeRecursive(g, childNode); } }
private void Form1_Load(object sender, EventArgs e) { LayoutTree lTree = new LayoutTree(); lTree.VerticalSpacer = 20.0f; lTree.HorizontalSpacer = 30.0f; TextLayoutTreeNode root = lTree.CreateNode<TextLayoutTreeNode>(null); root.Text = "root"; TextLayoutTreeNode c0 = lTree.CreateNode<TextLayoutTreeNode>(root); c0.Text = "c0"; TextLayoutTreeNode c1 = lTree.CreateNode<TextLayoutTreeNode>(root); c1.Text = "aaaaaaaaaaaaa\naaaaaaaaaaaaa"; TextLayoutTreeNode c2 = lTree.CreateNode<TextLayoutTreeNode>(c1); c2.Text = "c2"; TextLayoutTreeNode c3 = lTree.CreateNode<TextLayoutTreeNode>(c1); c3.Text = "bbbbbbbbbbbb"; rootNode = root; }
private void AddUnspecifiedTypes(bool fstemBased, int cvarTypes, LayoutTreeNode ltn) { int index; if (!fstemBased) { if (!ListContainsGuid(ltn.EntryTypeList, m_unspecComplexFormType, out index)) { var unspecified = new ItemTypeInfo(true, m_unspecComplexFormType); ltn.EntryTypeList.Insert(cvarTypes, unspecified); index = cvarTypes; } ltn.EntryTypeList[index].Name = m_noComplexEntryTypeLabel; } if (!ListContainsGuid(ltn.EntryTypeList, m_unspecVariantType, out index)) { var unspecified = new ItemTypeInfo(true, m_unspecVariantType); ltn.EntryTypeList.Insert(0, unspecified); index = 0; } ltn.EntryTypeList[index].Name = m_noVariantTypeLabel; }
private void SetActiveNode(LayoutTreeNode ltn, string className, string layoutName, string partRef) { if (XmlUtils.GetOptionalAttributeValue(ltn.Configuration, "ref") == partRef && ltn.ParentLayout != null // is this ever possible? && XmlUtils.GetOptionalAttributeValue(ltn.ParentLayout, "class") == className && XmlUtils.GetOptionalAttributeValue(ltn.ParentLayout, "name") == layoutName) { m_tvParts.SelectedNode = ltn; return; } foreach (LayoutTreeNode ltnChild in ltn.Nodes) SetActiveNode(ltnChild, className, layoutName, partRef); }
private void FixEntryTypeList(LayoutTreeNode ltn, string parentLayoutName) { // Add any new types to our ordered list (or fill in an empty list). var setGuidsFromXml = new Set<Guid>(ltn.EntryTypeList.Select(info => info.ItemGuid)); Dictionary<Guid, ICmPossibility> mapGuidType; int index; switch (ltn.EntryType) { case "complex": // Get the canonical list from the project if needed. if (m_rgComplexFormTypes == null) m_rgComplexFormTypes = GetSortedFlattenedComplexFormTypeList(); mapGuidType = m_rgComplexFormTypes.ToDictionary(poss => poss.Guid); foreach (var info in from poss in m_rgComplexFormTypes where !setGuidsFromXml.Contains(poss.Guid) select new ItemTypeInfo(true, poss.Guid)) { ltn.EntryTypeList.Add(info); } if (!ListContainsGuid(ltn.EntryTypeList, m_unspecComplexFormType, out index)) { var unspecified = new ItemTypeInfo(true, m_unspecComplexFormType); ltn.EntryTypeList.Insert(0, unspecified); index = 0; } ltn.EntryTypeList[index].Name = m_noComplexEntryTypeLabel; break; case "variant": // Get the canonical list from the project if needed. if (m_rgVariantTypes == null) m_rgVariantTypes = GetSortedFlattenedVariantTypeList(); mapGuidType = m_rgVariantTypes.ToDictionary(poss => poss.Guid); foreach (var info in from poss in m_rgVariantTypes where !setGuidsFromXml.Contains(poss.Guid) select new ItemTypeInfo(true, poss.Guid)) { ltn.EntryTypeList.Add(info); } if (!ListContainsGuid(ltn.EntryTypeList, m_unspecVariantType, out index)) { var unspecified = new ItemTypeInfo(true, m_unspecVariantType); ltn.EntryTypeList.Insert(0, unspecified); index = 0; } ltn.EntryTypeList[index].Name = m_noVariantTypeLabel; break; //case "minor": default: // Should be 'minor', but treat any unknown entrytype as 'minor' var fstemBased = parentLayoutName.Contains(sdefaultStemBasedLayout); // Get the canonical Variant Type list from the project if needed. if (m_rgVariantTypes == null) m_rgVariantTypes = GetSortedFlattenedVariantTypeList(); mapGuidType = m_rgVariantTypes.ToDictionary(poss => poss.Guid); // Root-based views have Complex Forms as Minor Entries too. if (!fstemBased) { // Get the canonical Complex Form Type list from the project if needed. if (m_rgComplexFormTypes == null) m_rgComplexFormTypes = GetSortedFlattenedComplexFormTypeList(); // Add them to the map foreach (var poss in m_rgComplexFormTypes) mapGuidType.Add(poss.Guid, poss); } // Now make sure the LayoutTreeNode has the right entries foreach (var info in from kvp in mapGuidType where !setGuidsFromXml.Contains(kvp.Key) select new ItemTypeInfo(true, kvp.Key)) { ltn.EntryTypeList.Add(info); } AddUnspecifiedTypes(fstemBased, fstemBased ? 0 : m_rgVariantTypes.Count, ltn); break; } // Remove any obsolete types from our ordered list. var obsoleteItems = ltn.EntryTypeList.Where(info => !IsUnspecifiedPossibility(info) && !mapGuidType.ContainsKey(info.ItemGuid)).ToList(); foreach (var info in obsoleteItems) ltn.EntryTypeList.Remove(info); // Add the names to the items in the ordered list. foreach (var info in ltn.EntryTypeList) { if (IsUnspecifiedPossibility(info)) continue; var poss = mapGuidType[info.ItemGuid]; info.Name = poss.Name.BestAnalysisVernacularAlternative.Text; } }
private void AddChildNodes(XmlNode layout, LayoutTreeNode ltnParent, int iStart) { m_stackLayouts.Insert(0, layout); // push this layout onto the stack. try { bool fMerging = iStart < ltnParent.Nodes.Count; int iNode = iStart; string className = XmlUtils.GetManditoryAttributeValue(layout, "class"); List<XmlNode> nodes = PartGenerator.GetGeneratedChildren(layout, m_mdc, new string[] { "ref", "label" }); foreach (XmlNode node in nodes) { XmlNode subLayout; if (node.Name == "sublayout") { Debug.Assert(!fMerging); string subLayoutName = XmlUtils.GetOptionalAttributeValue(node, "name", null); if (subLayoutName == null) { subLayout = node; // a sublayout lacking a name contains the part refs directly. } else { subLayout = m_layouts.GetElement("layout", new string[] { className, "jtview", subLayoutName }); } if (subLayout != null) AddChildNodes(subLayout, ltnParent, ltnParent.Nodes.Count); } else if (node.Name == "part") { // Check whether this node has already been added to this parent. Don't add // it if it's already there! LayoutTreeNode ltnOld = FindMatchingNode(ltnParent, node); if (ltnOld != null) continue; string sRef = XmlUtils.GetManditoryAttributeValue(node, "ref"); XmlNode part = m_parts.GetElement("part", new string[] { className + "-Jt-" + sRef }); if (part == null && sRef != "$child") continue; bool fHide = XmlUtils.GetOptionalBooleanAttributeValue(node, "hideConfig", false); LayoutTreeNode ltn; if (!fHide) { ltn = new LayoutTreeNode(node, m_stringTbl, className); ltn.OriginalIndex = ltnParent.Nodes.Count; ltn.CallingLayout = m_stackLayouts[0]; ltn.ParentLayout = layout; ltn.HiddenNode = m_hidden.Part; ltn.HiddenParent = m_hidden.Layout; ltn.HiddenCallingLayout = m_hidden.Caller; if (fMerging) (ltnParent.Nodes[iNode] as LayoutTreeNode).MergedNodes.Add(ltn); else ltnParent.Nodes.Add(ltn); } else { Debug.Assert(!fMerging); ltn = ltnParent; m_hidden.Push(node, layout, m_stackLayouts[0]); } if (part != null) ProcessChildNodes(part.ChildNodes, className, ltn); ltn.OriginalNumberOfSubnodes = ltn.Nodes.Count; m_hidden.Pop(); ++iNode; } } } finally { m_stackLayouts.RemoveAt(0); // pop this layout off the stack. } }
/// <summary> /// Walk the tree of child nodes, storing information for each <obj> or <seq> /// node. /// </summary> /// <param name="xmlNodeList"></param> /// <param name="className"></param> /// <param name="ltn"></param> private void ProcessChildNodes(XmlNodeList xmlNodeList, string className, LayoutTreeNode ltn) { foreach (XmlNode xn in xmlNodeList) { if (xn is XmlComment) continue; if (xn.Name == "obj" || xn.Name == "seq" || xn.Name == "objlocal") { StoreChildNodeInfo(xn, className, ltn); } else { ProcessChildNodes(xn.ChildNodes, className, ltn); } } }
private void StoreComplexFormData(LayoutTreeNode ltn) { ltn.ShowComplexFormPara = m_chkComplexFormsAsParagraphs.Checked; }
private void CopyValuesTo(LayoutTreeNode ltn) { // Review: might be difficult to keep this up-to-date! How do we know we've got // everything in here that needs to be here?! --gjm ltn.m_cSubnodes = m_cSubnodes; ltn.m_fAllowBeforeStyle = m_fAllowBeforeStyle; ltn.m_fAllowCharStyle = m_fAllowCharStyle; ltn.m_fAllowDivParaStyle = m_fAllowDivParaStyle; ltn.m_fAllowParaStyle = m_fAllowParaStyle; ltn.m_fContentVisible = m_fContentVisible; ltn.m_fDuplicate = m_fDuplicate; //ltn.m_fHiddenChildDirty = m_fHiddenChildDirty; ltn.m_fNumSingle = m_fNumSingle; //ltn.m_fPreventNullStyle = m_fPreventNullStyle; ltn.m_fSenseIsPara = m_fSenseIsPara; ltn.m_fShowComplexFormPara = m_fShowComplexFormPara; ltn.m_fShowComplexFormParaConfig = m_fShowComplexFormParaConfig; ltn.m_fShowGramInfoConfig = m_fShowGramInfoConfig; ltn.m_fShowSenseConfig = m_fShowSenseConfig; ltn.m_fShowWsLabels = m_fShowWsLabels; ltn.m_fSingleGramInfoFirst = m_fSingleGramInfoFirst; ltn.m_fStyleFromHiddenChild = m_fStyleFromHiddenChild; ltn.m_fUseParentConfig = m_fUseParentConfig; ltn.m_idxOrig = m_idxOrig; //ltn.m_rgltnMerged = m_rgltnMerged; ltn.m_sAfter = m_sAfter; ltn.m_sBefore = m_sBefore; ltn.m_sBeforeStyleName = m_sBeforeStyleName; ltn.m_sClassName = m_sClassName; ltn.m_sDup = m_sDup; ltn.m_sFlowType = m_sFlowType; ltn.m_sLabel = m_sLabel; ltn.m_sLayoutName = m_sLayoutName; ltn.m_sNumber = m_sNumber; ltn.m_sNumFont = m_sNumFont; ltn.m_sNumStyle = m_sNumStyle; ltn.m_sParam = m_sParam; ltn.m_sPartName = m_sPartName; ltn.m_sSenseParaStyle = m_sSenseParaStyle; ltn.m_sSep = m_sSep; ltn.m_sStyleName = m_sStyleName; ltn.m_sVisibility = m_sVisibility; ltn.m_sWsLabel = m_sWsLabel; ltn.m_sWsType = m_sWsType; ltn.m_xnCallingLayout = m_xnCallingLayout; ltn.m_xnConfig = m_xnConfig; ltn.m_xnHiddenChild = m_xnHiddenChild; ltn.m_xnHiddenChildLayout = m_xnHiddenChildLayout; ltn.m_xnHiddenNode = m_xnHiddenNode; ltn.m_xnHiddenParentLayout = m_xnHiddenParentLayout; ltn.m_xnParentLayout = m_xnParentLayout; ltn.LexRelType = LexRelType; ltn.RelTypeList = RelTypeList; ltn.EntryType = EntryType; ltn.EntryTypeList = EntryTypeList; }
private void StoreSenseConfigData(LayoutTreeNode ltn) { if (m_cfgSenses.NumberStyleCombo.SelectedIndex == 0) { ltn.Number = ""; } else { ltn.Number = m_cfgSenses.BeforeNumber + ((NumberStyleComboItem)m_cfgSenses.NumberStyleCombo.SelectedItem).FormatString + m_cfgSenses.AfterNumber; ltn.NumStyle = GenerateNumStyleFromCheckBoxes(); ltn.NumFont = m_cfgSenses.NumberFontCombo.SelectedItem.ToString(); // item is a string actually... if (ltn.NumFont == xWorksStrings.ksUnspecified) ltn.NumFont = String.Empty; ltn.NumberSingleSense = m_cfgSenses.NumberSingleSense; } ltn.ShowSingleGramInfoFirst = m_chkShowSingleGramInfoFirst.Checked; // Set the information on the child grammatical info node as well. foreach (TreeNode n in ltn.Nodes) { LayoutTreeNode tn = n as LayoutTreeNode; if (tn != null && tn.ShowGramInfoConfig) { tn.ShowSingleGramInfoFirst = m_chkShowSingleGramInfoFirst.Checked; break; } } ltn.ShowSenseAsPara = m_cfgSenses.DisplaySenseInPara; ltn.SenseParaStyle = m_cfgSenses.SenseParaStyle; //ltn.SingleSenseStyle = m_cfgSenses.SingleSenseStyle; }
private void StoreGramInfoData(LayoutTreeNode ltn) { if (m_cfgSenses.Visible) return; ltn.ShowSingleGramInfoFirst = m_chkShowSingleGramInfoFirst.Checked; // Set the information on the parent sense node as well. var ltnParent = ltn.Parent as LayoutTreeNode; if (ltnParent != null && ltnParent.ShowSenseConfig) ltnParent.ShowSingleGramInfoFirst = m_chkShowSingleGramInfoFirst.Checked; }
private void MakeDivInParaChildNotVisible(LayoutTreeNode ltn, object sender) { // applies to Root dictionary ltn=Senses when ShowSenseAsPara=false var lts = sender as ConfigSenseLayout; if (lts == null) return; if (lts.DisplaySenseInPara) return; // find Stem: Main Entry-Senses-Visible Complex Forms ltn foreach (TreeNode n in ltn.Nodes) // iterate over child nodes { LayoutTreeNode tn = n as LayoutTreeNode; if (tn != null) { // meant for tn.Label == "Subentries" in root dictionary if (tn.Checked && tn.FlowType == "divInPara") { var resources = new ComponentResourceManager(typeof(XmlDocConfigureDlg)); MessageBox.Show(resources.GetString("k_RootSenseOnSubentriesGoneDlgText"), resources.GetString("k_RootSenseOnSubentriesGoneDlgLabel"), MessageBoxButtons.OK, MessageBoxIcon.Information); tn.Checked = false; break; } // meant for tn.Label.Contains("Referenced Complex Form") in stem dictionary if (tn.Checked && tn.FlowType == "span" && tn.Label.Contains(xWorksStrings.ksReferencedComplexForm) && tn.ShowComplexFormPara) { tn.ShowComplexFormPara = false; break; } } } }
private void MakeParentParaIfDivInParaVisible(LayoutTreeNode ltn) { if (ltn.Checked && ltn.FlowType == "divInPara") { var ltnParent = ltn.Parent as LayoutTreeNode; if (ltnParent != null) { ltnParent.ShowSenseAsPara = true; if (ltnParent == m_current) { DisplayCurrentNodeDetails(); } } } }
private void StoreNodeData(LayoutTreeNode ltn) { ltn.ContentVisible = ltn.Checked; if (m_tbBefore.Visible && m_tbBefore.Enabled) ltn.Before = m_tbBefore.Text; else ltn.Before = ""; // if it's invisible don't let any non-empty value be saved. if (m_tbBetween.Visible && m_tbBetween.Enabled) ltn.Between = m_tbBetween.Text; else ltn.Between = ""; // if it's invisible don't let any non-empty value be saved. if (m_tbAfter.Visible && m_tbAfter.Enabled) ltn.After = m_tbAfter.Text; else ltn.After = ""; // if it's invisible don't let any non-empty value be saved. if (m_chkDisplayWsAbbrs.Visible) ltn.ShowWsLabels = m_chkDisplayWsAbbrs.Checked && m_chkDisplayWsAbbrs.Enabled; if (m_cfgSenses.Visible) StoreSenseConfigData(ltn); if (m_chkShowSingleGramInfoFirst.Visible) StoreGramInfoData(ltn); if (m_chkComplexFormsAsParagraphs.Visible) StoreComplexFormData(ltn); if (m_cbCharStyle.Visible && m_cbCharStyle.Enabled) { var sci = m_cbCharStyle.SelectedItem as StyleComboItem; if (sci != null && sci.Style != null) ltn.StyleName = sci.Style.Name; else ltn.StyleName = String.Empty; } if (m_cbBeforeStyle.Visible && m_cbBeforeStyle.Enabled) { var sci = m_cbBeforeStyle.SelectedItem as StyleComboItem; if (sci != null && sci.Style != null) ltn.BeforeStyleName = sci.Style.Name; else ltn.BeforeStyleName = String.Empty; } if (m_lvItems.Visible && m_lvItems.Enabled) ltn.WsLabel = GenerateWsLabelFromListView(); MakeParentParaIfDivInParaVisible(ltn); }
private void m_tvParts_AfterSelect(object sender, TreeViewEventArgs e) { // Save the data for the old node before displaying the data for the new node. if (m_current != null && m_current.Level > 0) StoreNodeData(); // Set up the dialog for editing the current node's layout. m_current = e.Node as LayoutTreeNode; DisplayCurrentNodeDetails(); }
internal LayoutTreeNode CreateCopy() { var ltn = new LayoutTreeNode(); CopyValuesTo(ltn); ltn.m_xnConfig = m_xnConfig.Clone(); ltn.IsDuplicate = true; ltn.m_cSubnodes = 0; if (ltn.RelTypeList != null && ltn.RelTypeList.Count > 0) { ltn.RelTypeList = LexReferenceInfo.CreateListFromStorageString(ltn.LexRelTypeSequence); } if (ltn.EntryTypeList != null && ltn.EntryTypeList.Count > 0) { ltn.EntryTypeList = ItemTypeInfo.CreateListFromStorageString(ltn.EntryTypeSequence); } return ltn; }
private LayoutTreeNode BuildMainLayout(XmlNode config) { LayoutTreeNode ltn = new LayoutTreeNode(config, m_stringTbl, null); ltn.OriginalIndex = m_tvParts.Nodes.Count; string className = ltn.ClassName; string layoutName = ltn.LayoutName; XmlNode layout = m_layouts.GetElement("layout", new string[] { className, "jtview", layoutName }); if (layout == null) throw new Exception("Cannot configure layout " + layoutName + " of class " + className + " because it does not exist"); ltn.ParentLayout = layout; // not really the parent layout, but the parent of this node's children string sVisible = XmlUtils.GetAttributeValue(layout, "visibility"); ltn.Checked = sVisible != "never"; AddChildNodes(layout, ltn, ltn.Nodes.Count); ltn.OriginalNumberOfSubnodes = ltn.Nodes.Count; return ltn; }
private void AddChildNodes(XmlNode layout, LayoutTreeNode ltnParent, int iStart) { bool fMerging = iStart < ltnParent.Nodes.Count; int iNode = iStart; string className = XmlUtils.GetManditoryAttributeValue(layout, "class"); List<XmlNode> nodes = PartGenerator.GetGeneratedChildren(layout, m_cache, new[] { "ref", "label" }); foreach (XmlNode node in nodes) { XmlNode subLayout; if (node.Name == "sublayout") { Debug.Assert(!fMerging); string subLayoutName = XmlUtils.GetOptionalAttributeValue(node, "name", null); if (subLayoutName == null) { subLayout = node; // a sublayout lacking a name contains the part refs directly. } else { subLayout = m_layouts.GetElement("layout", new[] { className, "jtview", subLayoutName, null }); } if (subLayout != null) AddChildNodes(subLayout, ltnParent, ltnParent.Nodes.Count); } else if (node.Name == "part") { // Check whether this node has already been added to this parent. Don't add // it if it's already there! LayoutTreeNode ltnOld = FindMatchingNode(ltnParent, node); if (ltnOld != null) continue; string sRef = XmlUtils.GetManditoryAttributeValue(node, "ref"); XmlNode part = m_parts.GetElement("part", new[] { className + "-Jt-" + sRef }); if (part == null && sRef != "$child") continue; bool fHide = XmlUtils.GetOptionalBooleanAttributeValue(node, "hideConfig", false); LayoutTreeNode ltn; var cOrig = 0; if (!fHide) { ltn = new LayoutTreeNode(node, m_stringTbl, className) { OriginalIndex = ltnParent.Nodes.Count, ParentLayout = layout, HiddenNode = m_levels.HiddenPartRef, HiddenNodeLayout = m_levels.HiddenLayout }; if (!String.IsNullOrEmpty(ltn.LexRelType)) FixLexRelationTypeList(ltn); if (!String.IsNullOrEmpty(ltn.EntryType)) FixEntryTypeList(ltn, ltnParent.LayoutName); //if (fMerging) //((LayoutTreeNode)ltnParent.Nodes[iNode]).MergedNodes.Add(ltn); //else ltnParent.Nodes.Add(ltn); } else { Debug.Assert(!fMerging); ltn = ltnParent; cOrig = ltn.Nodes.Count; if (className == "StTxtPara") { ltnParent.HiddenChildLayout = layout; ltnParent.HiddenChild = node; } } try { m_levels.Push(node, layout); var fOldAdding = ltn.AddingSubnodes; ltn.AddingSubnodes = true; if (part != null) ProcessChildNodes(part.ChildNodes, className, ltn); ltn.OriginalNumberOfSubnodes = ltn.Nodes.Count; ltn.AddingSubnodes = fOldAdding; if (fHide) { var cNew = ltn.Nodes.Count - cOrig; var msg = String.Format("{0} nodes for a hidden PartRef ({1})!", cNew, node.OuterXml); //Debug.Assert(cNew <= 1, msg); //if (cNew > 1) // Debug.WriteLine(msg); } } finally { m_levels.Pop(); } ++iNode; } } }
private LayoutTreeNode FindMatchingNode(LayoutTreeNode ltn, XmlNode node) { if (ltn == null || node == null) return null; foreach (LayoutTreeNode ltnSub in ltn.Nodes) { if (ltnSub.Configuration == node) return ltnSub; } return FindMatchingNode(ltn.Parent as LayoutTreeNode, node); }
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; } }
private void StoreChildNodeInfo(XmlNode xn, string className, LayoutTreeNode ltn) { string sField = XmlUtils.GetManditoryAttributeValue(xn, "field"); if (ltn.Level > 0) { if (sField == "Senses" && (ltn.ClassName == "LexEntry" || ltn.ClassName == "LexSense")) { ltn.ShowSenseConfig = true; } else if (sField == "ReferringSenses" && ltn.ClassName == "ReversalIndexEntry") { ltn.ShowSenseConfig = true; } if (sField == "MorphoSyntaxAnalysis" && ltn.ClassName == "LexSense") { ltn.ShowGramInfoConfig = true; } if (sField == "ComplexFormEntryBackRefs" && ltn.ClassName == "LexEntry") { string sShowAsIndentedPara = XmlUtils.GetAttributeValue(ltn.Configuration, "showasindentedpara"); ltn.ShowComplexFormParaConfig = !String.IsNullOrEmpty(sShowAsIndentedPara); } } bool fRecurse = XmlUtils.GetOptionalBooleanAttributeValue(ltn.Configuration, "recurseConfig", true); if (!fRecurse) { // We don't want to recurse forever just because senses have subsenses, which // can have subsenses, which can ... // Or because entries have subentries (in root type layouts)... ltn.UseParentConfig = true; return; } XmlNode xnCaller = m_hidden.Part; if (xnCaller == null) xnCaller = ltn.Configuration; string sLayout = XmlVc.GetLayoutName(xn, xnCaller); int flid = 0; uint clidDst = 0; string sClass = null; string sTargetClasses = null; try { flid = m_cache.GetFlid(0, className, sField); if ((int)flid == 0) return; FieldType type = m_cache.GetFieldType(flid); Debug.Assert(type >= FieldType.kcptMinObj); if (type >= FieldType.kcptMinObj) { sTargetClasses = XmlUtils.GetOptionalAttributeValue(xn, "targetclasses"); if (flid < (int)CmObject.SpecialTagValues.ktagMinVp) { clidDst = m_mdc.GetDstClsId((uint)flid); if (clidDst == 0) sClass = XmlUtils.GetOptionalAttributeValue(xn, "targetclass"); else sClass = m_mdc.GetClassName(clidDst); } else { sClass = XmlUtils.GetOptionalAttributeValue(xn, "targetclass"); } } } catch { } if (clidDst == (uint)MoForm.kclsidMoForm && !sLayout.StartsWith("publi")) return; // ignore the layouts used by the LexEntry-Jt-Headword part. if (String.IsNullOrEmpty(sLayout) || String.IsNullOrEmpty(sClass)) return; if (sTargetClasses == null) sTargetClasses = sClass; string[] rgsClasses = sTargetClasses.Split(new char[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries); XmlNode subLayout = null; if (rgsClasses.Length > 0) subLayout = m_layouts.GetElement("layout", new string[] { rgsClasses[0], "jtview", sLayout }); if (subLayout != null) { int iStart = ltn.Nodes.Count; int cNodes = subLayout.ChildNodes.Count; AddChildNodes(subLayout, ltn, iStart); bool fRepeatedConfig = XmlUtils.GetOptionalBooleanAttributeValue(xn, "repeatedConfig", false); if (fRepeatedConfig) return; // repeats an earlier part element (probably as a result of <if>s) for (int i = 1; i < rgsClasses.Length; i++) { XmlNode mergedLayout = m_layouts.GetElement("layout", new string[] { rgsClasses[i], "jtview", sLayout }); if (mergedLayout != null && mergedLayout.ChildNodes.Count == cNodes) { AddChildNodes(mergedLayout, ltn, iStart); } } } }
private void StoreChildNodeInfo(XmlNode xn, string className, LayoutTreeNode ltn) { string sField = XmlUtils.GetManditoryAttributeValue(xn, "field"); XmlNode xnCaller = m_levels.PartRef; if (xnCaller == null) xnCaller = ltn.Configuration; bool hideConfig = xnCaller == null ? false : XmlUtils.GetOptionalBooleanAttributeValue(xnCaller, "hideConfig", false); // Insert any special configuration appropriate for this property...unless the caller is hidden, in which case, // we don't want to configure it at all. if (!ltn.IsTopLevel && !hideConfig) { if (sField == "Senses" && (ltn.ClassName == "LexEntry" || ltn.ClassName == "LexSense")) { ltn.ShowSenseConfig = true; } else if (sField == "ReferringSenses" && ltn.ClassName == "ReversalIndexEntry") { ltn.ShowSenseConfig = true; } if (sField == "MorphoSyntaxAnalysis" && ltn.ClassName == "LexSense") { ltn.ShowGramInfoConfig = true; } if (sField == "VisibleComplexFormBackRefs" || sField == "ComplexFormsNotSubentries") { //The existence of the attribute is important for this setting, not its value! var sShowAsIndentedPara = XmlUtils.GetAttributeValue(ltn.Configuration, "showasindentedpara"); ltn.ShowComplexFormParaConfig = !String.IsNullOrEmpty(sShowAsIndentedPara); } } bool fRecurse = XmlUtils.GetOptionalBooleanAttributeValue(ltn.Configuration, "recurseConfig", true); if (!fRecurse) { // We don't want to recurse forever just because senses have subsenses, which // can have subsenses, which can ... // Or because entries have subentries (in root type layouts)... ltn.UseParentConfig = true; return; } string sLayout = XmlVc.GetLayoutName(xn, xnCaller); int clidDst = 0; string sClass = null; string sTargetClasses = null; try { // Failure should be fairly unusual, but, for example, part MoForm-Jt-FormEnvPub attempts to display // the property PhoneEnv inside an if that checks that the MoForm is one of the subclasses that has // the PhoneEnv property. MoForm itself does not. if (!((FDO.Infrastructure.IFwMetaDataCacheManaged)m_cache.DomainDataByFlid.MetaDataCache).FieldExists(className, sField, true)) return; int flid = m_cache.DomainDataByFlid.MetaDataCache.GetFieldId(className, sField, true); CellarPropertyType type = (CellarPropertyType)m_cache.DomainDataByFlid.MetaDataCache.GetFieldType(flid); Debug.Assert(type >= CellarPropertyType.MinObj); if (type >= CellarPropertyType.MinObj) { sTargetClasses = XmlUtils.GetOptionalAttributeValue(xn, "targetclasses"); clidDst = m_mdc.GetDstClsId(flid); if (clidDst == 0) sClass = XmlUtils.GetOptionalAttributeValue(xn, "targetclass"); else sClass = m_mdc.GetClassName(clidDst); if (clidDst == StParaTags.kClassId) { string sClassT = XmlUtils.GetOptionalAttributeValue(xn, "targetclass"); if (!String.IsNullOrEmpty(sClassT)) sClass = sClassT; } } } catch { return; } if (clidDst == MoFormTags.kClassId && !sLayout.StartsWith("publi")) return; // ignore the layouts used by the LexEntry-Jt-Headword part. if (String.IsNullOrEmpty(sLayout) || String.IsNullOrEmpty(sClass)) return; if (sTargetClasses == null) sTargetClasses = sClass; string[] rgsClasses = sTargetClasses.Split(new[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries); XmlNode subLayout = null; if (rgsClasses.Length > 0) subLayout = m_layouts.GetElement("layout", new[] { rgsClasses[0], "jtview", sLayout, null }); if (subLayout != null) { int iStart = ltn.Nodes.Count; int cNodes = subLayout.ChildNodes.Count; AddChildNodes(subLayout, ltn, iStart); bool fRepeatedConfig = XmlUtils.GetOptionalBooleanAttributeValue(xn, "repeatedConfig", false); if (fRepeatedConfig) return; // repeats an earlier part element (probably as a result of <if>s) for (int i = 1; i < rgsClasses.Length; i++) { XmlNode mergedLayout = m_layouts.GetElement("layout", new[] { rgsClasses[i], "jtview", sLayout, null }); if (mergedLayout != null && mergedLayout.ChildNodes.Count == cNodes) { AddChildNodes(mergedLayout, ltn, iStart); } } } else { // The "layout" in a part node can actually refer directly to another part, so check // for that possibility. var subPart = m_parts.GetElement("part", new[] { rgsClasses[0] + "-Jt-" + sLayout }) ?? m_parts.GetElement("part", new[] { className + "-Jt-" + sLayout }); if (subPart == null && !sLayout.EndsWith("-en")) { // Complain if we can't find either a layout or a part, and the name isn't tagged // for a writing system. (We check only for English, being lazy.) var msg = String.Format("Missing jtview layout for class=\"{0}\" name=\"{1}\"", rgsClasses[0], sLayout); Debug.Assert(subLayout != null, msg); //Debug.WriteLine(msg); } } }