protected override void AddAttribute (string name, string value, HtmlTextWriterAttribute key)
		{
			output.WriteLine ("{0:###0} AddAttribute ({1}, {2}, {3}))", NextIndex (), name, value, key);
			if (full_trace)
				WriteTrace (new StackTrace ());

			base.AddAttribute (name, value, key);
		}

		public PendingAttribute (string name, string value, HtmlTextWriterAttribute a, bool encode, bool know_encode)
		{
			this.name = name;
			this.value = value;
			this.a = a;
			this.encode = encode;
			this.know_encode = know_encode;
		}

 public override void AddAttribute(HtmlTextWriterAttribute key, string value)
 {
     if (((key == HtmlTextWriterAttribute.Src) || (key == HtmlTextWriterAttribute.Href)) || (key == HtmlTextWriterAttribute.Background))
     {
         base.AddAttribute(key.ToString(), value, key);
     }
     else
     {
         base.AddAttribute(key, value);
     }
 }

        public override void AddAttribute(HtmlTextWriterAttribute key, string value)
        {
            if (multiValueAttrs != null && multiValueAttrs.Contains(key))
            {
                if (!attrValues.ContainsKey(key))
                    attrValues.Add(key, new List<string>());

                attrValues[key].Add(value);
            }
            else
            {
                base.AddAttribute(key, value);
            }
        }

        public override void AddAttribute(HtmlTextWriterAttribute key, string value)
        {
            if (_allowedMultiValueAttrs.Contains(key))
            {
                if (!_attrValues.ContainsKey(key))
                    _attrValues.Add(key, new List<string>());

                _attrValues[key].Add(value);
            }
            else
            {
                base.AddAttribute(key, value);
            }
        }

 protected override bool OnAttributeRender(string name, string value, HtmlTextWriterAttribute key)
 {
     Hashtable hashtable = (Hashtable) this._recognizedAttributes[base.TagName];
     if ((hashtable == null) || (hashtable[name] == null))
     {
         if (this._globalSuppressedAttributes[name] != null)
         {
             return false;
         }
         Hashtable hashtable2 = (Hashtable) this._suppressedAttributes[base.TagName];
         if ((hashtable2 != null) && (hashtable2[name] != null))
         {
             return false;
         }
     }
     return true;
 }

        /// <devdoc>
        /// Override to filter out unnecessary attributes
        /// </devdoc>
        protected override bool OnAttributeRender(string name, string value, HtmlTextWriterAttribute key) {
            Hashtable elementRecognizedAttributes = (Hashtable)_recognizedAttributes[TagName];
            if (elementRecognizedAttributes != null && elementRecognizedAttributes[name] != null) {
                return true;
            }
            
            if (_globalSuppressedAttributes[name] != null) {
                return false;
            }
            
            Hashtable elementSuppressedAttributes = (Hashtable)_suppressedAttributes[TagName];
            if (elementSuppressedAttributes != null && elementSuppressedAttributes[name] != null) {
                return false;
            }

            return true;
        }

 /// <summary>
 /// Applies the value to the specified attribute to the HtmlTextWriter
 /// this instance contains.
 /// </summary>
 /// <param name="key">The attribute to set.</param>
 /// <param name="value">The value to set to the attribute.</param>
 /// <returns>The attribute manager.</returns>
 public HtmlAttributeManager Attr(HtmlTextWriterAttribute key, string value)
 {
     Writer.AddAttribute(key, value);
     return this;
 }

 public override void AddAttribute(HtmlTextWriterAttribute key, String value)
 {
     if (HasRenderedFirstTag) {
         base.AddAttribute(key, value);
     } else if (key == HtmlTextWriterAttribute.Onclick) {
         value +=
             ";(function(e){" +
               "setTimeout(function(){" +
                 "e.disabled=(window.Page_IsValid !== true) ? false : (e.form && e.form.checkValidity && e.form.checkValidity());" +
               "}, 0);" +
             "})(this);";
         base.AddAttribute(key, value);
     } else {
         base.AddAttribute(key, value);
     }
 }

 protected virtual bool OnAttributeRender(string name, string value, HtmlTextWriterAttribute key) {
     return true;
 }

 protected bool IsAttributeDefined(HtmlTextWriterAttribute key) {
     for (int i = 0; i < _attrCount; i++) {
         if (_attrList[i].key == key) {
             return true;
         }
     }
     return false;
 }

        protected virtual string EncodeAttributeValue(HtmlTextWriterAttribute attrKey, string value) {
            bool encode = true;

            if (0 <= (int)attrKey && (int)attrKey < _attrNameLookupArray.Length) {
                encode = _attrNameLookupArray[(int)attrKey].encode;
            }

            return EncodeAttributeValue(value, encode);
        }

 protected virtual void AddAttribute(string name, string value, HtmlTextWriterAttribute key) {
     AddAttribute(name, value, key, false, false);
 }

 protected string GetAttributeName(HtmlTextWriterAttribute attrKey)
 {
     if ((attrKey >= HtmlTextWriterAttribute.Accesskey) && (attrKey < _attrNameLookupArray.Length))
     {
         return _attrNameLookupArray[(int) attrKey].name;
     }
     return string.Empty;
 }

        private static void RegisterAttribute(string name, HtmlTextWriterAttribute key, bool encode, bool isUrl) {
            string nameLCase = name.ToLower(CultureInfo.InvariantCulture);

            _attrKeyLookupTable.Add(nameLCase, key);

            if ((int)key < _attrNameLookupArray.Length) {
                _attrNameLookupArray[(int)key] = new AttributeInformation(name, encode, isUrl);
            }
        }

		protected override bool OnAttributeRender (string name, string value, HtmlTextWriterAttribute key)
		{
			// FIXME:
			// I checked every possible HtmlTextWriterAttribute key
			// and always throws ArgumentNullException.
			return (bool) attr_render [null];
		}

	public virtual void AddAttribute(HtmlTextWriterAttribute key, string value, bool fEncode) {}

        protected string GetAttributeName(HtmlTextWriterAttribute attrKey) {
            if ((int)attrKey >= 0 && (int)attrKey < _attrNameLookupArray.Length)
                return _attrNameLookupArray[(int)attrKey].name;

            return string.Empty;
        }

		public bool PublicOnAttributeRender (string name, string value, HtmlTextWriterAttribute attr)
		{
			return OnAttributeRender (name, value, attr);
		}

		public string PublicGetAttributeName (HtmlTextWriterAttribute attrKey)
		{
			return GetAttributeName (attrKey);
		}