public void AddOptionTag(HtmlOptionTag tag) { _options.Add(tag.Key, tag); }
private void Insert(int index, string key, HtmlOptionTag value) { if (count == keys.Length) EnsureCapacity(count + 1); if (index < count) { Array.Copy(keys, index, keys, index + 1, count - index); Array.Copy(values, index, values, index + 1, count - index); } keys[index] = key; values[index] = value; count++; version++; }
/// <summary> /// Creates a HtmlSelectTag from a HTMLSelectElementClass. /// </summary> /// <param name="selectElement"> The HTMLSelectElementClass to convert.</param> /// <returns> A HtmlSelectTag</returns> private HtmlSelectTag CreateHtmlSelectTag(HTMLSelectElementClass selectElement) { HtmlSelectTag tag = new HtmlSelectTag(); tag.Class = selectElement.className; tag.Id = selectElement.id; if ( selectElement.name != null ) { tag.Name = selectElement.name; } else { if ( selectElement.id != null ) { tag.Name = selectElement.id; } else { tag.Name = selectElement.uniqueID; tag.Id = selectElement.uniqueID; } } // TODO: parse from innerHtml // tag.OnClick = // tag.Style=currentNode.GetAttribute("style",currentNode.NamespaceURI); tag.Title = selectElement.title; if ( selectElement.multiple ) { tag.Multiple=true; } tag.Value = selectElement.value; // tag.Options = new HtmlOptionCollection(); //object noll = null; IHTMLElementCollection options = (IHTMLElementCollection)selectElement.children; // while ( options.MoveNext() ) foreach ( object obj in options ) { if ( obj is HTMLOptionElementClass ) { HTMLOptionElementClass option = (HTMLOptionElementClass)obj; HtmlOptionTag optionTag = new HtmlOptionTag(); optionTag.Id = option.id; if ( option.selected ) { optionTag.Selected=true; } if ( option.text == null ) { optionTag.Text = string.Empty; } else { optionTag.Text = option.text; } if ( option.value == null ) { optionTag.Value = string.Empty; } else { optionTag.Value = option.value; } optionTag.Key = "Option " + tag.Options.Length.ToString(); tag.AddOptionTag(optionTag); } } return tag; }
/// <summary> /// Removes the element at the specified index of the <b>HtmlOptionCollection</b>. /// </summary> /// <param name="index">The zero-based index of the element to remove.</param> /// <exception cref="ArgumentOutOfRangeException"> /// <paramref name="index"/> is outside the range of valid indices for the <see cref="HtmlOptionCollection"/>. /// </exception> /// <exception cref="NotSupportedException"> /// <para>The <see cref="HtmlOptionCollection"/> is read-only.</para> /// <para>-or-</para> /// <para>The <b>HtmlOptionCollection</b> has a fixed size.</para> /// </exception> /// <remarks> /// <para>The index sequence is based on the sort sequence. When an element is added, /// it is inserted into <see cref="HtmlOptionCollection"/> in the correct sort order, and /// the indexing adjusts accordingly. When an element removed, the indexing also adjusts /// accordingly. Therefore, the index of a specific key-and-value pair might change as /// elements are added or removed from the <see cref="HtmlOptionCollection"/>.</para> /// <para>In collections of contiguous elements, such as lists, the elements that /// follow the removed element move up to occupy the vacated spot. If the collection is /// indexed, the indices of the elements that are moved are also updated.</para> /// </remarks> public virtual void RemoveAt(int index) { if (index < 0 || index >= count) throw new ArgumentOutOfRangeException("index", index, "The index is outside the range of valid indices."); count--; if (index < count) { Array.Copy(keys, index + 1, keys, index, count - index); Array.Copy(values, index + 1, values, index, count - index); } // We can't set the deleted entries equal to null, because they might be value types. // Instead, we'll create empty single-element arrays of the right type and copy them // over the entries we want to erase. string[] tempKey = new string[1]; HtmlOptionTag[] tempVal = new HtmlOptionTag[1]; Array.Copy(tempKey, 0, keys, count, 1); Array.Copy(tempVal, 0, values, count, 1); version++; }
/// <summary> /// Replaces the value at a specific index in the <b>HtmlOptionCollection</b>. /// </summary> /// <param name="index">The zero-based index at which to save <paramref name="value"/>.</param> /// <param name="value">The <see cref="HtmlOptionTag"/> to save into the <see cref="HtmlOptionCollection"/>.</param> /// <exception cref="ArgumentOutOfRangeException"> /// <paramref name="index"/> is outside the range of valid indices for the <see cref="HtmlOptionCollection"/>. /// </exception> /// <remarks> /// <para>The index sequence is based on the sort sequence. When an element is added, /// it is inserted into <see cref="HtmlOptionCollection"/> in the correct sort order, and /// the indexing adjusts accordingly. When an element removed, the indexing also adjusts /// accordingly. Therefore, the index of a specific key-and-value pair might change as /// elements are added or removed from the <see cref="HtmlOptionCollection"/>.</para> /// </remarks> public virtual void SetByIndex(int index, HtmlOptionTag value) { if (index < 0 || index >= count) throw new ArgumentOutOfRangeException("index", index, "The index is outside the range of valid indices."); values[index] = value; version++; }
/// <summary> /// Determines whether the <b>HtmlOptionCollection</b> contains a specific value. /// </summary> /// <param name="value">The value to locate in the <see cref="HtmlOptionCollection"/>.</param> /// <returns> /// <b>true</b> if the <see cref="HtmlOptionCollection"/> contains an element with the specified /// <paramref name="value"/>; otherwise, <b>false</b>. /// </returns> public virtual bool ContainsValue(HtmlOptionTag value) { return (IndexOfValue(value) >= 0); }
/// <summary> /// Returns the zero-based index of the first occurrence of the specified value in /// the <b>HtmlOptionCollection</b>. /// </summary> /// <param name="value">The value to locate in the <see cref="HtmlOptionCollection"/>.</param> /// <returns> /// The zero-based index of <paramref name="value"/>, if <paramref name="value"/> is found in /// the <see cref="HtmlOptionCollection"/>; otherwise, -1. /// </returns> /// <remarks> /// <para>The index sequence is based on the sort sequence. When an element is added, /// it is inserted into <see cref="HtmlOptionCollection"/> in the correct sort order, and /// the indexing adjusts accordingly. When an element removed, the indexing also adjusts /// accordingly. Therefore, the index of a specific key-and-value pair might change as /// elements are added or removed from the <see cref="HtmlOptionCollection"/>.</para> /// <para>The values of the elements of the <see cref="HtmlOptionCollection"/> are compared to the /// specified value using the Equals method.</para> /// <para>This method uses a linear search; therefore, the average execution time is /// proportional to <see cref="HtmlOptionCollection.Count"/>.</para> /// </remarks> public virtual int IndexOfValue(HtmlOptionTag value) { return Array.IndexOf(values, value, 0, count); }
public virtual int IndexOf(HtmlOptionTag value) { return list.IndexOfValue(value); }
/// <summary> /// Adds an element with the specified key and value to the <b>HtmlOptionCollection</b>. /// </summary> /// <param name="key">The key of the element to add.</param> /// <param name="value">The value of the element to add.</param> /// <exception cref="ArgumentNullException">The <paramref name="key"/> is a null reference.</exception> /// <exception cref="ArgumentException"> /// <para>An element with the specified <paramref name="key"/> already exists in the <see cref="HtmlOptionCollection"/>.</para> /// <para>-or-</para> /// <para>The <b>HtmlOptionCollection</b> is set to use the <see cref="IComparable"/> interface, /// and <paramref name="key"/> does not implement the <b>IComparable</b> interface.</para> /// </exception> /// <exception cref="InvalidOperationException">The comparer throws an exception.</exception> /// <exception cref="NotSupportedException"> /// <para>The <see cref="HtmlOptionCollection"/> is read-only.</para> /// <para>-or-</para> /// <para>The <b>HtmlOptionCollection</b> has a fixed size.</para> /// </exception> public virtual void Add(string key, HtmlOptionTag value) { if (Object.ReferenceEquals(key, null)) // avoids compiler error for null check on value type throw new ArgumentNullException("key", "The key cannot be null."); int index = Array.BinarySearch(keys, 0, count, key, comparer); if (index >= 0) throw new ArgumentException(String.Format("Item has already been added. Key being added: \"{0}\".", key)); Insert(~index, key, value); }
public override void SetByIndex(int index, HtmlOptionTag value) { lock (root) list.SetByIndex(index, value); }
public virtual bool Contains(HtmlOptionTag value) { return list.ContainsValue(value); }
public override int IndexOfValue(HtmlOptionTag value) { lock (root) return list.IndexOfValue(value); }
public override bool ContainsValue(HtmlOptionTag value) { lock (root) return list.ContainsValue(value); }
public override void Add(string key, HtmlOptionTag value) { lock (root) list.Add(key, value); }
public virtual void Reset() { if (version != list.version) throw new InvalidOperationException("The collection was modified - enumeration cannot continue."); // We can't set the entries equal to null, because they might be value types. // Instead, we'll create empty single-element arrays of the right type and copy them // over the entries we want to erase. string[] tempKey = new string[1]; HtmlOptionTag[] tempVal = new HtmlOptionTag[1]; key = tempKey[0]; value = tempVal[0]; currentValid = false; index = startIndex; }
/// <summary> /// Creates a select tag. /// </summary> /// <param name="currentNode"> The XPathNavigator node.</param> /// <returns> A HtmlSelectTag.</returns> private HtmlSelectTag CreateSelectTag(XPathNavigator currentNode) { HtmlSelectTag tag = new HtmlSelectTag(); tag.Class=currentNode.GetAttribute("class",currentNode.NamespaceURI); tag.Id=currentNode.GetAttribute("id",currentNode.NamespaceURI); tag.Name=currentNode.GetAttribute("name",currentNode.NamespaceURI); tag.OnClick=currentNode.GetAttribute("onclick",currentNode.NamespaceURI); tag.Style=currentNode.GetAttribute("style",currentNode.NamespaceURI); tag.Title=currentNode.GetAttribute("title",currentNode.NamespaceURI); if ( tag.OnClick.Length == 0 ) { tag.OnClick = currentNode.GetAttribute("onClick",currentNode.NamespaceURI); } if ( currentNode.GetAttribute("multiple",currentNode.NamespaceURI)=="true" ) { tag.Multiple=true; } tag.Value=currentNode.GetAttribute("value",currentNode.NamespaceURI); // fill options nodes XPathNodeIterator options = currentNode.SelectChildren(XPathNodeType.Element); //tag.Options = new HtmlOptionCollection(); int i=1; while ( options.MoveNext() ) { HtmlOptionTag option = new HtmlOptionTag(); option.Id=options.Current.GetAttribute("id",options.Current.NamespaceURI); if ( options.Current.GetAttribute("selected",options.Current.NamespaceURI)=="true" ) { option.Selected=true; } option.Text=options.Current.Value; option.Value=options.Current.GetAttribute("value",options.Current.NamespaceURI); option.Key = "Option " + i; tag.AddOptionTag(option); i++; } return tag; }