BamlLocalizerError _error; // The error code. internal BamlLocalizerErrorNotifyEventArgs(BamlLocalizableResourceKey key, BamlLocalizerError error) { _key = key; // _error = error; }
internal static string ResourceKeyToString(BamlLocalizableResourceKey key) { return string.Format( CultureInfo.InvariantCulture, "{0}:{1}.{2}", key.Uid, key.ClassName, key.PropertyName ); }
public BamlLocalizableResource this [BamlLocalizableResourceKey key] { get { return(default(BamlLocalizableResource)); } set { } }
/// <summary> /// Compare two BamlLocalizableResourceKey objects /// </summary> /// <param name="other">The other BamlLocalizableResourceKey object to be compared against</param> /// <returns>True if they are equal. False otherwise</returns> public bool Equals(BamlLocalizableResourceKey other) { if (other == null) { return(false); } return(_uid == other._uid && _className == other._className && _propertyName == other._propertyName); }
/// <summary> /// Gets or sets a localizable resource by the key /// </summary> /// <param name="key">BamlLocalizableResourceKey key</param> /// <returns>BamlLocalizableResource object identified by the key</returns> public BamlLocalizableResource this[BamlLocalizableResourceKey key] { get { CheckNonNullParam(key, "key"); return(_dictionary[key]); } set { CheckNonNullParam(key, "key"); _dictionary[key] = value; } }
public bool Contains(BamlLocalizableResourceKey key) { return default(bool); }
private static IList<BamlTreeNode> SplitXmlContent( BamlLocalizableResourceKey key, string content, BamlTreeUpdateMap bamlTreeMap ) { // process each translation as a piece of xml content because of potential formatting tag inside StringBuilder xmlContent = new StringBuilder(); xmlContent.Append("<ROOT>"); xmlContent.Append(content); xmlContent.Append("</ROOT>"); IList<BamlTreeNode> list = new List<BamlTreeNode>(4); XmlDocument doc = new XmlDocument(); bool succeed = true; try { doc.LoadXml(xmlContent.ToString()); XmlElement root = doc.FirstChild as XmlElement; if (root != null && root.HasChildNodes) { for (int i = 0; i < root.ChildNodes.Count && succeed; i++) { succeed = GetBamlTreeNodeFromXmlNode( key, root.ChildNodes[i], bamlTreeMap, list ); } } } catch (XmlException) { // The content can't be parse as Xml. bamlTreeMap.Resolver.RaiseErrorNotifyEvent( new BamlLocalizerErrorNotifyEventArgs( key, BamlLocalizerError.SubstitutionAsPlaintext ) ); // Apply the substitution as plain text succeed = GetBamlTreeNodeFromText( key, content, bamlTreeMap, list ); } return (succeed ? list : null); }
private static bool GetBamlTreeNodeFromText( BamlLocalizableResourceKey key, string content, // xml node to construct BamlTreeNode from BamlTreeUpdateMap bamlTreeMap, IList<BamlTreeNode> newChildrenList // list of new children ) { BamlStringToken[] tokens = BamlResourceContentUtil.ParseChildPlaceholder(content); if (tokens == null) { bamlTreeMap.Resolver.RaiseErrorNotifyEvent( new BamlLocalizerErrorNotifyEventArgs( key, BamlLocalizerError.IncompleteElementPlaceholder ) ); return false; } bool succeed = true; for (int i = 0; i < tokens.Length; i++) { switch (tokens[i].Type) { case BamlStringToken.TokenType.Text : { BamlTreeNode node = new BamlTextNode(tokens[i].Value); newChildrenList.Add(node); break; } case BamlStringToken.TokenType.ChildPlaceHolder : { BamlTreeNode node = bamlTreeMap.MapUidToBamlTreeElementNode(tokens[i].Value); // The value will be null if there is no uid-matching node in the tree. if (node != null) { newChildrenList.Add(node); } else { bamlTreeMap.Resolver.RaiseErrorNotifyEvent( new BamlLocalizerErrorNotifyEventArgs( new BamlLocalizableResourceKey( tokens[i].Value, string.Empty, string.Empty ), BamlLocalizerError.InvalidUid ) ); succeed = false; } break; } } } return succeed; }
/// <summary> /// build a localizable resource from a baml tree node /// </summary> internal BamlLocalizableResource BuildFromNode(BamlLocalizableResourceKey key, BamlTreeNode node) { if (node.Formatted) { // the content of the node has been formatted to be part of // parents' content, so no need to create a seperate entry for the // element return null; } BamlLocalizableResource resource = null; LocalizabilityAttribute localizability = null; string formattingTag; // // variable controling what comments gets applied // BamlStartElementNode commentNode = null; // node containing comment string commentTargetName = null; // the target of the comment, e.g. $Content, FontSize, etc. // // step 1: Get the localizability attribute from the source files // switch(node.NodeType) { case BamlNodeType.StartElement: { // For element commentNode = (BamlStartElementNode) node; GetLocalizabilityForElementNode(commentNode, out localizability, out formattingTag); commentTargetName = BamlConst.ContentSuffix; break; } case BamlNodeType.LiteralContent: { // For literal content, get the attribute from parent element GetLocalizabilityForElementNode((BamlStartElementNode) node.Parent, out localizability, out formattingTag); commentNode = (BamlStartElementNode) node.Parent; commentTargetName = BamlConst.ContentSuffix; break; } case BamlNodeType.Property: { BamlStartComplexPropertyNode propertyNode = (BamlStartComplexPropertyNode) node; if ( LocComments.IsLocCommentsProperty(propertyNode.OwnerTypeFullName, propertyNode.PropertyName) || LocComments.IsLocLocalizabilityProperty(propertyNode.OwnerTypeFullName, propertyNode.PropertyName) ) { // skip Localization.Comments and Localization.Attributes properties. They aren't localizable return null; } // For property GetLocalizabilityForPropertyNode(propertyNode, out localizability); commentTargetName = propertyNode.PropertyName; commentNode = (BamlStartElementNode) node.Parent; break; } default: { Invariant.Assert(false); // no localizable resource for such node break; } } // // Step 2: Find out the inheritance value // // The node participates in localizability inheritance // let's fill things in localizability = CombineAndPropagateInheritanceValues( node as ILocalizabilityInheritable, localizability ); // // Step 3: We finalized the localizability values. We now apply. // string content = null; if (localizability.Category != LocalizationCategory.NeverLocalize && localizability.Category != LocalizationCategory.Ignore && TryGetContent(key, node, out content)) { // we only create one if it is localizable resource = new BamlLocalizableResource(); resource.Readable = (localizability.Readability == Readability.Readable); resource.Modifiable = (localizability.Modifiability == Modifiability.Modifiable); resource.Category = localizability.Category; // continue to fill in content. resource.Content = content; resource.Comments = _resolver.GetStringComment(commentNode, commentTargetName); } // return the resource return resource; }
private static void ReArrangeChildren( BamlLocalizableResourceKey key, BamlTreeNode node, string translation, BamlTreeUpdateMap treeMap ) { // // Split the translation into a list of BamlNodes. // IList<BamlTreeNode> nodes = SplitXmlContent( key, translation, treeMap ); // merge the nodes from translation with the source nodes MergeChildrenList(key, treeMap, node, nodes); }
/// <summary> /// Compare two BamlLocalizableResourceKey objects /// </summary> /// <param name="other">The other BamlLocalizableResourceKey object to be compared against</param> /// <returns>True if they are equal. False otherwise</returns> public bool Equals(BamlLocalizableResourceKey other) { if (other == null) { return false; } return _uid == other._uid && _className == other._className && _propertyName == other._propertyName; }
/// <summary> /// This builds the localizable string from the baml tree node /// </summary> /// <return> /// return true when the node has valid localizable content, false otherwise. /// </return> internal bool TryGetContent(BamlLocalizableResourceKey key, BamlTreeNode currentNode, out string content) { content = string.Empty; switch (currentNode.NodeType) { case BamlNodeType.Property : { bool isValidContent = true; BamlPropertyNode propertyNode = (BamlPropertyNode) currentNode; content = BamlResourceContentUtil.EscapeString(propertyNode.Value); // // Markup extensions are not localizable values, e.g. {x:Type SolidColorBrush}. // So if the string can be parsed as Markup extensions, we will exclude it unless // the user sets localization comments explicitly to localize this value. // string typeName, args; string tempContent = content; if (MarkupExtensionParser.GetMarkupExtensionTypeAndArgs(ref tempContent, out typeName, out args)) { // See if this value has been marked as localizable explicitly in comments LocalizabilityGroup localizability = _resolver.GetLocalizabilityComment( propertyNode.Parent as BamlStartElementNode, propertyNode.PropertyName ); isValidContent = (localizability != null && localizability.Readability == Readability.Readable); } return isValidContent; } case BamlNodeType.LiteralContent : { content = BamlResourceContentUtil.EscapeString( ((BamlLiteralContentNode)currentNode).Content ); return true; // succeed } case BamlNodeType.StartElement : { BamlStartElementNode elementNode = (BamlStartElementNode) currentNode; if (elementNode.Content == null) { StringBuilder contentBuilder = new StringBuilder(); foreach(BamlTreeNode child in elementNode.Children) { // we only format element and text inline // other nodes like property node we don't put them into the content of the element switch (child.NodeType) { case BamlNodeType.StartElement : { string childContent; if (TryFormatElementContent(key,(BamlStartElementNode)child, out childContent)) { contentBuilder.Append(childContent); } else { return false; // failed to get content for children element } break; } case BamlNodeType.Text : { contentBuilder.Append(BamlResourceContentUtil.EscapeString( ((BamlTextNode)child).Content) ); break; } } } elementNode.Content = contentBuilder.ToString(); } content = elementNode.Content; return true; } default : return true; } }
/// <summary> /// determines whether the dictionary contains the localizable resource /// with the specified key /// </summary> /// <param name="key"></param> /// <returns></returns> public bool Contains(BamlLocalizableResourceKey key) { CheckNonNullParam(key, "key"); return _dictionary.ContainsKey(key); }
internal void SetRootElementKey(BamlLocalizableResourceKey key) { _rootElementKey = key; }
/// <summary> /// Adds a localizable resource with the provided key /// </summary> /// <param name="key">the BamlLocalizableResourceKey key</param> /// <param name="value">the BamlLocalizableResource</param> public void Add(BamlLocalizableResourceKey key, BamlLocalizableResource value) { CheckNonNullParam(key, "key"); _dictionary.Add(key, value); }
/// <summary> /// removes the localizable resource with the specified key /// </summary> /// <param name="key">the key</param> public void Remove(BamlLocalizableResourceKey key) { _dictionary.Remove(key); }
/// <summary> /// Gets or sets a localizable resource by the key /// </summary> /// <param name="key">BamlLocalizableResourceKey key</param> /// <returns>BamlLocalizableResource object identified by the key</returns> public BamlLocalizableResource this[BamlLocalizableResourceKey key] { get { CheckNonNullParam(key, "key"); return _dictionary[key]; } set { CheckNonNullParam(key, "key"); _dictionary[key] = value; } }
/// <summary>Compares two instances of <see cref="T:System.Windows.Markup.Localizer.BamlLocalizableResourceKey" /> for equality.</summary> /// <param name="other">The other instance of <see cref="T:System.Windows.Markup.Localizer.BamlLocalizableResourceKey" /> to compare for equality.</param> /// <returns> /// <see langword="true" /> if the two instances are equal; otherwise, <see langword="false" />.</returns> // Token: 0x060024E0 RID: 9440 RVA: 0x000B297E File Offset: 0x000B0B7E public bool Equals(BamlLocalizableResourceKey other) { return(other != null && (this._uid == other._uid && this._className == other._className) && this._propertyName == other._propertyName); }
public void Remove(BamlLocalizableResourceKey key) { }
//------------------------------------------------- // Internal static //------------------------------------------------- /// <summary> /// Return the localizable resource key for this baml tree node. /// If this node shouldn't be localized, the key returned will be null. /// </summary> internal static BamlLocalizableResourceKey GetKey(BamlTreeNode node) { BamlLocalizableResourceKey key = null; switch (node.NodeType) { case BamlNodeType.StartElement: { BamlStartElementNode elementNode = (BamlStartElementNode) node; if (elementNode.Uid != null) { key = new BamlLocalizableResourceKey( elementNode.Uid, elementNode.TypeFullName, BamlConst.ContentSuffix, elementNode.AssemblyName ); } break; } case BamlNodeType.Property: { BamlPropertyNode propertyNode = (BamlPropertyNode) node; BamlStartElementNode parent = (BamlStartElementNode) propertyNode.Parent; if (parent.Uid != null) { string uid; if (propertyNode.Index <= 0) { uid = parent.Uid; } else { // This node is auto-numbered. This has to do with the fact that // the compiler may compile duplicated properties into Baml under the same element. uid = string.Format( TypeConverterHelper.InvariantEnglishUS, "{0}.{1}_{2}", parent.Uid, propertyNode.PropertyName, propertyNode.Index ); } key = new BamlLocalizableResourceKey( uid, propertyNode.OwnerTypeFullName, propertyNode.PropertyName, propertyNode.AssemblyName ); } break; } case BamlNodeType.LiteralContent: { BamlLiteralContentNode literalNode = (BamlLiteralContentNode) node; BamlStartElementNode parent = (BamlStartElementNode) node.Parent; if (parent.Uid != null) { key = new BamlLocalizableResourceKey( parent.Uid, parent.TypeFullName, BamlConst.LiteralContentSuffix, parent.AssemblyName ); } break; } } return key; }
/// <summary> /// Maps a key to a baml tree node in the given tree /// </summary> internal BamlTreeNode MapKeyToBamlTreeNode(BamlLocalizableResourceKey key, BamlTree tree) { if (_keyToBamlNodeIndexMap.Contains(key)) { return tree[(int)_keyToBamlNodeIndexMap[key]]; } return null; }
public bool Contains(BamlLocalizableResourceKey key) { return(default(bool)); }
public BamlLocalizableResource this [BamlLocalizableResourceKey key] { get { return default(BamlLocalizableResource); } set { } }
private bool TryFormatElementContent( BamlLocalizableResourceKey key, BamlStartElementNode node, out string content ) { content = string.Empty; string formattingTag; LocalizabilityAttribute attribute; GetLocalizabilityForElementNode(node, out attribute, out formattingTag); attribute = CombineAndPropagateInheritanceValues(node, attribute); if ( formattingTag != null && attribute.Category != LocalizationCategory.NeverLocalize && attribute.Category != LocalizationCategory.Ignore && attribute.Modifiability == Modifiability.Modifiable && attribute.Readability == Readability.Readable ) { // this node should be formatted inline StringBuilder contentBuilder = new StringBuilder(); // write opening tag if (node.Uid != null) { contentBuilder.AppendFormat( TypeConverterHelper.InvariantEnglishUS, "<{0} {1}=\"{2}\">", formattingTag, XamlReaderHelper.DefinitionUid, BamlResourceContentUtil.EscapeString(node.Uid) ); } else { contentBuilder.AppendFormat(TypeConverterHelper.InvariantEnglishUS, "<{0}>", formattingTag); } // recurisively call down to format the content string childContent; bool succeed = TryGetContent(key, node, out childContent); if (succeed) { contentBuilder.Append(childContent); // write closing tag contentBuilder.AppendFormat(TypeConverterHelper.InvariantEnglishUS, "</{0}>", formattingTag); // remeber that we format this element so that we don't format the value again. // e.g. <Text x:Uid="t"> <Bold x:Uid="b"> ... </Bold> </Text> // if <Bold> is already inlined in Text element's contennt, we don't need to // have a seperate entry for <Bold> anymore node.Formatted = true; content = contentBuilder.ToString(); } return succeed; } else { // this node should be represented by place holder. bool succeed = true; if (node.Uid != null) { content = string.Format( TypeConverterHelper.InvariantEnglishUS, "{0}{1}{2}", BamlConst.ChildStart, BamlResourceContentUtil.EscapeString(node.Uid), BamlConst.ChildEnd ); } else { // we want to enforce the rule that all children element // must have UID defined. _resolver.RaiseErrorNotifyEvent( new BamlLocalizerErrorNotifyEventArgs( key, BamlLocalizerError.UidMissingOnChildElement ) ); succeed = false; // failed } return succeed; } }
internal bool IsNewBamlTreeNode(BamlLocalizableResourceKey key) { return _keyToNewBamlNodeIndexMap.Contains(key); }
private static bool ApplyChangeToBamlTree( BamlLocalizableResourceKey key, BamlLocalizableResource resource, BamlTreeUpdateMap treeMap ) { if ( resource == null || resource.Content == null || !resource.Modifiable) { // Invalid translation or the resource is marked as non-modifiable. return true; } if ( !treeMap.LocalizationDictionary.Contains(key) && !treeMap.IsNewBamlTreeNode(key)) { // A localizable node is either in the localization dicationary extracted // from the source or it is a new node created by the localizer. // Otherwise, we cannot modify it. return true; } // get the node, at this point, all the missing nodes are created BamlTreeNode node = treeMap.MapKeyToBamlTreeNode(key); Invariant.Assert(node != null); // apply translations switch (node.NodeType) { case BamlNodeType.LiteralContent : { BamlLiteralContentNode literalNode = (BamlLiteralContentNode) node; // set the content to the node. literalNode.Content = BamlResourceContentUtil.UnescapeString(resource.Content); // now try to link this node into the parent. if (literalNode.Parent == null) { BamlTreeNode parent = treeMap.MapUidToBamlTreeElementNode(key.Uid); if (parent != null) { // link it up with the parent parent.AddChild(literalNode); } else { return false; // can't resolve the parent yet } } break; } case BamlNodeType.Property : { BamlPropertyNode propertyNode = (BamlPropertyNode) node; // set the translation into the property propertyNode.Value = BamlResourceContentUtil.UnescapeString(resource.Content); // now try to link this node into the parent if (propertyNode.Parent == null) { BamlStartElementNode parent = (BamlStartElementNode) treeMap.MapUidToBamlTreeElementNode(key.Uid); if (parent != null) { // insert property node to the parent parent.InsertProperty(node); } else { return false; } } break; } case BamlNodeType.StartElement : { string source = null; if (treeMap.LocalizationDictionary.Contains(key)) { source = ((BamlLocalizableResource) treeMap.LocalizationDictionary[key]).Content; } if (resource.Content != source) { // only rearrange the value if source and update are different ReArrangeChildren(key, node, resource.Content, treeMap); } break; } default : break; } return true; }
public void Add(BamlLocalizableResourceKey key, BamlLocalizableResource value) { }
private static void MergeChildrenList( BamlLocalizableResourceKey key, BamlTreeUpdateMap treeMap, BamlTreeNode parent, IList<BamlTreeNode> newChildren ) { if (newChildren == null) return; List<BamlTreeNode> oldChildren = parent.Children; int nodeIndex = 0; StringBuilder textBuffer = new StringBuilder(); if (oldChildren != null) { Hashtable uidSubstitutions = new Hashtable(newChildren.Count); foreach (BamlTreeNode node in newChildren) { if (node.NodeType == BamlNodeType.StartElement) { BamlStartElementNode element = (BamlStartElementNode) node; // element's Uid can be null if it is a formatting tag. if (element.Uid != null) { if (uidSubstitutions.ContainsKey(element.Uid)) { treeMap.Resolver.RaiseErrorNotifyEvent( new BamlLocalizerErrorNotifyEventArgs( key, BamlLocalizerError.DuplicateElement ) ); return; // the substitution contains duplicate elements. } uidSubstitutions[element.Uid] = null; // stored in Hashtable } } } parent.Children = null; // start re-adding child element to parent // The last node is EndStartElement node and must remain to be at the end, // so it won't be rearranged. for (int i = 0; i < oldChildren.Count - 1; i++) { BamlTreeNode child = oldChildren[i]; switch (child.NodeType) { case BamlNodeType.StartElement: { BamlStartElementNode element = (BamlStartElementNode) child; if (element.Uid != null) { if (!uidSubstitutions.ContainsKey(element.Uid)) { // cannot apply uid susbstitution because the susbstituition doesn't // contain all the existing uids. parent.Children = oldChildren; // reset to old children and exit treeMap.Resolver.RaiseErrorNotifyEvent( new BamlLocalizerErrorNotifyEventArgs( key, BamlLocalizerError.MismatchedElements ) ); return; } // Each Uid can only appear once. uidSubstitutions.Remove(element.Uid); } // Append all the contents till the matching element. while (nodeIndex < newChildren.Count) { BamlTreeNode newNode = newChildren[nodeIndex++]; Invariant.Assert(newNode != null); if (newNode.NodeType == BamlNodeType.Text) { textBuffer.Append(((BamlTextNode) newNode).Content); // Collect all text into the buffer } else { TryFlushTextToBamlNode(parent, textBuffer); parent.AddChild(newNode); if (newNode.NodeType == BamlNodeType.StartElement) break; } } break; } case BamlNodeType.Text: { // Skip original text node. New text node will be created from // text tokens in translation break; } default: { parent.AddChild(child); break; } } } } // finish the rest of the nodes for (; nodeIndex < newChildren.Count; nodeIndex++) { BamlTreeNode newNode = newChildren[nodeIndex]; Invariant.Assert(newNode != null); if (newNode.NodeType == BamlNodeType.Text) { textBuffer.Append(((BamlTextNode) newNode).Content); // Collect all text into the buffer } else { TryFlushTextToBamlNode(parent, textBuffer); parent.AddChild(newNode); } } TryFlushTextToBamlNode(parent, textBuffer); // Always terminate the list with EndElementNode; parent.AddChild(new BamlEndElementNode()); }
private static bool GetBamlTreeNodeFromXmlNode( BamlLocalizableResourceKey key, XmlNode node, // xml node to construct BamlTreeNode from BamlTreeUpdateMap bamlTreeMap, // Baml tree update map IList<BamlTreeNode> newChildrenList // list of new children ) { if (node.NodeType == XmlNodeType.Text) { // construct a Text tree node from the xml content return GetBamlTreeNodeFromText( key, node.Value, bamlTreeMap, newChildrenList ); } else if (node.NodeType == XmlNodeType.Element) { XmlElement child = node as XmlElement; string className = bamlTreeMap.Resolver.ResolveFormattingTagToClass(child.Name); bool invalidResult = string.IsNullOrEmpty(className); string assemblyName = null; if (!invalidResult) { assemblyName = bamlTreeMap.Resolver.ResolveAssemblyFromClass(className); invalidResult = string.IsNullOrEmpty(assemblyName); } if (invalidResult) { bamlTreeMap.Resolver.RaiseErrorNotifyEvent( new BamlLocalizerErrorNotifyEventArgs( key, BamlLocalizerError.UnknownFormattingTag ) ); return false; } // get the uid for this formatting tag string tagUid = null; if (child.HasAttributes) { tagUid = child.GetAttribute(XamlReaderHelper.DefinitionUid); if (!string.IsNullOrEmpty(tagUid)) tagUid = BamlResourceContentUtil.UnescapeString(tagUid); } BamlStartElementNode bamlNode = null; if (tagUid != null) { bamlNode = bamlTreeMap.MapUidToBamlTreeElementNode(tagUid); } if (bamlNode == null) { bamlNode = new BamlStartElementNode( assemblyName, className, false, /*isInjected*/ false /*CreateUsingTypeConverter*/ ); if (tagUid != null) { // store the new node created bamlTreeMap.AddBamlTreeNode( tagUid, new BamlLocalizableResourceKey(tagUid, className, BamlConst.ContentSuffix, assemblyName), bamlNode ); // Add the x:Uid node to the element bamlNode.AddChild( new BamlDefAttributeNode( XamlReaderHelper.DefinitionUid, tagUid ) ); } TryAddContentPropertyToNewElement(bamlTreeMap, bamlNode); // terminate the child by a end element node bamlNode.AddChild(new BamlEndElementNode()); } else { if (bamlNode.TypeFullName != className) { // This can happen if the localizer adds a new element with an id // that is also been added to the newer version of source baml bamlTreeMap.Resolver.RaiseErrorNotifyEvent( new BamlLocalizerErrorNotifyEventArgs( key, BamlLocalizerError.DuplicateUid ) ); return false; } } newChildrenList.Add(bamlNode); bool succeed = true; if (child.HasChildNodes) { // recursively go down IList<BamlTreeNode> list = new List<BamlTreeNode>(); for (int i = 0; i < child.ChildNodes.Count && succeed; i++) { succeed = GetBamlTreeNodeFromXmlNode( key, child.ChildNodes[i], bamlTreeMap, list ); } if (succeed) { // merging the formatting translation with exisiting nodes. // formatting translation doesn't contain properties. MergeChildrenList(key, bamlTreeMap, bamlNode, list); } } return succeed; } return true; // other than text and element nodes }
/// <summary> /// determines whether the dictionary contains the localizable resource /// with the specified key /// </summary> /// <param name="key"></param> /// <returns></returns> public bool Contains(BamlLocalizableResourceKey key) { CheckNonNullParam(key, "key"); return(_dictionary.ContainsKey(key)); }
internal BamlTreeNode MapKeyToBamlTreeNode(BamlLocalizableResourceKey key) { BamlTreeNode node = _originalMap.MapKeyToBamlTreeNode(key, _tree); if (node == null) { // find it in the new nodes if (_keyToNewBamlNodeIndexMap.Contains(key)) { node = _tree[(int)_keyToNewBamlNodeIndexMap[key]]; } } return node; }
internal void AddBamlTreeNode( string uid, BamlLocalizableResourceKey key, BamlTreeNode node ) { // add to node _tree.AddTreeNode(node); // remember the tree node index if (uid != null) { _uidToNewBamlNodeIndexMap[uid] = _tree.Size - 1; } _keyToNewBamlNodeIndexMap[key] = _tree.Size - 1; }