C# Properties.Add方法代码示例

 /// <summary>
 /// This method parses a string with attributes and returns a Properties object.
 /// </summary>
 /// <param name="str">a string of this form: 'key1="value1"; key2="value2";... keyN="valueN" '</param>
 /// <returns>a Properties object</returns>
 public static Properties ParseAttributes(string str) {
     Properties result = new Properties();
     if (str == null) return result;
     StringTokenizer keyValuePairs = new StringTokenizer(str, ";");
     StringTokenizer keyValuePair;
     string key;
     string value;
     while (keyValuePairs.HasMoreTokens()) {
         keyValuePair = new StringTokenizer(keyValuePairs.NextToken(), ":");
         if (keyValuePair.HasMoreTokens()) key = keyValuePair.NextToken().Trim().Trim();
         else continue;
         if (keyValuePair.HasMoreTokens()) value = keyValuePair.NextToken().Trim();
         else continue;
         if (value.StartsWith("\"")) value = value.Substring(1);
         if (value.EndsWith("\"")) value = value.Substring(0, value.Length - 1);
         result.Add(key.ToLower(CultureInfo.InvariantCulture), value);
     }
     return result;
 }

        /**
        * This method gets called when a start tag is encountered.
        *
        * @param   uri         the Uniform Resource Identifier
        * @param   lname       the local name (without prefix), or the empty string if Namespace processing is not being performed.
        * @param   name        the name of the tag that is encountered
        * @param   attrs       the list of attributes
        */
        public override void StartElement(String uri, String lname, String name, Hashtable attrs)
        {
            //System.err.Println("Start: " + name);

            // super.handleStartingTags is replaced with handleStartingTags
            // suggestion by Vu Ngoc Tan/Hop
            name = name.ToLower(CultureInfo.InvariantCulture);
            if (((HtmlTagMap)myTags).IsHtml(name)) {
                // we do nothing
                return;
            }
            if (((HtmlTagMap)myTags).IsHead(name)) {
                // we do nothing
                return;
            }
            if (((HtmlTagMap)myTags).IsTitle(name)) {
                // we do nothing
                return;
            }
            if (((HtmlTagMap)myTags).IsMeta(name)) {
                // we look if we can change the body attributes
                String meta = null;
                String content = null;
                if (attrs != null) {
                    foreach (String attribute in attrs.Keys) {
                        if (Util.EqualsIgnoreCase(attribute, HtmlTags.CONTENT))
                            content = (String)attrs[attribute];
                        else if (Util.EqualsIgnoreCase(attribute, HtmlTags.NAME))
                            meta = (String)attrs[attribute];
                    }
                }
                if (meta != null && content != null) {
                    bodyAttributes.Add(meta, content);
                }
                return;
            }
            if (((HtmlTagMap)myTags).IsLink(name)) {
                // we do nothing for the moment, in a later version we could extract the style sheet
                return;
            }
            if (((HtmlTagMap)myTags).IsBody(name)) {
                // maybe we could extract some info about the document: color, margins,...
                // but that's for a later version...
                XmlPeer peer = new XmlPeer(ElementTags.ITEXT, name);
                peer.AddAlias(ElementTags.TOP, HtmlTags.TOPMARGIN);
                peer.AddAlias(ElementTags.BOTTOM, HtmlTags.BOTTOMMARGIN);
                peer.AddAlias(ElementTags.RIGHT, HtmlTags.RIGHTMARGIN);
                peer.AddAlias(ElementTags.LEFT, HtmlTags.LEFTMARGIN);
                bodyAttributes.AddAll(peer.GetAttributes(attrs));
                HandleStartingTags(peer.Tag, bodyAttributes);
                return;
            }
            if (myTags.ContainsKey(name)) {
                XmlPeer peer = (XmlPeer) myTags[name];
                if (Table.IsTag(peer.Tag) || Cell.IsTag(peer.Tag)) {
                    Properties p = peer.GetAttributes(attrs);
                    String value;
                    if (Table.IsTag(peer.Tag) && (value = p[ElementTags.BORDERWIDTH]) != null) {
                        if (float.Parse(value, System.Globalization.NumberFormatInfo.InvariantInfo) > 0) {
                            tableBorder = true;
                        }
                    }
                    if (tableBorder) {
                        p.Add(ElementTags.LEFT, "true");
                        p.Add(ElementTags.RIGHT, "true");
                        p.Add(ElementTags.TOP, "true");
                        p.Add(ElementTags.BOTTOM, "true");
                    }
                    HandleStartingTags(peer.Tag, p);
                    return;
                }
                HandleStartingTags(peer.Tag, peer.GetAttributes(attrs));
                return;
            }
            Properties attributes = new Properties();
            if (attrs != null) {
                foreach (String attribute in attrs.Keys) {
                    attributes.Add(attribute.ToLower(CultureInfo.InvariantCulture), ((String)attrs[attribute]).ToLower(CultureInfo.InvariantCulture));
                }
            }
            HandleStartingTags(name, attributes);
        }

 /**
 * @see com.lowagie.text.xml.XmlPeer#getAttributes(org.xml.sax.Attributes)
 */
 public override Properties GetAttributes(Hashtable attrs)
 {
     Properties attributes = new Properties();
     attributes.AddAll(attributeValues);
     if (defaultContent != null) {
         attributes[ElementTags.ITEXT] = defaultContent;
     }
     if (attrs != null) {
         foreach (string key in attrs.Keys) {
             attributes.Add(GetName(key).ToLower(CultureInfo.InvariantCulture), (string)attrs[key]);
         }
     }
     return attributes;
 }

 /// <summary>
 /// This method gets called when a start tag is encountered.
 /// </summary>
 /// <param name="uri"></param>
 /// <param name="lname"></param>
 /// <param name="name">the name of the tag that is encountered</param>
 /// <param name="attrs">the list of attributes</param>
 public override void StartElement(String uri, String lname, String name, Hashtable attrs) {
 
     Properties attributes = new Properties();
     if (attrs != null) {
         foreach (string key in attrs.Keys) {
             attributes.Add(key, (string)attrs[key]);
         }
     }
     HandleStartingTags(name, attributes);
 }

 /// <summary>
 /// Constructs a Font-object.
 /// </summary>
 /// <param name="attributes">the attributes of a Font object</param>
 /// <returns>a Font object</returns>
 public virtual Font GetFont(Properties attributes) {
     string fontname = null;
     string encoding = defaultEncoding;
     bool embedded = defaultEmbedding;
     float size = Font.UNDEFINED;
     int style = Font.NORMAL;
     BaseColor color = null;
     string value = attributes[Markup.HTML_ATTR_STYLE];
     if (value != null && value.Length > 0) {
         Properties styleAttributes = Markup.ParseAttributes(value);
         if (styleAttributes.Count == 0) {
             attributes.Add(Markup.HTML_ATTR_STYLE, value);
         }
         else {
             fontname = styleAttributes[Markup.CSS_KEY_FONTFAMILY];
             if (fontname != null) {
                 string tmp;
                 while (fontname.IndexOf(',') != -1) {
                     tmp = fontname.Substring(0, fontname.IndexOf(','));
                     if (IsRegistered(tmp)) {
                         fontname = tmp;
                     }
                     else {
                         fontname = fontname.Substring(fontname.IndexOf(',') + 1);
                     }
                 }
             }
             if ((value = styleAttributes[Markup.CSS_KEY_FONTSIZE]) != null) {
                 size = Markup.ParseLength(value);
             }
             if ((value = styleAttributes[Markup.CSS_KEY_FONTWEIGHT]) != null) {
                 style |= Font.GetStyleValue(value);
             }
             if ((value = styleAttributes[Markup.CSS_KEY_FONTSTYLE]) != null) {
                 style |= Font.GetStyleValue(value);
             }
             if ((value = styleAttributes[Markup.CSS_KEY_COLOR]) != null) {
                 color = Markup.DecodeColor(value);
             }
             attributes.AddAll(styleAttributes);
         }
     }
     if ((value = attributes[ElementTags.ENCODING]) != null) {
         encoding = value;
     }
     if ("true".Equals(attributes[ElementTags.EMBEDDED])) {
         embedded = true;
     }
     if ((value = attributes[ElementTags.FONT]) != null) {
         fontname = value;
     }
     if ((value = attributes[ElementTags.SIZE]) != null) {
         size = float.Parse(value, System.Globalization.NumberFormatInfo.InvariantInfo);
     }
     if ((value = attributes[Markup.HTML_ATTR_STYLE]) != null) {
         style |= Font.GetStyleValue(value);
     }
     if ((value = attributes[ElementTags.STYLE]) != null) {
         style |= Font.GetStyleValue(value);
     }
     string r = attributes[ElementTags.RED];
     string g = attributes[ElementTags.GREEN];
     string b = attributes[ElementTags.BLUE];
     if (r != null || g != null || b != null) {
         int red = 0;
         int green = 0;
         int blue = 0;
         if (r != null) red = int.Parse(r);
         if (g != null) green = int.Parse(g);
         if (b != null) blue = int.Parse(b);
         color = new BaseColor(red, green, blue);
     }
     else if ((value = attributes[ElementTags.COLOR]) != null) {
         color = Markup.DecodeColor(value);
     }
     if (fontname == null) {
         return GetFont(null, encoding, embedded, size, style, color);
     }
     return GetFont(fontname, encoding, embedded, size, style, color);
 }

 /// <summary>
 /// This method gets called when a start tag is encountered.
 /// </summary>
 /// <param name="uri"></param>
 /// <param name="lname"></param>
 /// <param name="name">the name of the tag that is encountered</param>
 /// <param name="attrs">the list of attributes</param>
 public override void StartElement(String uri, String lname, String name, Hashtable attrs)
 {
     if (myTags.ContainsKey(name)) {
         XmlPeer peer = (XmlPeer) myTags[name];
         HandleStartingTags(peer.Tag, peer.GetAttributes(attrs));
     }
     else {
         Properties attributes = new Properties();
         if (attrs != null) {
             foreach (string key in attrs.Keys) {
                 attributes.Add(key, (string)attrs[key]);
             }
         }
         HandleStartingTags(name, attributes);
     }
 }

 /// <summary> Gets the list of attributes of the peer. </summary>
 public virtual Properties GetAttributes(Hashtable attrs)
 {
     Properties attributes = new Properties();
     attributes.AddAll(attributeValues);
     if (defaultContent != null) {
         attributes.Add(ElementTags.ITEXT, defaultContent);
     }
     if (attrs != null) {
         foreach (string key in attrs.Keys) {
             attributes.Add(GetName(key), (string)attrs[key]);
         }
     }
     return attributes;
 }

 /// <summary>
 /// Will fill empty cells with valid blank Cells
 /// </summary>
 public void Complete()
 {
     if (mTableInserted == true) {
         MergeInsertedTables();  // integrate tables in the table
         mTableInserted = false;
     }
     if (mAutoFillEmptyCells == true) {
         FillEmptyMatrixCells();
     }
     if (alternatingRowAttributes != null) {
         Properties even = new Properties();
         Properties odd = new Properties();
         string name;
         string[] value;
         foreach (object itm in alternatingRowAttributes.Keys) {
             name = itm.ToString();
             value = (string[])alternatingRowAttributes[name];
             even.Add(name, value[0]);
             odd.Add(name, value[1]);
         }
     }
 }