public SVGPaintable(SVGPaintable inheritPaintable, AttributeList attrList)
    {
        this._linearGradList = inheritPaintable.linearGradList;
        this._radialGradList = inheritPaintable.radialGradList;;
        Initialize(attrList);

        if(IsFillX() == false) {
          if(inheritPaintable.IsLinearGradiantFill()) {
        this._gradientID = inheritPaintable.gradientID;
          } else if(inheritPaintable.IsRadialGradiantFill()) {
        this._gradientID = inheritPaintable.gradientID;
          } else this._fillColor = inheritPaintable.fillColor;
        }
        if(!IsStroke()&& inheritPaintable.IsStroke()) {
          this._strokeColor = inheritPaintable.strokeColor;
        }

        if(_strokeLineCap == SVGStrokeLineCapMethod.Unknown) {
          _strokeLineCap = inheritPaintable.strokeLineCap;
        }

        if(_strokeLineJoin == SVGStrokeLineJoinMethod.Unknown) {
          _strokeLineJoin = inheritPaintable.strokeLineJoin;
        }

        if(isStrokeWidth == false)
          this._strokeWidth.NewValueSpecifiedUnits(inheritPaintable.strokeWidth);
    }

 public AttributeList(AttributeList a)
 {
     if(a.attrs != null)
       attrs = new Dictionary<string,string>(a.attrs);
     else
       attrs = null;
 }

    public static AttributeList GetCustomAttributes( Member member, TypeNode attrType ) {
      AttributeList result = null;
      if (member == null) 
	      return null;
      AttributeList attrs = member.Attributes;
      if( attrs != null ) {
        for( int i = 0; i < attrs.Count; i++ ) {
          AttributeNode an = attrs[i];
          if (an == null) continue;
          MemberBinding mb = an.Constructor as MemberBinding;
          if( mb != null && mb.BoundMember != null && mb.BoundMember.DeclaringType == attrType ) {
            if( result == null ) {
              result = new AttributeList();
            }
            result.Add(an);
          }
        }
      }
      if (result == null) {
        TypeNode tn = member as TypeNode;
        if (tn != null) return MetadataHelper.GetCustomAttributes(tn.BaseType, attrType);
        Property p = MetadataHelper.GetPropertyForMethod(member);
        if (p != null) return MetadataHelper.GetCustomAttributes(p, attrType);
      }      
      return result;
    }    

 public AddRequest(
     LDAPDN entry,
     AttributeList attributes)
 {
     this.entry = entry;
     this.attributes = attributes;
 }

 internal AttributeListAttribute(INtfsContext context, AttributeRecord record)
     : base(context, record)
 {
     byte[] content = Utilities.ReadAll(Content);
     _list = new AttributeList();
     _list.ReadFrom(content, 0);
 }

 public virtual AttributeNode GetClosestMatch(AttributeNode/*!*/ nd1, AttributeList/*!*/ list1, AttributeList list2, int list1pos, ref int list2start,
   TrivialHashtable/*!*/ matchedNodes, out Differences closestDifferences, out int list2pos) {
   closestDifferences = null; list2pos = -1;
   if (list2 == null) return null;
   if (nd1 == null || list1 == null || matchedNodes == null ||  list1pos < 0 || list1pos >= list1.Count || list2start < 0 || list2start >= list2.Count) {
     Debug.Assert(false); return null;
   }
   AttributeNode closest = null;
   Differences winnerSoFar = null;
   for (int j = list2start, m = list2.Count; j < m; j++){
     AttributeNode nd2 = list2[j];
     if (list2start == j) list2start++;
     if (nd2 == null) continue;
     if (matchedNodes[nd2.UniqueKey] != null) continue;
     Differences diff = this.GetDifferences(nd1, nd2);
     if (diff == null){Debug.Assert(false); continue;}
     if (diff.Similarity <= 0.5){
       //Not a good enough match
       if (list2start == j+1) list2start--; //The next call to GetClosestMatch will start looking at list2start, so this node will be considered then
       continue; //ignore it for the rest of this call
     }
     if (winnerSoFar != null && winnerSoFar.Similarity >= diff.Similarity) continue;
     winnerSoFar = closestDifferences = diff;
     closest = nd2;
     list2pos = j;
     if (diff.NumberOfDifferences == 0) return closest; //Perfect match, no need to look for other matches
   }
   if (closest != null){
     //^ assert winnerSoFar != null;
     //closest is closer to nd1 than any other node in list2, but this is no good if some other node in list1 has a better claim on closest
     for (int i = list1pos+1, n = list1.Count; i < n; i++){
       AttributeNode nd1alt = list1[i];
       if (nd1alt == null) continue;
       if (matchedNodes[nd1alt.UniqueKey] != null) continue;
       Differences diff = this.GetDifferences(nd1alt, closest);
       if (diff == null){Debug.Assert(false); continue;}
       if (diff.Similarity <= winnerSoFar.Similarity) continue;
       //nd1alt has a better claim on closest. See if it wants closest.
       Differences diff2;
       int j, k = list2start;
       AttributeNode nd2alt = this.GetClosestMatch(nd1alt, list1, list2, i, ref k,  matchedNodes, out diff2, out j);
       if (nd2alt != closest){
         Debug.Assert(nd2alt != null && diff2 != null && diff2.Similarity >= diff.Similarity);
         continue; //nd1alt prefers nd2alt to closest, so closest is still available
       }
       //nd1alt wants closest, take it out of the running
       matchedNodes[closest.UniqueKey] = nd1alt;
       //Now that closest is out of the running, try again
       k = list2start;
       AttributeNode newClosest = this.GetClosestMatch(nd1, list1, list2, i, ref k, matchedNodes, out winnerSoFar, out list2pos);
       //put closest back in the running so that the next call to this routine will pick it up
       matchedNodes[closest.UniqueKey] = closest;
       closest = newClosest;
       break;
     }
   }
   closestDifferences = winnerSoFar;
   return closest;
 }

 /***********************************************************************************/
 public SVGPathElement(AttributeList attrList, SVGTransformList inheritTransformList, SVGPaintable inheritPaintable, SVGGraphics r)
     : base(inheritTransformList)
 {
     _attrList = attrList;
     _paintable = new SVGPaintable(inheritPaintable, attrList);
     _render = r;
     Initial();
 }

 internal CustomPropertyDescriptor(object owner, PropertyDescriptor pd)
     : base(pd)
 {
     propertyDescriptor = pd;
     this.owner = owner;
     attributes = new AttributeList(pd.Attributes);
     UpdateMemberData();
 }

 private AttributeList Translate(CodeAttributeDeclarationCollection attributes, AttributeList attributeList){
   if (attributes == null) return null;
   int n = attributes.Count;
   if (attributeList == null)
     if (n == 0) return null; else attributeList = new AttributeList(n);
   for (int i = 0; i < n; i++)
     attributeList.Add(this.Translate(attributes[i]));
   return attributeList;
 }

 public override AttributeList VisitAttributeList(AttributeList attributes)
 {
     AttributeList list = new AttributeList();
     for (int i = 0; i < attributes.Count; i++)
     {
         AttributeNode a = attributes[i];
         list.Add(VisitAttributeNode(a));
     }
     return list;
 }

 //================================================================================
 public SVGPolylineElement(  AttributeList attrList,
             SVGTransformList inheritTransformList,
             SVGPaintable inheritPaintable,
             SVGGraphics _render)
     : base(inheritTransformList)
 {
     this._attrList = attrList;
     this._render = _render;
     this._paintable = new SVGPaintable(inheritPaintable, attrList);
     this._listPoints = ExtractPoints(this._attrList.GetValue("points"));
 }

 /***************************************************************************/
 public SVGStopElement(AttributeList attrList)
 {
     _stopColor = new SVGColor(attrList.GetValue("stop-color"));
     string temp = attrList.GetValue("offset").Trim();
     if(temp != "") {
       if(temp.EndsWith("%")) {
     _offset = float.Parse(temp.TrimEnd(new char[1] { '%' }), System.Globalization.CultureInfo.InvariantCulture);
       } else {
     _offset = float.Parse(temp, System.Globalization.CultureInfo.InvariantCulture)* 100;
       }
     }
 }

 /***************************************************************************/
 public SVGStopElement(AttributeList attrList)
 {
     _stopColor = new SVGColor(attrList.GetValue("stop-color"));
     string temp = attrList.GetValue("offset").Trim();
     if(temp != "") {
       if(temp.EndsWith("%")) {
     _offset = SVGNumber.ParseToFloat(temp.TrimEnd(new char[1]{'%'}));
       } else {
     _offset = SVGNumber.ParseToFloat(temp)* 100;
       }
     }
 }

 //================================================================================
 public SVGCircleElement(AttributeList attrList,
           SVGTransformList inheritTransformList,
           SVGPaintable inheritPaintable,
           SVGGraphics _render)
     : base(inheritTransformList)
 {
     this._attrList = attrList;
     this._render = _render;
     this._paintable = new SVGPaintable(inheritPaintable, this._attrList);
     this._cx = new SVGLength(attrList.GetValue("cx"));
     this._cy = new SVGLength(attrList.GetValue("cy"));
     this._r = new SVGLength(attrList.GetValue("r"));
 }

		public Tag GetTag()
		{
			AttributeList attributes = new AttributeList();

			foreach(Attribute x in List)
			{
				attributes.Add((Attribute)x.Clone());
			}

            Tag retVal = new Tag(m_tag, attributes);

			return(retVal);
		}

 private void GetAttributesStartPos(AttributeList attrs, ref int priorStartLine, ref int priorStartPos) {
   if (attrs != null) {
     for (int i=0; i<attrs.Count; i++) {
       if (attrs[i] != null) {
         int candidateStart = attrs[i].SourceContext.StartPos;
         if (candidateStart < priorStartPos) {
           priorStartPos = candidateStart;
           priorStartLine = attrs[i].SourceContext.StartLine;
         }
       }
     }
   }
 }

 /***********************************************************************************/
 public SVGLineElement(  AttributeList attrList,
           SVGTransformList inheritTransformList,
           SVGPaintable inheritPaintable,
           SVGGraphics _render)
     : base(inheritTransformList)
 {
     this._attrList = attrList;
     this._paintable = new SVGPaintable(inheritPaintable, this._attrList);
     this._render = _render;
     this._x1 = new SVGLength(attrList.GetValue("x1"));
     this._y1 = new SVGLength(attrList.GetValue("y1"));
     this._x2 = new SVGLength(attrList.GetValue("x2"));
     this._y2 = new SVGLength(attrList.GetValue("y2"));
 }

        public Tag(string name, AttributeList attributes)
        {
            if (name == null)
            {
                throw new ArgumentException("name cannot be null");
            }
            if (attributes == null)
            {
                throw new ArgumentException("attributes cannot be null");
            }

            this._name = name;
            this._attributes = attributes;
        }

        private static void ScrubAttributeList(AttributeList attributes)
        {
            if (attributes == null) return;
            for (int i = 0, n = attributes.Count; i < n; i++)
            {
                if (attributes[i] == null) continue;

                if (attributes[i].Type == null) continue;

                if (ContractNodes.ContractClassAttributeName.Matches(attributes[i].Type.Name))
                {
                    attributes[i] = null;
                }
            }
        }

 //================================================================================
 public SVGRectElement(AttributeList attrList,
           SVGTransformList inheritTransformList,
           SVGPaintable inheritPaintable,
           SVGGraphics _render)
     : base(inheritTransformList)
 {
     this._attrList = attrList;
     this._render = _render;
     this._paintable = new SVGPaintable(inheritPaintable, this._attrList);
     this._x = new SVGLength(attrList.GetValue("x"));
     this._y = new SVGLength(attrList.GetValue("y"));
     this._width = new SVGLength(attrList.GetValue("width"));
     this._height = new SVGLength(attrList.GetValue("height"));
     this._rx = new SVGLength(attrList.GetValue("rx"));
     this._ry = new SVGLength(attrList.GetValue("ry"));
 }