Move from CVS.

git-svn-id: svn://svn.code.sf.net/p/itextsharp/code/trunk@2 820d3149-562b-4f88-9aa4-a8e61a3485cf

src/core/AssemblyInfo.cs

@@ -0,0 +1,58 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+
+//
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+//
+[assembly: AssemblyTitle("iTextSharp")]
+[assembly: AssemblyDescription("A free PDF library ported from Java iText.")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("")]
+[assembly: AssemblyCopyright("Copyright (C) 1999-2008 by Bruno Lowagie and Paulo Soares. All Rights Reserved.")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]        
+
+//
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Revision and Build Numbers 
+// by using the '*' as shown below:
+
+[assembly: AssemblyVersion("4.1.2")]
+
+//
+// In order to sign your assembly you must specify a key to use. Refer to the 
+// Microsoft .NET Framework documentation for more information on assembly signing.
+//
+// Use the attributes below to control which key is used for signing. 
+//
+// Notes: 
+//   (*) If no key is specified, the assembly is not signed.
+//   (*) KeyName refers to a key that has been installed in the Crypto Service
+//       Provider (CSP) on your machine. KeyFile refers to a file which contains
+//       a key.
+//   (*) If the KeyFile and the KeyName values are both specified, the 
+//       following processing occurs:
+//       (1) If the KeyName can be found in the CSP, that key is used.
+//       (2) If the KeyName does not exist and the KeyFile does exist, the key 
+//           in the KeyFile is installed into the CSP and used.
+//   (*) In order to create a KeyFile, you can use the sn.exe (Strong Name) utility.
+//       When specifying the KeyFile, the location of the KeyFile should be
+//       relative to the project output directory which is
+//       %Project Directory%\obj\<configuration>. For example, if your KeyFile is
+//       located in the project directory, you would specify the AssemblyKeyFile 
+//       attribute as [assembly: AssemblyKeyFile("..\\..\\mykey.snk")]
+//   (*) Delay Signing is an advanced option - see the Microsoft .NET Framework
+//       documentation for more information on this.
+//
+[assembly: AssemblyDelaySign(false)]
+[assembly: AssemblyKeyFile("..\\..\\itextsharp.snk")]
+[assembly: AssemblyKeyName("")]

src/core/System/Drawing/Dimension.cs

@@ -0,0 +1,158 @@
+using System;
+
+namespace System.Drawing {
+    /// <summary>
+    /// The <code>Dimension</code> class encapsulates the width and
+    /// height of a component (in int precision) in a single object. 
+    /// </summary>
+    /// <remarks>
+    /// The class is 
+    /// associated with certain properties of components. Several methods 
+    /// defined by the <code>Component</code> class and the 
+    /// <code>LayoutManager</code> interface return a <code>Dimension</code> object.
+    /// <p/>
+    /// Normally the values of <code>width</code> 
+    /// and <code>height</code> are non-negative ints. 
+    /// The constructors that allow you to create a dimension do 
+    /// not prevent you from setting a negative value for these properties. 
+    /// If the value of <code>width</code> or <code>height</code> is 
+    /// negative, the behavior of some methods defined by other objects is 
+    /// undefined. 
+    /// </remarks>
+    public class Dimension : Dimension2D {
+    
+        /// <summary>
+        /// The width dimension. Negative values can be used. 
+        /// </summary>
+        public int width;
+
+        /// <summary>
+        /// The height dimension. Negative values can be used. 
+        /// </summary>
+        public int height;
+
+        /// <summary>
+        /// Creates an instance of <code>Dimension</code> with a width 
+        /// of zero and a height of zero. 
+        /// </summary>
+        public Dimension() : this(0, 0) {}
+
+        /// <summary>
+        /// Creates an instance of <code>Dimension</code> whose width 
+        /// and height are the same as for the specified dimension. 
+        /// </summary>
+        /// <param name="d">
+        /// the specified dimension for the 
+        /// <code>width</code> and 
+        /// <code>height</code> values.
+        /// </param>
+        public Dimension(Dimension d) : this(d.width, d.height) {}
+
+        /// <summary>
+        /// Constructs a Dimension and initializes it to the specified width and
+        /// specified height.
+        /// </summary>
+        /// <param name="width">the specified width dimension</param>
+        /// <param name="height">the specified height dimension</param>
+        public Dimension(int width, int height) {
+            this.width = width;
+            this.height = height;
+        }
+
+        /// <summary>
+        /// Returns the width of this dimension in double precision.
+        /// </summary>
+        /// <value>the width</value>
+        public override double Width {
+            get {
+                return width;
+            }
+        }
+
+        /// <summary>
+        /// Returns the height of this dimension in double precision.
+        /// </summary>
+        /// <value>the height</value>
+        public override double Height {
+            get {
+                return height;
+            }
+        }
+
+        /// <summary>
+        /// Set the size of this Dimension object to the specified width
+        /// and height in double precision.
+        /// </summary>
+        /// <param name="width">the new width for the Dimension object</param>
+        /// <param name="height">the new height for the Dimension object</param>
+        public override void SetSize(double width, double height) {
+            width = (int) Math.Ceiling(width);
+            height = (int) Math.Ceiling(height);
+        }
+
+        /// <summary>
+        /// Get/set the size of this <code>Dimension</code> object.
+        /// </summary>
+        /// <value>the size</value>
+        public new Dimension Size {
+            get {
+                return new Dimension(width, height);
+            }
+
+            set {
+                SetSize(value.width, value.height);
+            }
+        }    
+
+        /// <summary>
+        /// Set the size of this <code>Dimension</code> object 
+        /// to the specified width and height.
+        /// </summary>
+        /// <param name="width">the new width for this <code>Dimension</code> object.</param>
+        /// <param name="height">the new height for this <code>Dimension</code> object.</param>
+        public void SetSize(int width, int height) {
+            this.width = width;
+            this.height = height;
+        }    
+
+        /// <summary>
+        /// Checks whether two dimension objects have equal values.
+        /// </summary>
+        /// <param name="obj"></param>
+        /// <returns></returns>
+        public override bool Equals(Object obj) {
+            if (obj is Dimension) {
+                Dimension d = (Dimension)obj;
+                return (width == d.width) && (height == d.height);
+            }
+            return false;
+        }
+
+        /// <summary>
+        /// Returns the hash code for this Dimension.
+        /// </summary>
+        /// <returns>a hash code</returns>
+        public override int GetHashCode() {
+            int sum = width + height;
+            return sum * (sum + 1)/2 + width;
+        }
+
+        /// <summary>
+        /// Returns a string representation of the values of this 
+        /// <code>Dimension</code> object's <code>height</code> and 
+        /// <code>width</code> fields.
+        /// </summary>
+        /// <remarks>
+        /// This method is intended to be used only 
+        /// for debugging purposes, and the content and format of the returned 
+        /// string may vary between implementations. The returned string may be 
+        /// empty but may not be <code>null</code>.
+        /// </remarks>
+        /// <returns>a string representation of this <code>Dimension</code>
+        /// object.
+        /// </returns>
+        public override string ToString() {
+            return this.GetType().Name + "[width=" + width + ",height=" + height + "]";
+        }
+    }
+}

src/core/System/Drawing/Dimension2D.cs

@@ -0,0 +1,69 @@
+using System;
+
+namespace System.Drawing {
+    /// <summary>
+    /// The <code>Dimension2D</code> class is to encapsulate a width 
+    /// and a height dimension.
+    /// </summary>
+    /// <remarks>
+    /// This class is only the abstract baseclass for all objects that
+    /// store a 2D dimension.
+    /// The actual storage representation of the sizes is left to
+    /// the subclass.
+    /// </remarks>
+    public abstract class Dimension2D : ICloneable {
+        /// <summary>
+        /// This is an abstract class that cannot be instantiated directly.
+        /// Type-specific implementation subclasses are available for
+        /// instantiation and provide a number of formats for storing
+        /// the information necessary to satisfy the various accessor
+        /// methods below.
+        /// </summary>
+        /// <seealso cref="T:System.Drawing.Dimension"/>
+        protected Dimension2D() {
+        }
+
+        /// <summary>
+        /// Returns the width of this <code>Dimension</code> in double 
+        /// precision.
+        /// </summary>
+        ///    <value>the width</value>
+        public abstract double Width {get;}
+
+        /// <summary>
+        /// Returns the height of this <code>Dimension</code> in double 
+        /// precision.
+        /// </summary>
+        /// <value>the height</value>
+        public abstract double Height {get;}
+
+        /// <summary>
+        /// Sets the size of this <code>Dimension</code> object to the 
+        /// specified width and height.
+        /// </summary>
+        /// <param name="width">the new width for the <code>Dimension</code>
+        /// object</param>
+        /// <param name="height">the new height for the <code>Dimension</code> 
+        /// object</param>
+        public abstract void SetSize(double width, double height);
+
+        /// <summary>
+        /// Sets the size of this <code>Dimension2D</code> object to 
+        /// match the specified size.
+        /// </summary>
+        /// <value>the size</value>
+        public Dimension2D Size {
+            set {
+                SetSize(value.Width, value.Height);
+            }
+        }
+
+        /// <summary>
+        /// Creates a new object of the same class as this object.
+        /// </summary>
+        /// <returns>a clone of this instance</returns>
+        public Object Clone() {
+            throw new Exception("not implemented");
+        }
+    }
+}

src/core/System/util/ListIterator.cs

@@ -0,0 +1,43 @@
+using System;
+using System.Collections;
+
+namespace System.util {
+    /// <summary>
+    /// Summary description for ListIterator.
+    /// </summary>
+    public class ListIterator {
+        ArrayList col;
+        int cursor = 0;
+        int lastRet = -1;
+
+        public ListIterator(ArrayList col) {
+            this.col = col;
+        }
+
+        public bool HasNext() {
+            return cursor != col.Count;
+        }
+
+        public object Next() {
+            Object next = col[cursor];
+            lastRet = cursor++;
+            return next;
+        }
+
+        public object Previous() {
+            int i = cursor - 1;
+            Object previous = col[i];
+            lastRet = cursor = i;
+            return previous;
+        }
+
+        public void Remove() {
+            if (lastRet == -1)
+                throw new InvalidOperationException();
+            col.RemoveAt(lastRet);
+            if (lastRet < cursor)
+                cursor--;
+            lastRet = -1;
+        }
+    }
+}

src/core/System/util/Properties.cs

@@ -0,0 +1,209 @@
+using System;
+using System.Text;
+using System.IO;
+using System.Collections;
+
+namespace System.util
+{
+    /// <summary>
+    /// Summary description for Properties.
+    /// </summary>
+    public class Properties
+    {
+        private Hashtable _col;
+        private const string whiteSpaceChars = " \t\r\n\f";
+        private const string keyValueSeparators = "=: \t\r\n\f";
+        private const string strictKeyValueSeparators = "=:";
+
+        public Properties()
+        {
+            _col = new Hashtable();
+        }
+
+        public string Remove(string key) {
+            string retval = (string)_col[key];
+            _col.Remove(key);
+            return retval;
+        }
+
+        public IEnumerator GetEnumerator() {
+            return _col.GetEnumerator();
+        }
+
+        public bool ContainsKey(string key) {
+            return _col.ContainsKey(key);            
+        }
+
+        public virtual void Add(string key, string value) {
+            _col[key] = value;        
+        }
+
+        public void AddAll(Properties col) {
+            foreach (string itm in col.Keys) {
+                _col[itm] = col[itm];
+            }
+        }
+
+        public int Count {
+            get {
+                return _col.Count;
+            }
+        }
+
+        public virtual string this[string key] {
+            get {
+                return (string)_col[key];
+            }
+
+            set {
+                _col[key] = value;
+            }
+        }
+
+        public ICollection Keys {
+            get {
+                return _col.Keys;
+            }
+        }
+
+        public void Clear() {
+            _col.Clear();
+        }
+
+        public void Load(Stream inStream) {
+            StreamReader inp = new StreamReader(inStream, Encoding.GetEncoding(1252));
+            while (true) {
+                // Get next line
+                String line = inp.ReadLine();
+                if (line == null)
+                    return;
+
+                if (line.Length > 0) {
+                
+                    // Find start of key
+                    int len = line.Length;
+                    int keyStart;
+                    for (keyStart=0; keyStart<len; keyStart++)
+                        if (whiteSpaceChars.IndexOf(line[keyStart]) == -1)
+                            break;
+
+                    // Blank lines are ignored
+                    if (keyStart == len)
+                        continue;
+
+                    // Continue lines that end in slashes if they are not comments
+                    char firstChar = line[keyStart];
+                    if ((firstChar != '#') && (firstChar != '!')) {
+                        while (ContinueLine(line)) {
+                            String nextLine = inp.ReadLine();
+                            if (nextLine == null)
+                                nextLine = "";
+                            String loppedLine = line.Substring(0, len-1);
+                            // Advance beyond whitespace on new line
+                            int startIndex;
+                            for (startIndex=0; startIndex<nextLine.Length; startIndex++)
+                                if (whiteSpaceChars.IndexOf(nextLine[startIndex]) == -1)
+                                    break;
+                            nextLine = nextLine.Substring(startIndex,nextLine.Length - startIndex);
+                            line = loppedLine+nextLine;
+                            len = line.Length;
+                        }
+
+                        // Find separation between key and value
+                        int separatorIndex;
+                        for (separatorIndex=keyStart; separatorIndex<len; separatorIndex++) {
+                            char currentChar = line[separatorIndex];
+                            if (currentChar == '\\')
+                                separatorIndex++;
+                            else if (keyValueSeparators.IndexOf(currentChar) != -1)
+                                break;
+                        }
+
+                        // Skip over whitespace after key if any
+                        int valueIndex;
+                        for (valueIndex=separatorIndex; valueIndex<len; valueIndex++)
+                            if (whiteSpaceChars.IndexOf(line[valueIndex]) == -1)
+                                break;
+
+                        // Skip over one non whitespace key value separators if any
+                        if (valueIndex < len)
+                            if (strictKeyValueSeparators.IndexOf(line[valueIndex]) != -1)
+                                valueIndex++;
+
+                        // Skip over white space after other separators if any
+                        while (valueIndex < len) {
+                            if (whiteSpaceChars.IndexOf(line[valueIndex]) == -1)
+                                break;
+                            valueIndex++;
+                        }
+                        String key = line.Substring(keyStart, separatorIndex - keyStart);
+                        String value = (separatorIndex < len) ? line.Substring(valueIndex, len - valueIndex) : "";
+
+                        // Convert then store key and value
+                        key = LoadConvert(key);
+                        value = LoadConvert(value);
+                        Add(key, value);
+                    }
+                }
+            }
+        }
+
+        /*
+        * Converts encoded &#92;uxxxx to unicode chars
+        * and changes special saved chars to their original forms
+        */
+        private String LoadConvert(String theString) {
+            char aChar;
+            int len = theString.Length;
+            StringBuilder outBuffer = new StringBuilder(len);
+
+            for (int x=0; x<len; ) {
+                aChar = theString[x++];
+                if (aChar == '\\') {
+                    aChar = theString[x++];
+                    if (aChar == 'u') {
+                        // Read the xxxx
+                        int value=0;
+                        for (int i=0; i<4; i++) {
+                            aChar = theString[x++];
+                            switch (aChar) {
+                                case '0': case '1': case '2': case '3': case '4':
+                                case '5': case '6': case '7': case '8': case '9':
+                                    value = (value << 4) + aChar - '0';
+                                    break;
+                                case 'a': case 'b': case 'c':
+                                case 'd': case 'e': case 'f':
+                                    value = (value << 4) + 10 + aChar - 'a';
+                                    break;
+                                case 'A': case 'B': case 'C':
+                                case 'D': case 'E': case 'F':
+                                    value = (value << 4) + 10 + aChar - 'A';
+                                    break;
+                                default:
+                                    throw new ArgumentException(
+                                        "Malformed \\uxxxx encoding.");
+                            }
+                        }
+                        outBuffer.Append((char)value);
+                    } else {
+                        if (aChar == 't') aChar = '\t';
+                        else if (aChar == 'r') aChar = '\r';
+                        else if (aChar == 'n') aChar = '\n';
+                        else if (aChar == 'f') aChar = '\f';
+                        outBuffer.Append(aChar);
+                    }
+                } else
+                    outBuffer.Append(aChar);
+            }
+            return outBuffer.ToString();
+        }
+
+        private bool ContinueLine(String line) {
+            int slashCount = 0;
+            int index = line.Length - 1;
+            while ((index >= 0) && (line[index--] == '\\'))
+                slashCount++;
+            return (slashCount % 2 == 1);
+        }
+    }
+}

src/core/System/util/StringTokenizer.cs

@@ -0,0 +1,130 @@
+using System;
+/*
+ * $Id: StringTokenizer.cs,v 1.4 2006/06/16 10:52:26 psoares33 Exp $
+ *
+ * Copyright 2006 by Paulo Soares.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License isp distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code isp 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code isp Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code isp Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library isp free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library isp distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+
+namespace System.util {
+
+    // a replacement for the StringTokenizer java class
+    // it's more or less the same as the one in the GNU classpath
+    public class StringTokenizer {
+        private int pos;
+        private String str;
+        private int len;
+        private String delim;
+        private bool retDelims;
+
+        public StringTokenizer(String str) : this(str, " \t\n\r\f", false) {
+        }
+
+        public StringTokenizer(String str, String delim) : this(str, delim, false) {
+        }
+
+        public StringTokenizer(String str, String delim, bool retDelims) {
+            len = str.Length;
+            this.str = str;
+            this.delim = delim;
+            this.retDelims = retDelims;
+            this.pos = 0;
+        }
+
+        public bool HasMoreTokens() {
+            if (! retDelims) {
+                while (pos < len && delim.IndexOf(str[pos]) >= 0)
+                    pos++;
+            }
+            return pos < len;
+        }
+
+        public String NextToken(String delim) {
+            this.delim = delim;
+            return NextToken();
+        }
+
+        public String NextToken() {
+            if (pos < len && delim.IndexOf(str[pos]) >= 0) {
+                if (retDelims)
+                    return str.Substring(pos++, 1);
+                while (++pos < len && delim.IndexOf(str[pos]) >= 0);
+            }
+            if (pos < len) {
+                int start = pos;
+                while (++pos < len && delim.IndexOf(str[pos]) < 0);
+
+                return str.Substring(start, pos - start);
+            }
+            throw new IndexOutOfRangeException();
+        }
+
+        public int CountTokens() {
+            int count = 0;
+            int delimiterCount = 0;
+            bool tokenFound = false;
+            int tmpPos = pos;
+
+            while (tmpPos < len) {
+                if (delim.IndexOf(str[tmpPos++]) >= 0) {
+                    if (tokenFound) {
+                        count++;
+                        tokenFound = false;
+                    }
+                    delimiterCount++;
+                }
+                else {
+                    tokenFound = true;
+                    while (tmpPos < len
+                        && delim.IndexOf(str[tmpPos]) < 0)
+                        ++tmpPos;
+                }
+            }
+            if (tokenFound)
+                count++;
+            return retDelims ? count + delimiterCount : count;
+        }
+    }
+}

src/core/System/util/Util.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Globalization;
+
+namespace System.util
+{
+    /// <summary>
+    /// Summary description for Util.
+    /// </summary>
+    public class Util
+    {
+        public static int USR(int op1, int op2) {        
+            if (op2 < 1) {
+                return op1;
+            } else {
+                return unchecked((int)((uint)op1 >> op2));
+            }
+        }
+
+        public static bool EqualsIgnoreCase(string s1, string s2) {
+            return CultureInfo.InvariantCulture.CompareInfo.Compare(s1, s2, CompareOptions.IgnoreCase) == 0;
+        }
+
+        public static int CompareToIgnoreCase(string s1, string s2) {
+            return CultureInfo.InvariantCulture.CompareInfo.Compare(s1, s2, CompareOptions.IgnoreCase);
+        }
+    }
+}

src/core/System/util/collections/Algorithm.cs

@@ -0,0 +1,49 @@
+using System;
+
+namespace System.util.collections
+{
+    /// <summary>
+    /// Very basic algorithms tool class.
+    /// </summary>
+    public class k_Algorithm
+    {
+        public static k_Iterator Copy(k_Iterator ak_SrcFirst, k_Iterator ak_BehindSrcLast, k_Iterator ak_DstFirst)
+        {
+            k_Iterator lk_Src = ak_SrcFirst.Clone(), lk_Dst = ak_DstFirst.Clone();
+            while (lk_Src != ak_BehindSrcLast)
+            {
+                lk_Dst.Current = lk_Src.Current;
+                lk_Src.Next(); lk_Dst.Next();
+            }
+            return lk_Dst;    
+        }
+
+        public static k_Iterator CopyBackward(k_Iterator ak_SrcFirst, k_Iterator ak_BehindSrcLast, k_Iterator ak_BehindDstLast)
+        {
+            k_Iterator lk_Src = ak_BehindSrcLast.Clone(), lk_Dst = ak_BehindDstLast.Clone();
+            while (lk_Src != ak_SrcFirst)
+            {
+                lk_Src.Prev(); lk_Dst.Prev();
+                lk_Dst.Current = lk_Src.Current;
+            }
+            return lk_Dst;
+        }
+
+        public static void Fill(k_Iterator ak_DstFirst, k_Iterator ak_BehindDstLast, object ak_Value)
+        {
+            for (k_Iterator lk_Iter = ak_DstFirst.Clone(); lk_Iter != ak_BehindDstLast; lk_Iter.Next())
+                lk_Iter.Current = ak_Value;
+        }
+
+        public static k_Iterator Find(k_Iterator ak_First, k_Iterator ak_Last, object ak_Value)
+        {
+            k_Iterator lk_Iter = ak_First.Clone();
+            for (; lk_Iter != ak_Last; lk_Iter.Next())
+            {
+                if (object.Equals(lk_Iter.Current, ak_Value))
+                    break;
+            }
+            return lk_Iter;
+        }
+    }
+}

src/core/System/util/collections/Container.cs

@@ -0,0 +1,64 @@
+using System;
+using System.Collections;
+
+namespace System.util.collections
+{
+    /// <summary>
+    /// Base interface for all containers
+    /// </summary>
+    public interface IContainer : ICollection, ICloneable
+    {
+        k_Iterator Begin { get; }
+        k_Iterator End { get; }
+
+        bool IsEmpty { get; }
+
+        k_Iterator Find(object ak_Value);
+    
+        k_Iterator Erase(k_Iterator ak_Where);
+        k_Iterator Erase(k_Iterator ak_First, k_Iterator ak_Last);
+    }
+
+    /// <summary>
+    /// Interface for non-associative sequential containers (k_Vector, k_Deque, k_List)
+    /// </summary>
+    public interface ISequence : IContainer, IList
+    {
+        object Front { get; set; }
+        object Back { get; set; }
+
+        void PushFront(object ak_Value);
+        void PopFront();
+        
+        void PushBack(object ak_Value);
+        void PopBack();
+
+        void Assign(k_Iterator ak_SrcBegin, k_Iterator ak_SrcEnd);
+        void Assign(object ak_Value, int ai_Count);
+
+        void Insert(k_Iterator ak_Where, object ak_Value);
+        void Insert(k_Iterator ak_Where, k_Iterator ak_SrcBegin, k_Iterator ak_SrcEnd);
+    }
+
+    /// <summary>
+    /// Interface for IDictionary derived containers which provide key to value mapping (k_HashTable)
+    /// </summary>
+    public interface IMap : IContainer, IDictionary
+    {
+        k_Iterator FindKey(object ak_Key);
+
+        void Add(DictionaryEntry ar_Item);
+        void Insert(k_Iterator ak_SrcBegin, k_Iterator ak_SrcEnd);
+    }
+
+    /// <summary>
+    /// Interface for sorted mapping containers (k_SkipList, k_Tree)
+    /// </summary>
+    public interface ISortedMap : IMap
+    {
+        IComparer Comparer { get; }
+
+        k_Iterator LowerBound(object ak_Key);
+        k_Iterator UpperBound(object ak_Key);
+    }
+}

src/core/System/util/collections/Deque.cs

@@ -0,0 +1,470 @@
+using System;
+using System.Collections;
+
+namespace System.util.collections
+{
+    /// <summary>
+    /// Circular buffer of arrays
+    /// </summary>
+    public class k_Deque : ISequence
+    {
+        #region k_BlockIterator Implementation
+
+        private class k_BlockIterator : k_Iterator
+        {
+            private readonly k_Deque mk_Deque;
+            private int mi_Index;
+            private int mi_BlockIndex;
+            private int mi_BlockOffset;
+
+            public k_BlockIterator(k_Deque ak_Deque, int ai_Index)
+            {
+                mk_Deque = ak_Deque;
+                mi_Index = ai_Index;
+                mi_BlockIndex = mk_Deque.CalcBlockAndPos(mi_Index, out mi_BlockOffset);
+            }
+
+            public override void Move(int ai_Count)
+            {
+                int li_Index = mi_Index + ai_Count;
+
+                if (li_Index > mk_Deque.Count)
+                    throw new InvalidOperationException("Tried to move beyond end element.");
+                else if (li_Index < 0)
+                    throw new InvalidOperationException("Tried to move before first element.");
+
+                mi_Index = li_Index;
+                mi_BlockOffset += ai_Count;
+
+                if (mi_BlockOffset >= k_Deque.mi_BlockSize || mi_BlockOffset < 0)
+                    mi_BlockIndex = mk_Deque.CalcBlockAndPos(mi_Index, out mi_BlockOffset);
+            }
+
+            public override int Distance(k_Iterator ak_Iter)
+            {
+                return mi_Index - ((k_BlockIterator)ak_Iter).mi_Index;
+            }
+
+            public override object Collection
+            {
+                get { return mk_Deque; }
+            }
+
+            public override object Current
+            {
+                get 
+                {
+                    if (mi_Index < 0 || mi_Index >= mk_Deque.mi_Count)
+                        throw new k_InvalidPositionException();
+                    return mk_Deque.mk_Blocks[mi_BlockIndex][mi_BlockOffset];
+                }
+                set
+                {
+                    if (mi_Index < 0 || mi_Index >= mk_Deque.mi_Count)
+                        throw new k_InvalidPositionException();
+                    mk_Deque.mk_Blocks[mi_BlockIndex][mi_BlockOffset] = value;
+                }
+            }
+
+            public override bool Equals(object ak_Obj)
+            {
+                k_BlockIterator lk_Iter = ak_Obj as k_BlockIterator;
+                if (lk_Iter == null)
+                    return false;
+                
+                return (mi_Index == lk_Iter.mi_Index) && object.ReferenceEquals(this.Collection, lk_Iter.Collection);
+            }
+
+            public override int GetHashCode()
+            {
+                return mk_Deque.GetHashCode() ^ mi_Index;
+            }
+
+            public override k_Iterator Clone()
+            {
+                return new k_BlockIterator(mk_Deque, mi_Index);
+            }
+
+            internal int Index
+            {
+                get { return mi_Index; }
+            }
+        }
+
+        private class k_PinnedBlockIterator : k_BlockIterator
+        {
+            public k_PinnedBlockIterator(k_Deque ak_Deque, int ai_Index)
+                : base(ak_Deque, ai_Index)
+            {
+            }
+
+            public override void Move(int ai_Count)
+            {
+                throw new k_IteratorPinnedException();
+            }
+        }
+
+        #endregion
+
+        private const int mi_BlockSize = 16;
+        private object[][] mk_Blocks;
+
+        private int mi_Offset;
+        private int mi_Count;
+
+        public k_Deque()
+            : this(mi_BlockSize)
+        {
+        }
+
+        public k_Deque(int ai_Capacity)
+        {
+            if (ai_Capacity < 0)
+                throw new ArgumentException("Capacity must be positive.", "ai_Capacity");
+            mk_Blocks = new object[(ai_Capacity+mi_BlockSize-1)/mi_BlockSize][];
+            for (int i=0; i<mk_Blocks.Length; ++i)
+                mk_Blocks[i] = new object[mi_BlockSize];
+        }
+
+        // IContainer Members
+        public k_Iterator Begin
+        {
+            get { return new k_PinnedBlockIterator(this, 0); }
+        }
+
+        public k_Iterator End
+        {
+            get { return new k_PinnedBlockIterator(this, mi_Count); }
+        }
+
+        public bool IsEmpty
+        {
+            get { return (this.Count == 0); }
+        }
+
+        public k_Iterator Find(object ak_Value)
+        {
+            return k_Algorithm.Find(this.Begin, this.End, ak_Value);
+        }
+
+        public k_Iterator Erase(k_Iterator ak_Where)
+        {
+            return Erase(ak_Where, ak_Where + 1);
+        }
+
+        public k_Iterator Erase(k_Iterator ak_First, k_Iterator ak_Last)
+        {
+            if (ak_First == ak_Last)
+                return ak_Last;
+
+            int li_FirstIndex = ((k_BlockIterator)ak_First).Index;
+            int li_Count = ak_Last - ak_First;
+            int li_LastCount = this.End - ak_Last;
+
+            if (li_FirstIndex < li_LastCount)
+            {
+                k_Algorithm.CopyBackward(this.Begin, ak_First, ak_Last);
+                k_Algorithm.Fill(this.Begin, ak_First, null);
+                mi_Offset += li_Count;
+                mi_Offset %= (mk_Blocks.Length * mi_BlockSize);
+            }
+            else
+            {
+                k_Algorithm.Copy(ak_Last, this.End, ak_First);
+                k_Algorithm.Fill(ak_Last, this.End, null);
+            }
+
+            mi_Count -= li_Count;
+
+            return new k_BlockIterator(this, li_FirstIndex);
+        }
+        
+        // ISequence Members
+        public object Front
+        {
+            get { return this.Begin.Current; }
+            set { this.Begin.Current = value; }
+        }
+
+        public object Back
+        {
+            get { return (this.End-1).Current; }
+            set { (this.End-1).Current = value; }
+        }
+
+        public void PushFront(object ak_Value)
+        {
+            if (mi_Offset % mi_BlockSize == 0                        // currently on block boundary
+                && mk_Blocks.Length * mi_BlockSize - mi_Count < mi_BlockSize)
+            {
+                AllocateBlock(mi_BlockSize);
+            }
+
+            if (mi_Offset == 0)
+                mi_Offset = mk_Blocks.Length * mi_BlockSize;
+            --mi_Offset;
+            mk_Blocks[mi_Offset/mi_BlockSize][mi_Offset%mi_BlockSize] = ak_Value;
+            ++mi_Count;
+        }
+
+        public void PopFront()
+        {
+            Erase(this.Begin);
+        }
+
+        public void PushBack(object ak_Value)
+        {
+            if ((mi_Offset+mi_Count) % mi_BlockSize == 0            // currently on block boundary
+                && mk_Blocks.Length * mi_BlockSize - mi_Count < mi_BlockSize)
+            {
+                AllocateBlock(mi_BlockSize);
+            }
+
+            int li_Pos = mi_Offset + mi_Count;
+            int li_Block = li_Pos/mi_BlockSize;
+            if (li_Block >= mk_Blocks.Length)
+                li_Block -= mk_Blocks.Length;
+            mk_Blocks[li_Block][li_Pos%mi_BlockSize] = ak_Value;
+            ++mi_Count;
+        }
+
+        public void PopBack()
+        {
+            Erase(this.End-1);
+        }
+
+        public void Assign(k_Iterator ak_SrcBegin, k_Iterator ak_SrcEnd)
+        {
+            Clear();
+            Insert(this.End, ak_SrcBegin, ak_SrcEnd);
+        }
+
+        public void Assign(object ak_Value, int ai_Count)
+        {
+            Clear();
+            for (int i = 0; i < ai_Count; ++i)
+                Insert(this.End, ak_Value);
+        }
+        
+        public void Insert(k_Iterator ak_Where, object ak_Value)
+        {
+            if (ak_Where == this.Begin)
+                PushFront(ak_Value);
+            else if (ak_Where == this.End)
+                PushBack(ak_Value);
+            else
+            {
+                int li_Index = ((k_BlockIterator)ak_Where).Index;
+                if (mk_Blocks.Length * mi_BlockSize - mi_Count < mi_BlockSize)
+                    AllocateBlock(mi_BlockSize);
+                
+                ++mi_Count;
+                if (li_Index < mi_Count/2)
+                {
+                    if (mi_Offset == 0)
+                        mi_Offset = mk_Blocks.Length * mi_BlockSize;
+                    --mi_Offset;
+                    k_Iterator lk_Dest = k_Algorithm.Copy(this.Begin+1, this.Begin+li_Index+1, this.Begin);
+                    lk_Dest.Current = ak_Value;
+                }
+                else
+                {
+                    // count has been incremented - there is a free element at the end
+                    k_Iterator lk_Dest = this.Begin + li_Index;
+                    k_Algorithm.CopyBackward(lk_Dest, this.End - 1, this.End);
+                    lk_Dest.Current = ak_Value;
+                }
+            }
+        }
+
+        public void Insert(k_Iterator ak_Where, k_Iterator ak_SrcBegin, k_Iterator ak_SrcEnd)
+        {
+            int li_FirstIndex = ((k_BlockIterator)ak_Where).Index;
+            int li_Count = ak_SrcEnd - ak_SrcBegin;
+            if (mk_Blocks.Length * mi_BlockSize <= mi_Count + li_Count + mi_BlockSize)
+                AllocateBlock(li_Count);
+
+            mi_Count += li_Count;
+
+            k_Iterator lk_Dest;
+            if (li_FirstIndex < li_Count/2)
+            {
+                if (mi_Offset == 0)
+                    mi_Offset = mk_Blocks.Length * mi_BlockSize;
+                mi_Offset -= li_Count;
+                lk_Dest = k_Algorithm.Copy(this.Begin+li_Count, this.Begin+li_FirstIndex+li_Count, this.Begin);
+            }
+            else
+            {
+                // count has been incremented - there are li_Count free elements at the end
+                lk_Dest = this.Begin + li_FirstIndex;
+                k_Algorithm.CopyBackward(lk_Dest, this.End - li_Count, this.End);
+            }
+
+            k_Algorithm.Copy(ak_SrcBegin, ak_SrcEnd, lk_Dest);
+        }
+
+        #region IList Members
+
+        public int Add(object ak_Value)
+        {
+            PushBack(ak_Value);
+            return mi_Count;
+        }
+
+        public void Clear()
+        {
+            for (int i=0; i<mk_Blocks.Length; ++i)
+                mk_Blocks[i] = new object[mi_BlockSize];
+            mi_Count = 0;
+            mi_Offset = 0;
+        }
+
+        public bool Contains(object ak_Value)
+        {
+            return (Find(ak_Value) != this.End);
+        }
+
+        public int IndexOf(object ak_Value)
+        {
+            k_Iterator lk_Found = Find(ak_Value);
+            if (lk_Found == this.End)
+                return -1;
+            return ((k_BlockIterator)lk_Found).Index;
+        }
+
+        public void Insert(int ai_Index, object ak_Value)
+        {
+            Insert(this.Begin + ai_Index, ak_Value);
+        }
+
+        public void Remove(object ak_Value)
+        {
+            Erase(Find(ak_Value));
+        }
+
+        public void RemoveAt(int ai_Index)
+        {
+            Erase(this.Begin + ai_Index);
+        }
+
+        public bool IsReadOnly
+        {
+            get { return false; }
+        }
+
+        public bool IsFixedSize
+        {
+            get { return false; }
+        }
+
+        public object this[int ai_Index]
+        {
+            get
+            {
+                if (ai_Index >= mi_Count || ai_Index < 0)
+                    throw new ArgumentOutOfRangeException("Position out of boundary");
+
+                int li_Pos, li_Block = CalcBlockAndPos(ai_Index, out li_Pos);
+                return mk_Blocks[li_Block][li_Pos];
+            }
+            set
+            {
+                if (ai_Index >= mi_Count || ai_Index < 0)
+                    throw new ArgumentOutOfRangeException("Position out of boundary");
+
+                int li_Pos, li_Block = CalcBlockAndPos(ai_Index, out li_Pos);
+                mk_Blocks[li_Block][li_Pos] = value;
+            }
+        }
+
+        #endregion
+
+        #region ICollection Members
+
+        public void CopyTo(Array ak_Array, int ai_Index)
+        {
+            for (k_Iterator lk_Iter = this.Begin.Clone(); lk_Iter != this.End; lk_Iter.Next())
+                ak_Array.SetValue(lk_Iter.Current, ai_Index++);
+        }
+
+        public int Count
+        {
+            get { return mi_Count; }
+        }
+
+        public bool IsSynchronized
+        {
+            get { return false; }
+        }
+
+        public object SyncRoot
+        {
+            get { return this; }
+        }
+
+        #endregion
+
+        #region IEnumerable Members
+
+        public IEnumerator GetEnumerator()
+        {
+            return new k_IteratorEnumerator(this.Begin, this.End);
+        }
+
+        #endregion
+
+        #region ICloneable Members
+
+        public object Clone()
+        {
+            k_Deque lk_Clone = new k_Deque(this.Count);
+            lk_Clone.Insert(lk_Clone.End, this.Begin, this.End);
+            return lk_Clone;
+        }
+
+        #endregion
+
+        private void AllocateBlock(int ai_MinElements)
+        {
+            // number of new blocks - grow by half block count (150%)
+            int li_Increment = mk_Blocks.Length / 2;
+            if (ai_MinElements > li_Increment*mi_BlockSize)
+                li_Increment = (ai_MinElements + mi_BlockSize - 1)/mi_BlockSize;
+
+            object[][] lk_NewBlocks = new object[mk_Blocks.Length + li_Increment][];
+
+            // first move all blocks after offset to front
+            int li_StartBlock = mi_Offset / mi_BlockSize;
+            int li_BackCount = mk_Blocks.Length - li_StartBlock;
+            Array.Copy(mk_Blocks, li_StartBlock, lk_NewBlocks, 0, li_BackCount);
+            
+            int li_TotalOld = li_BackCount;
+
+            // second move all blocks before offset to end
+            int li_FrontCount = (mi_Offset + mi_Count + mi_BlockSize - 1) / mi_BlockSize - mk_Blocks.Length;
+            if (li_FrontCount > 0)
+            {
+                Array.Copy(mk_Blocks, 0, lk_NewBlocks, li_BackCount, li_FrontCount);
+                li_TotalOld += li_FrontCount;
+            }
+
+            // actually create new empty blocks
+            for (int i=li_TotalOld; i < li_TotalOld+li_Increment; ++i)
+                lk_NewBlocks[i] = new object[mi_BlockSize];
+
+            mk_Blocks = lk_NewBlocks;
+            mi_Offset %= mi_BlockSize;
+        }
+
+        private int CalcBlockAndPos(int ai_Index, out int ai_Pos)
+        {
+            ai_Pos = mi_Offset + ai_Index;
+            int li_BlockIndex = ai_Pos / mi_BlockSize;
+            if (li_BlockIndex >= mk_Blocks.Length)
+                li_BlockIndex -= mk_Blocks.Length;
+            ai_Pos %= mi_BlockSize;
+            return li_BlockIndex;
+        }
+    }
+}

src/core/System/util/collections/HashTable.cs

@@ -0,0 +1,658 @@
+using System;
+using System.Collections;
+
+namespace System.util.collections
+{
+    /// <summary>
+    /// A HashTable with iterators
+    /// </summary>
+    public class k_HashTable : IMap
+    {
+        #region static helper functions
+
+        private readonly static int[] mk_Primes = 
+        {
+            11, 17, 23, 29, 37, 47, 59, 71, 89, 107, 131, 163, 197, 239, 293, 353, 431, 521, 631, 761, 919,
+            1103, 1327, 1597, 1931, 2333, 2801, 3371, 4049, 4861, 5839, 7013, 8419, 10103, 12143, 14591,
+            17519, 21023, 25229, 30293, 36353, 43627, 52361, 62851, 75431, 90523, 108631, 130363, 
+            156437, 187751, 225307, 270371, 324449, 389357, 467237, 560689, 672827, 807403,
+            968897, 1162687, 1395263, 1674319, 2009191, 2411033, 2893249, 3471899, 4166287, 
+            4999559, 5999471, 7199369 
+        };
+
+        private static bool IsPrime(int ai_Number) 
+        {
+            if ((ai_Number & 1) == 0) 
+                return (ai_Number == 2);
+
+            int li_Max = (int)Math.Sqrt(ai_Number);
+            for (int li_Div=3; li_Div < li_Max; li_Div+=2)
+            {
+                if ((ai_Number % li_Div) == 0)
+                    return false;
+            }
+            return true;
+        }
+
+        private static int FindPrimeGreater(int ai_Min)
+        {
+            if (ai_Min < 0)
+                throw new ArgumentException("k_HashTable capacity overflow.");
+
+            // do binary search lookup in primes array
+            int li_Pos = Array.BinarySearch(mk_Primes, ai_Min);
+            if (li_Pos >= 0)
+                return mk_Primes[li_Pos];
+
+            li_Pos = ~li_Pos;
+            if (li_Pos < mk_Primes.Length)
+                return mk_Primes[li_Pos];
+
+            // ai_Min is greater than highest number in mk_Primes
+            for (int i = (ai_Min|1); i <= Int32.MaxValue; i+=2)
+            {
+                if (IsPrime(i))
+                    return i;
+            }
+            return ai_Min;
+        }
+
+        #endregion
+
+        #region Bucket Structure
+
+        private struct r_Bucket 
+        {
+            public object mk_Key;
+            public object mk_Value;
+            public int mi_HashCode;        // MSB (sign bit) indicates a collision.
+        }
+
+        #endregion
+
+        #region k_BucketIterator Implementation
+
+        private class k_BucketIterator : k_Iterator
+        {
+            private readonly k_HashTable mk_Table;
+            private int mi_Index;
+
+            public k_BucketIterator(k_HashTable ak_Table, int ai_Index)
+            {
+                mk_Table = ak_Table;
+                mi_Index = -1;
+                if (ai_Index >= 0)
+                    mi_Index = FindNext(ai_Index-1);
+            }
+
+            public override object Current
+            {
+                get
+                {
+                    if (mi_Index < 0 || mk_Table.mk_Buckets[mi_Index].mk_Key == null)
+                        throw new k_InvalidPositionException();
+
+                    r_Bucket lr_Bucket = mk_Table.mk_Buckets[mi_Index];
+                    return new DictionaryEntry(lr_Bucket.mk_Key, lr_Bucket.mk_Value);
+                }
+                set
+                {
+                    if (mi_Index < 0 || mk_Table.mk_Buckets[mi_Index].mk_Key == null)
+                        throw new k_InvalidPositionException();
+
+                    DictionaryEntry lr_Entry = (DictionaryEntry)value;
+                    r_Bucket lr_Bucket = mk_Table.mk_Buckets[mi_Index];
+                    if (mk_Table.mk_Comparer.Compare(lr_Entry.Key, lr_Bucket.mk_Key) != 0)
+                        throw new ArgumentException("Key values must not be changed.");
+                    mk_Table.mk_Buckets[mi_Index].mk_Value = lr_Entry.Value;
+                }
+            }
+
+            public override void Move(int ai_Count)
+            {
+                int li_NewIndex = mi_Index;
+
+                if (ai_Count > 0)
+                {
+                    while (ai_Count-- > 0)
+                    {
+                        if (li_NewIndex < 0)
+                            throw new InvalidOperationException("Tried to moved beyond end element.");
+
+                        li_NewIndex = FindNext(li_NewIndex);
+                    }
+                }
+                else
+                {
+                    while (ai_Count++ < 0)
+                    {
+                        if (li_NewIndex < 0)
+                            li_NewIndex = FindPrev(mk_Table.mk_Buckets.Length);
+                        else
+                            li_NewIndex = FindPrev(li_NewIndex);
+
+                        if (li_NewIndex < 0)
+                            throw new InvalidOperationException("Tried to move before first element.");
+                    }
+                }
+
+                mi_Index = li_NewIndex;
+            }
+
+            public override int Distance(k_Iterator ak_Iter)
+            {
+                k_BucketIterator lk_Iter = ak_Iter as k_BucketIterator;
+                if (lk_Iter == null || !object.ReferenceEquals(lk_Iter.Collection, this.Collection))
+                    throw new ArgumentException("Cannot determine distance of iterators belonging to different collections.");
+                
+                k_Iterator lk_End = mk_Table.End;
+    
+                int li_IndexDiff; 
+                if (this != lk_End && ak_Iter != lk_End)
+                    li_IndexDiff = mi_Index - lk_Iter.mi_Index;
+                else
+                    li_IndexDiff = (this == lk_End) ? 1 : -1;    // 1 is also fine when both are End
+
+                if (li_IndexDiff < 0)
+                {
+                    int li_Diff = 0;
+                    k_Iterator lk_Bck = this.Clone(); 
+                    for (; lk_Bck != ak_Iter && lk_Bck != lk_End; lk_Bck.Next())
+                        --li_Diff;
+
+                    if (lk_Bck == ak_Iter)
+                        return li_Diff;
+                } 
+                else
+                {
+                    int li_Diff = 0;
+                    k_Iterator lk_Fwd = ak_Iter.Clone(); 
+                    for (; lk_Fwd != this && lk_Fwd != lk_End; lk_Fwd.Next())
+                        ++li_Diff;
+
+                    if (lk_Fwd == this)
+                        return li_Diff;
+                }
+                
+                throw new Exception("Inconsistent state. Concurrency?");
+            }
+
+            public override object Collection
+            {
+                get { return mk_Table; }
+            }
+
+            public override bool Equals(object ak_Obj)
+            {
+                k_BucketIterator lk_Iter = ak_Obj as k_BucketIterator;
+                if (lk_Iter == null)
+                    return false;
+
+                return (mi_Index == lk_Iter.mi_Index && object.ReferenceEquals(mk_Table, lk_Iter.mk_Table));
+            }
+
+            public override int GetHashCode()
+            {
+                return mk_Table.GetHashCode() ^ mi_Index;
+            }
+
+            public override k_Iterator Clone()
+            {
+                return new k_BucketIterator(mk_Table, mi_Index);
+            }
+
+            private int FindPrev(int ai_Index)
+            {
+                --ai_Index;
+                r_Bucket[] lk_Buckets = mk_Table.mk_Buckets;
+                while (ai_Index >= 0 && lk_Buckets[ai_Index].mk_Key == null)
+                    --ai_Index;
+                if (ai_Index < -1)
+                    return -1;
+                return ai_Index;
+            }
+
+            private int FindNext(int ai_Index)
+            {
+                ++ai_Index;
+                r_Bucket[] lk_Buckets = mk_Table.mk_Buckets;
+                while (ai_Index < lk_Buckets.Length && lk_Buckets[ai_Index].mk_Key == null)
+                    ++ai_Index;
+
+                if (ai_Index >= lk_Buckets.Length)
+                    return -1;
+                return ai_Index;
+            }
+
+            internal int Index
+            {
+                get { return mi_Index; }
+            }
+        }
+
+        private class k_PinnedBucketIterator : k_BucketIterator
+        {
+            public k_PinnedBucketIterator(k_HashTable ak_Table, int ai_Index)
+                : base(ak_Table, ai_Index)
+            {
+            }
+
+            public override void Move(int ai_Count)
+            {
+                throw new k_IteratorPinnedException();
+            }
+        }
+
+        #endregion
+
+        private IHashCodeProvider mk_HashProvider;
+        private IComparer mk_Comparer;
+        private double md_LoadFactor;
+        private int mi_GrowSize;
+        private r_Bucket[] mk_Buckets;
+        private int mi_Count;
+        private readonly k_Iterator mk_End;
+
+        public k_HashTable()
+            : this(0, 0.72)
+        {
+        }
+
+        public k_HashTable(int ai_Capacity, double ad_LoadFactor)
+            : this(ai_Capacity, ad_LoadFactor, null, null)
+        {
+        }
+
+        public k_HashTable(int ai_Capacity, double ad_LoadFactor, IHashCodeProvider ak_HashProvider, IComparer ak_Comparer)
+        {
+            if (ad_LoadFactor <= .0 || ad_LoadFactor > 1.0)
+                throw new ArgumentException("Load factor must be greater than .0 and smaller or equal to 1.0", "ad_LoadFactor");
+            md_LoadFactor = ad_LoadFactor;
+            
+            double ld_Size = ai_Capacity/ad_LoadFactor;
+            if (ld_Size > int.MaxValue)
+                throw new ArgumentException("k_HashTable overflow");
+
+            int li_TableSize = FindPrimeGreater((int)ld_Size);
+            mk_Buckets = new r_Bucket[li_TableSize];
+            mi_GrowSize = (md_LoadFactor < 1.0) ? (int)(md_LoadFactor * li_TableSize) : li_TableSize-1;
+            
+            mk_HashProvider = ak_HashProvider;
+            mk_Comparer = ak_Comparer;
+
+            mk_End = new k_PinnedBucketIterator(this, -1);
+        }
+
+        // IContainer Members
+        public k_Iterator Begin
+        {
+            get 
+            { 
+                if (mi_Count == 0)
+                    return mk_End;
+                return new k_PinnedBucketIterator(this, 0);
+            }
+        }
+
+        public k_Iterator End
+        {
+            get { return mk_End; }
+        }
+
+        public bool IsEmpty
+        {
+            get { return (mi_Count == 0); }
+        }
+
+        public k_Iterator Find(object ak_Value)
+        {
+            DictionaryEntry lr_Item = (DictionaryEntry)ak_Value;
+            int li_Index = FindBucket(lr_Item.Key);
+            if (li_Index < 0 || !object.Equals(mk_Buckets[li_Index].mk_Value, lr_Item.Value))
+                return this.End;
+            return new k_BucketIterator(this, li_Index);
+        }
+
+        public k_Iterator Erase(k_Iterator ak_Where)
+        {
+            //System.Diagnostics.Debug.Assert(object.ReferenceEquals(this, ak_Where.Collection), "Iterator does not belong to this collection.");
+            k_Iterator lk_Successor = ak_Where + 1;
+            EmptyBucket(((k_BucketIterator)ak_Where).Index);
+            return lk_Successor;
+        }
+
+        public k_Iterator Erase(k_Iterator ak_First, k_Iterator ak_Last)
+        {
+            if (ak_First == this.Begin && ak_Last == this.End)
+            {
+                Clear();
+                return ak_Last.Clone();
+            }
+            
+            k_Iterator lk_Current = ak_First;
+            while (lk_Current != ak_Last)
+                lk_Current = Erase(lk_Current);
+            return lk_Current;
+        }
+
+        // IMap Members
+        public k_Iterator FindKey(object ak_Key)
+        {
+            return new k_BucketIterator(this, FindBucket(ak_Key));
+        }
+
+        public void Add(DictionaryEntry ar_Item)
+        {
+            Add(ar_Item.Key, ar_Item.Value);
+        }
+
+        public void Insert(k_Iterator ak_SrcBegin, k_Iterator ak_SrcEnd)
+        {
+            for (k_Iterator lk_Iter = ak_SrcBegin.Clone(); lk_Iter != ak_SrcEnd; lk_Iter.Next())
+                Add((DictionaryEntry)lk_Iter.Current);
+        }
+
+        #region IDictionary Members
+
+        public void Add(object ak_Key, object ak_Value)
+        {
+            SetValue(ak_Key, ak_Value, true);
+        }
+
+        public void Clear() 
+        {
+            if (mi_Count == 0)
+                return;
+
+            for (int i=0; i < mk_Buckets.Length; ++i)
+                mk_Buckets[i] = new r_Bucket();
+
+            mi_Count = 0;
+        }
+
+        public bool Contains(object ak_Key)
+        {
+            return (FindBucket(ak_Key) >= 0);
+        }
+
+        public void Remove(object ak_Key)
+        {
+            EmptyBucket(FindBucket(ak_Key));
+        }
+
+        public IDictionaryEnumerator GetEnumerator()
+        {
+            return new k_IteratorDictEnumerator(this.Begin, this.End);
+        }
+
+        public bool IsReadOnly
+        {
+            get { return false; }
+
+        }
+        public bool IsFixedSize
+        {
+            get { return false; }
+        }
+
+        public object this[object ak_Key]
+        {
+            get 
+            {
+                int li_Index = FindBucket(ak_Key);
+                if (li_Index < 0)
+                    return null;
+
+                return mk_Buckets[li_Index].mk_Value;
+            }
+            set 
+            {
+                SetValue(ak_Key, value, false);
+            }
+        }
+
+        public ICollection Keys
+        {
+            get
+            {
+                int i = 0;
+                object[] lk_Keys = new object[mi_Count];
+                foreach (DictionaryEntry lr_Entry in this)
+                    lk_Keys[i++] = lr_Entry.Key;
+                return lk_Keys;
+            }
+        }
+
+        public ICollection Values
+        {
+            get
+            {
+                int i=0;
+                object[] lk_Values = new object[mi_Count];
+                foreach (DictionaryEntry lr_Entry in this)
+                    lk_Values[i++] = lr_Entry.Value;
+                return lk_Values;
+            }
+        }
+
+        #endregion
+
+        #region ICollection Members
+
+        public void CopyTo(Array ak_Array, int ai_Index)
+        {
+            foreach (DictionaryEntry lr_Entry in this)
+                ak_Array.SetValue(lr_Entry, ai_Index++);
+        }
+
+        public int Count
+        {
+            get { return mi_Count; }
+        }
+
+        public bool IsSynchronized
+        {
+            get { return false; }
+        }
+
+        public object SyncRoot
+        {
+            get { return this; }
+        }
+
+        #endregion
+
+        #region IEnumerable Members
+
+        IEnumerator System.Collections.IEnumerable.GetEnumerator()
+        {
+            return new k_IteratorEnumerator(this.Begin, this.End);
+        }
+
+        #endregion
+        
+        #region ICloneable Members
+
+        public object Clone()
+        {
+            k_HashTable lk_Clone = new k_HashTable(this.Count, md_LoadFactor, mk_HashProvider, mk_Comparer);
+
+            int i = mk_Buckets.Length;
+            while (i-- > 0)
+            {
+                object lk_Key = mk_Buckets[i].mk_Key;
+                if (lk_Key != null)
+                    lk_Clone[lk_Key] = mk_Buckets[i].mk_Value;
+            }
+            return lk_Clone;
+        }
+
+        #endregion
+
+        private void EmptyBucket(int ai_Index)
+        {
+            if (ai_Index < 0 || ai_Index >= mk_Buckets.Length)
+                return;
+            
+            if (mk_Buckets[ai_Index].mk_Key == null)
+                throw new InvalidOperationException("Key was removed earlier.");
+
+            mk_Buckets[ai_Index].mi_HashCode &= unchecked((int)0x80000000);
+            mk_Buckets[ai_Index].mk_Key = null;
+            mk_Buckets[ai_Index].mk_Value = null;
+            --mi_Count;
+        }
+
+        private int FindBucket(object ak_Key)
+        {
+            if (ak_Key == null)
+                throw new ArgumentException("Key must not be null.", "ak_Key");
+
+            uint lui_BucketCount = (uint)mk_Buckets.Length;
+
+            uint lui_Increment;
+            uint lui_HashCode = ComputeHashAndStep(ak_Key, out lui_Increment);
+                
+            uint lui_Walker = lui_HashCode % lui_BucketCount;
+            r_Bucket lr_Bucket;
+            do
+            {
+                int li_Index = (int)lui_Walker;
+                lr_Bucket = mk_Buckets[li_Index];
+                if (lr_Bucket.mk_Key == null && lr_Bucket.mi_HashCode >= 0)
+                    break;    // stop on empty non-duplicate
+
+                if ((lr_Bucket.mi_HashCode & 0x7fffffff) == lui_HashCode
+                    && EqualsHelper(lr_Bucket.mk_Key, ak_Key))
+                    return li_Index;
+
+                lui_Walker += lui_Increment;
+                lui_Walker %= lui_BucketCount;
+            }
+            while (lr_Bucket.mi_HashCode < 0 && lui_Walker != lui_HashCode);
+
+            return -1;        // not found
+        }
+
+        private void SetValue(object ak_Key, object ak_Value, bool ab_Add)
+        {
+            if (mi_Count >= mi_GrowSize)
+                ExpandBucketsArray();
+
+            uint lui_BucketCount = (uint)mk_Buckets.Length;
+
+            uint lui_Increment;
+            uint lui_HashCode = ComputeHashAndStep(ak_Key, out lui_Increment);
+                
+            r_Bucket lr_Bucket;
+            int li_Free = -1;
+            uint lui_Walker = lui_HashCode % lui_BucketCount;
+            do
+            {
+                int li_Index = (int)lui_Walker;
+                lr_Bucket = mk_Buckets[li_Index];
+                if (li_Free < 0 && lr_Bucket.mk_Key == null && lr_Bucket.mi_HashCode < 0)
+                    li_Free = li_Index;
+
+                if (lr_Bucket.mk_Key == null && (lr_Bucket.mi_HashCode & unchecked(0x80000000)) == 0)
+                {
+                    if (li_Free >= 0)
+                        li_Index = li_Free;
+                    mk_Buckets[li_Index].mk_Key = ak_Key;
+                    mk_Buckets[li_Index].mk_Value = ak_Value;
+                    mk_Buckets[li_Index].mi_HashCode |= (int)lui_HashCode;
+                    ++mi_Count;
+                    return;
+                }
+
+                if ((lr_Bucket.mi_HashCode & 0x7fffffff) == lui_HashCode
+                    && EqualsHelper(lr_Bucket.mk_Key, ak_Key))
+                {
+                    if (ab_Add)
+                        throw new ArgumentException("duplicate key");
+                    mk_Buckets[li_Index].mk_Value = ak_Value;
+                    return;
+                }
+
+                // mark all as dupes as long as we have not found a free bucket
+                if (li_Free == -1)
+                    mk_Buckets[li_Index].mi_HashCode |= unchecked((int)0x80000000);
+
+                lui_Walker += lui_Increment;
+                lui_Walker %= lui_BucketCount;
+            }
+            while (lui_Walker != lui_HashCode);
+
+            if (li_Free == -1)
+                throw new InvalidOperationException("Corrupted hash table. Insert failed.");
+
+            mk_Buckets[li_Free].mk_Key = ak_Key;
+            mk_Buckets[li_Free].mk_Value = ak_Value;
+            mk_Buckets[li_Free].mi_HashCode |= (int)lui_HashCode;
+            ++mi_Count;
+        }
+
+        private static void InternalExpandInsert(r_Bucket[] ak_Buckets, r_Bucket ar_Bucket)
+        {
+            ar_Bucket.mi_HashCode &= 0x7fffffff;
+            uint lui_BucketCount = (uint)ak_Buckets.Length;
+            uint lui_Increment = (uint)(1 + ((((uint)ar_Bucket.mi_HashCode >> 5) + 1) % (lui_BucketCount - 1)));
+
+            uint lui_Walker = (uint)ar_Bucket.mi_HashCode % lui_BucketCount;
+            for (;;)
+            {
+                int li_Index = (int)lui_Walker;
+                if (ak_Buckets[li_Index].mk_Key == null)
+                {
+                    ak_Buckets[li_Index] = ar_Bucket;
+                    return;
+                }
+
+                // since current bucket is occupied mark it as duplicate
+                ak_Buckets[li_Index].mi_HashCode |= unchecked((int)0x80000000);
+
+                lui_Walker += lui_Increment;
+                lui_Walker %= lui_BucketCount;
+            }
+        }
+
+        private void ExpandBucketsArray()
+        {
+            int li_NewSize = FindPrimeGreater(mk_Buckets.Length * 2);
+
+            r_Bucket[] lk_Buckets = new r_Bucket[li_NewSize];
+            foreach (r_Bucket lr_Bucket in mk_Buckets)
+            {
+                if (lr_Bucket.mk_Key == null)
+                    continue;
+                InternalExpandInsert(lk_Buckets, lr_Bucket);
+            }
+
+            mk_Buckets = lk_Buckets;
+            mi_GrowSize = (md_LoadFactor < 1.0) ? (int)(md_LoadFactor * li_NewSize) : li_NewSize-1;
+        }
+
+        private uint ComputeHashAndStep(object ak_Key, out uint aui_Increment) 
+        {
+            // mask the sign bit (our collision indicator)
+            uint lui_HashCode = (uint)GetHashHelper(ak_Key) & 0x7fffffff;
+            // calc increment value relatively prime to mk_Buckets.Length 
+            aui_Increment = (uint)(1 + (((lui_HashCode >> 5) + 1) % ((uint)mk_Buckets.Length - 1)));
+            return lui_HashCode;
+        }
+
+        private int GetHashHelper(object ak_Key)
+        {
+            if (mk_HashProvider != null)
+                return mk_HashProvider.GetHashCode(ak_Key);
+            return ak_Key.GetHashCode();
+        }
+
+        private bool EqualsHelper(object ak_ObjA, object ak_ObjB)
+        {
+            if (mk_Comparer != null)
+                return (mk_Comparer.Compare(ak_ObjA, ak_ObjB) == 0);
+            return Object.Equals(ak_ObjA, ak_ObjB);
+        }
+    }
+}

src/core/System/util/collections/Iterator.cs

@@ -0,0 +1,323 @@
+using System;
+using System.Collections;
+
+namespace System.util.collections
+{
+    public abstract class k_Iterator : IComparable, ICloneable
+    {
+        public static k_Iterator operator ++(k_Iterator ak_Iter)
+        {
+            return ak_Iter + 1;
+        }
+
+        public static k_Iterator operator --(k_Iterator ak_Iter)
+        {
+            return ak_Iter - 1;
+        }
+
+        public static k_Iterator operator +(k_Iterator ak_Iter, int ai_Distance)
+        {
+            k_Iterator lk_Clone = ak_Iter.Clone();
+            lk_Clone.Move(ai_Distance);
+            return lk_Clone;
+        }
+
+        public static k_Iterator operator -(k_Iterator ak_Iter, int ai_Distance)
+        {
+            k_Iterator lk_Clone = ak_Iter.Clone();
+            lk_Clone.Move(-ai_Distance);
+            return lk_Clone;
+        }
+
+        public static int operator -(k_Iterator ak_Left, k_Iterator ak_Right)
+        {
+            return ak_Left.Distance(ak_Right);
+        }
+
+        public static bool operator ==(k_Iterator ak_Left, k_Iterator ak_Right)
+        {
+            return object.Equals(ak_Left, ak_Right);
+        }
+
+        public static bool operator !=(k_Iterator ak_Left, k_Iterator ak_Right)
+        {
+            return !object.Equals(ak_Left, ak_Right);
+        }
+
+        public override bool Equals(object ak_Obj)
+        {
+            return base.Equals(ak_Obj);    // implemented to avoid warning
+        }
+
+        public override int GetHashCode()
+        {
+            return base.GetHashCode();    // implemented to avoid warning
+        }
+
+        public int CompareTo(object ak_Obj)
+        {
+            k_Iterator lk_Iter = ak_Obj as k_Iterator;
+            if (lk_Iter == null || !object.ReferenceEquals(lk_Iter.Collection, this.Collection))
+                throw new ArgumentException("Cannot compare iterators of different origin.");
+
+            return Distance(lk_Iter);
+        }
+
+        object ICloneable.Clone()
+        {
+            return this.Clone();
+        }
+
+        public void Next()
+        {
+            Move(1);
+        }
+
+        public void Prev()
+        {
+            Move(-1);
+        }
+
+        public abstract object Current { get; set; }
+        public abstract object Collection { get; }
+        public abstract k_Iterator Clone();
+
+        public abstract void Move(int ai_Count);
+        public abstract int Distance(k_Iterator ak_Iter);
+    }
+
+    public class k_IteratorEnumerator : IEnumerator
+    {
+        protected k_Iterator mk_Current;
+        protected k_Iterator mk_Begin, mk_End;
+        protected bool mb_Fresh;
+
+        public k_IteratorEnumerator(k_Iterator ak_Begin, k_Iterator ak_End)
+        {
+            mk_Begin = ak_Begin;
+            mk_End = ak_End;
+            mb_Fresh = true;
+        }
+
+        #region IEnumerator Members
+
+        public bool MoveNext()
+        {
+            if (mb_Fresh)
+            {
+                mk_Current = mk_Begin.Clone();
+                mb_Fresh = false;
+            }
+            else if (mk_Current != mk_End)
+                mk_Current.Next();
+
+            return (mk_Current != mk_End);
+        }
+
+        public void Reset()
+        {
+            mb_Fresh = true;
+            mk_Current = null;
+        }
+
+        public object Current
+        {
+            get
+            {
+                if (mb_Fresh || mk_Current == mk_End)
+                    throw new InvalidOperationException("The enumerator is positioned before the first element of the collection or after the last element.");
+                return mk_Current.Current;
+            }
+        }
+
+        #endregion
+    }
+
+    public class k_IteratorDictEnumerator : k_IteratorEnumerator, IDictionaryEnumerator
+    {
+        public k_IteratorDictEnumerator(k_Iterator ak_Begin, k_Iterator ak_End)
+            : base(ak_Begin, ak_End)
+        {
+        }
+
+        #region IDictionaryEnumerator Members
+
+        public object Key
+        {
+            get { return this.Entry.Key; }
+        }
+
+        public object Value
+        {
+            get { return this.Entry.Value; }
+        }
+
+        public DictionaryEntry Entry
+        {
+            get { return (DictionaryEntry)this.Current; }
+        }
+
+        #endregion
+    }
+
+    public class k_IListIterator : k_Iterator
+    {
+        private readonly IList mk_List;
+        private int mi_Index;
+
+        public static k_IListIterator CreateBegin(IList ak_List)
+        {
+            return new k_PinnedIListIterator(ak_List, 0);
+        }
+
+        public static k_IListIterator CreateEnd(IList ak_List)
+        {
+            return new k_PinnedIListIterator(ak_List, ak_List.Count);
+        }
+
+        public k_IListIterator(IList ak_List, int ai_Index)
+        {
+            mk_List = ak_List;
+            mi_Index = ai_Index;
+        }
+
+        public override void Move(int ai_Count)
+        {
+            int li_Index = mi_Index + ai_Count;
+            
+            if (li_Index < 0)
+                throw new InvalidOperationException("Tried to move before first element.");
+            else if (li_Index > mk_List.Count)
+                throw new InvalidOperationException("Tried to moved beyond end element.");
+
+            mi_Index = li_Index;
+        }
+
+        public override int Distance(k_Iterator ak_Iter)
+        {
+            return mi_Index - ((k_IListIterator)ak_Iter).mi_Index;
+        }
+
+        public override object Collection
+        {
+            get { return mk_List; }
+        }
+
+        public override object Current
+        {
+            get
+            {
+                if (mi_Index < 0 || mi_Index >= mk_List.Count)
+                    throw new k_InvalidPositionException();
+                return mk_List[mi_Index];
+            }
+            set
+            {
+                if (mi_Index < 0 || mi_Index >= mk_List.Count)
+                    throw new k_InvalidPositionException();
+                mk_List[mi_Index] = value;
+            }
+        }
+
+        public override bool Equals(object ak_Obj)
+        {
+            k_IListIterator lk_Iter = ak_Obj as k_IListIterator;
+            if (lk_Iter == null)
+                return false;
+            return (mi_Index == lk_Iter.mi_Index) && object.ReferenceEquals(this.Collection, lk_Iter.Collection);
+        }
+
+        public override int GetHashCode()
+        {
+            return mk_List.GetHashCode() ^ mi_Index;
+        }
+
+        public override k_Iterator Clone()
+        {
+            return new k_IListIterator(mk_List, mi_Index);
+        }
+
+        internal int Index
+        {
+            get { return mi_Index; }
+        }
+    }
+
+    internal class k_PinnedIListIterator : k_IListIterator
+    {
+        public k_PinnedIListIterator(IList ak_List, int ai_Index)
+            : base(ak_List, ai_Index)
+        {
+        }
+
+        public override void Move(int ai_Count)
+        {
+            throw new k_IteratorPinnedException();
+        }
+    }
+
+    public class k_CollectionOnIterators : ICollection
+    {
+        private k_Iterator mk_Begin, mk_End;
+        private int mi_Count;
+
+        public k_CollectionOnIterators(k_Iterator ak_Begin, k_Iterator ak_End)
+        {
+            mk_Begin = ak_Begin;
+            mk_End = ak_End;
+            mi_Count = mk_End - mk_Begin;
+        }
+
+        #region ICollection Members
+
+        public int Count
+        {
+            get { return mi_Count; }
+        }
+
+        public bool IsSynchronized
+        {
+            get { return false; }
+        }
+
+        public object SyncRoot
+        {
+            get { return mk_Begin.Collection; }
+        }
+
+        public void CopyTo(Array ak_Array, int ai_Index)
+        {
+            foreach (object lk_Obj in this)
+                ak_Array.SetValue(lk_Obj, ai_Index++);
+        }
+
+        #endregion
+
+        #region IEnumerable Members
+
+        public IEnumerator GetEnumerator()
+        {
+            return new k_IteratorEnumerator(mk_Begin, mk_End);
+        }
+
+        #endregion
+    }
+
+    [Serializable]
+    public class k_IteratorPinnedException : InvalidOperationException
+    {
+        public k_IteratorPinnedException()
+            : base("Cannot move pinned iterator. Use Clone() to create a movable copy.")
+        {
+        }
+    }
+
+    [Serializable]
+    public class k_InvalidPositionException : InvalidOperationException
+    {
+        public k_InvalidPositionException()
+            : base("Iterator positioned on End or invalid element.")
+        {
+        }
+    }
+}

src/core/System/util/collections/List.cs

@@ -0,0 +1,537 @@
+using System;
+using System.Collections;
+
+namespace System.util.collections
+{
+    /// <summary>
+    /// A doubly linked list
+    /// </summary>
+    public class k_List : ISequence
+    {
+        #region k_Node Implementation
+
+        private class k_Node
+        {
+            private object mk_Value;
+            public k_Node mk_Prev, mk_Next;
+
+            public k_Node(object ak_Value)
+            {
+                mk_Value = ak_Value;
+            }
+
+            public object Value
+            {
+                get { return mk_Value; }
+                set { mk_Value = value; }
+            }
+        }
+
+        #endregion
+
+        #region k_NodeIterator Implementation
+
+        private class k_NodeIterator : k_Iterator, ICloneable
+        {
+            private readonly k_List mk_List;
+            private k_Node mk_Current;
+
+            public k_NodeIterator(k_List ak_List, k_Node ak_Node)
+            {
+                mk_List = ak_List;
+                mk_Current = ak_Node;
+            }
+
+            public override object Current
+            {
+                get
+                {
+                    if (mk_Current == null)
+                        throw new k_InvalidPositionException();
+                    return mk_Current.Value;
+                }
+                set
+                {
+                    if (mk_Current == null)
+                        throw new k_InvalidPositionException();
+                    mk_Current.Value = value;
+                }
+            }
+
+            public override object Collection
+            {
+                get { return mk_List; }
+            }
+
+            public override void Move(int ai_Count)
+            {
+                k_Node lk_NewPos = mk_Current;
+
+                int li_Count = ai_Count;
+                if (li_Count > 0)
+                {
+                    while (li_Count-- > 0)
+                    {
+                        if (lk_NewPos == null)
+                            throw new InvalidOperationException("Tried to moved beyond end element.");
+
+                        lk_NewPos = lk_NewPos.mk_Next;
+                    }
+                }
+                else
+                {
+                    while (li_Count++ < 0)
+                    {
+                        if (lk_NewPos == null)
+                            lk_NewPos = mk_List.mk_Tail;
+                        else
+                            lk_NewPos = lk_NewPos.mk_Prev;
+
+                        if (lk_NewPos == null)
+                            throw new InvalidOperationException("Tried to move before first element.");
+                    }
+                }
+                
+#if (DEBUG)
+                if (ai_Count != 0 && object.ReferenceEquals(mk_Current, lk_NewPos))
+                    throw new IndexOutOfRangeException("Iterator is positioned on invalid node.");
+#endif
+
+                mk_Current = lk_NewPos;
+            }
+
+            public override int Distance(k_Iterator ak_Iter)
+            {
+                k_NodeIterator lk_Iter = (k_NodeIterator)ak_Iter;
+
+                if (!this.IsValid || !lk_Iter.IsValid)
+                    throw new ArgumentException("Iterator is invalid.");
+
+                int li_Diff = 0;
+                k_Iterator lk_End = mk_List.End;
+                k_Iterator lk_Fwd = lk_Iter.Clone();
+                for (; lk_Fwd != this && lk_Fwd != lk_End; lk_Fwd.Next())
+                    ++li_Diff;
+
+                if (lk_Fwd == this)
+                    return li_Diff;
+
+                li_Diff = 0;
+                k_Iterator lk_Bck = this.Clone(); 
+                for (; lk_Bck != lk_Iter && lk_Bck != lk_End; lk_Bck.Next())
+                    --li_Diff;
+
+                if (lk_Bck == lk_Iter)
+                    return li_Diff;
+
+                throw new Exception("Inconsistent state. Concurrency?");
+            }
+
+            public override bool Equals(object ak_Obj)
+            {
+                k_NodeIterator lk_Iter = ak_Obj as k_NodeIterator;
+                if (lk_Iter == null)
+                    return false;
+                return object.ReferenceEquals(mk_Current, lk_Iter.mk_Current);
+            }
+
+            public override int GetHashCode()
+            {
+                if (mk_Current == null)
+                    return mk_List.GetHashCode();
+                return mk_Current.GetHashCode();
+            }
+
+            public override k_Iterator Clone()
+            {
+                return new k_NodeIterator(mk_List, mk_Current);
+            }
+
+            internal k_Node Node
+            {
+                get { return mk_Current; }
+            }
+
+            internal bool IsValid
+            {
+                get { return (mk_Current == null || (!object.ReferenceEquals(mk_Current.mk_Next, mk_Current) && !object.ReferenceEquals(mk_Current.mk_Prev, mk_Current))); }
+            }
+        }
+
+        private class k_PinnedNodeIterator : k_NodeIterator
+        {
+            public k_PinnedNodeIterator(k_List ak_List, k_Node ak_Node)
+                : base(ak_List, ak_Node)
+            {
+            }
+
+            public override void Move(int ai_Count)
+            {
+                throw new k_IteratorPinnedException();
+            }
+        }
+
+        #endregion
+
+        private int mi_Count;
+        private k_Node mk_Head, mk_Tail;
+        private k_Iterator mk_Begin, mk_End;
+
+        public k_List()
+        {
+            mk_End = new k_PinnedNodeIterator(this, null);
+            mk_Begin = mk_End;
+        }
+
+        // IContainer Members
+        public k_Iterator Begin
+        {
+            get 
+            { 
+                if (mi_Count == 0)
+                    return mk_End;
+                if (mk_Begin == null)
+                    mk_Begin = new k_PinnedNodeIterator(this, mk_Head);
+                return mk_Begin; 
+            }
+        }
+
+        public k_Iterator End
+        {
+            get { return mk_End; }
+        }
+
+        public bool IsEmpty
+        {
+            get { return (mi_Count == 0); }
+        }
+
+        public k_Iterator Find(object ak_Value)
+        {
+            return k_Algorithm.Find(this.Begin, this.End, ak_Value);
+        }
+        
+        public k_Iterator Erase(k_Iterator ak_Where)
+        {
+            //System.Diagnostics.Debug.Assert(object.ReferenceEquals(this, ak_Where.Collection), "Iterator does not belong to this list.");
+            if (ak_Where == this.End)
+                return this.End;
+            return Erase(ak_Where, ak_Where + 1);
+        }
+
+        public k_Iterator Erase(k_Iterator ak_First, k_Iterator ak_Last)
+        {
+            //System.Diagnostics.Debug.Assert(object.ReferenceEquals(this, ak_First.Collection) && object.ReferenceEquals(this, ak_Last.Collection), "Iterators do not belong to this collection.");
+            int li_Distance = ak_Last - ak_First;
+            if (li_Distance == 0)
+                return ak_Last;
+            
+            k_Node lk_First = ((k_NodeIterator)ak_First).Node;
+            k_Node lk_Prev = lk_First.mk_Prev;
+            k_Node lk_Next = (ak_Last != this.End) ? ((k_NodeIterator)ak_Last).Node : null;
+
+            if (lk_Prev != null)
+                lk_Prev.mk_Next = lk_Next;
+            else
+            {
+                //System.Diagnostics.Debug.Assert(object.ReferenceEquals(mk_Head, lk_First), "Inconsistent list state");
+                mk_Head = lk_Next;
+                mk_Begin = null;
+            }
+
+            if (lk_Next != null)
+                lk_Next.mk_Prev = lk_Prev;
+            else
+            {
+                //System.Diagnostics.Debug.Assert(object.ReferenceEquals(mk_Tail, ((k_NodeIterator)(ak_Last-1)).Node), "Inconsistent list state");
+                mk_Tail = lk_Prev;
+            }
+
+            mi_Count -= li_Distance;
+
+#if (DEBUG)            
+            // create invalid nodes linking to itself
+            k_Node lk_Node = lk_First;
+            while (lk_Node != null && lk_Node != lk_Next)
+            {
+                k_Node lk_Tmp = lk_Node.mk_Next;
+                lk_Node.mk_Next = lk_Node;
+                lk_Node.mk_Prev = lk_Node;
+
+                lk_Node = lk_Tmp;
+            }
+#endif    
+
+            return ak_Last;
+        }
+
+        // ISequence Members
+        public object Front
+        {
+            get 
+            {
+                if (this.IsEmpty)
+                    throw new InvalidOperationException("Empty list");
+                return mk_Head.Value; 
+            }
+            set
+            {
+                if (this.IsEmpty)
+                    throw new InvalidOperationException("Empty list");
+                mk_Head.Value = value;
+            }
+        }
+
+        public object Back
+        {
+            get
+            {
+                if (this.IsEmpty)
+                    throw new InvalidOperationException("Empty list");
+                return mk_Tail.Value;
+            }
+            set 
+            {
+                if (this.IsEmpty)
+                    throw new InvalidOperationException("Empty list");
+                mk_Tail.Value = value; 
+            }
+        }
+
+        public void PushFront(object ak_Value)
+        {
+            Insert(this.Begin, ak_Value);
+        }
+
+        public void PopFront()
+        {
+            Erase(this.Begin);
+        }
+
+        public void PushBack(object ak_Value)
+        {
+            Insert(this.End, ak_Value);
+        }
+
+        public void PopBack()
+        {
+            Erase(this.End-1);
+        }
+
+        public void Assign(k_Iterator ak_SrcBegin, k_Iterator ak_SrcEnd)
+        {
+            Clear();
+            Insert(this.End, ak_SrcBegin, ak_SrcEnd);
+        }
+
+        public void Assign(object ak_Value, int ai_Count)
+        {
+            Clear();
+            Insert(this.End, ak_Value, ai_Count);
+        }
+
+        public void Insert(k_Iterator ak_Where, object ak_Value)
+        {
+            //System.Diagnostics.Debug.Assert(object.ReferenceEquals(this, ak_Where.Collection), "Iterator does not belong to this collection.");
+
+            k_Node lk_New = new k_Node(ak_Value);
+            PasteNodeRange((k_NodeIterator)ak_Where, lk_New, lk_New);
+            ++mi_Count;
+        }
+
+        public void Insert(k_Iterator ak_Where, k_Iterator ak_SrcBegin, k_Iterator ak_SrcEnd)
+        {
+            //System.Diagnostics.Debug.Assert(object.ReferenceEquals(this, ak_Where.Collection), "Iterator does not belong to this collection.");
+
+            k_Node lk_Start = new k_Node(null), lk_End = lk_Start;
+            
+            int li_Count = 0;
+            for (k_Iterator lk_Iter = ak_SrcBegin.Clone(); lk_Iter != ak_SrcEnd; lk_Iter.Next(), ++li_Count)
+            {
+                k_Node lk_New = new k_Node(lk_Iter.Current);
+                lk_End.mk_Next = lk_New;
+                lk_New.mk_Prev = lk_End;
+                lk_End = lk_New;
+            }
+
+            if (li_Count > 0)
+            {
+                PasteNodeRange((k_NodeIterator)ak_Where, lk_Start.mk_Next, lk_End);
+                mi_Count += li_Count;
+            }
+        }
+
+        public void Insert(k_Iterator ak_Where, object ak_Value, int ai_Count)
+        {
+            //System.Diagnostics.Debug.Assert(object.ReferenceEquals(this, ak_Where.Collection), "Iterator does not belong to this collection.");
+
+            k_Node lk_Start = new k_Node(null), lk_End = lk_Start;
+            
+            for (int i=0; i<ai_Count; ++i)
+            {
+                k_Node lk_New = new k_Node(ak_Value);
+                lk_End.mk_Next = lk_New;
+                lk_New.mk_Prev = lk_End;
+                lk_End = lk_New;
+            }
+
+            if (ai_Count > 0)
+            {
+                PasteNodeRange((k_NodeIterator)ak_Where, lk_Start.mk_Next, lk_End);
+                mi_Count += ai_Count;
+            }
+        }
+        
+        #region IList Members
+
+        public int Add(object ak_Value)
+        {
+            Insert(this.End, ak_Value);
+            return mi_Count;
+        }
+
+        public void Clear()
+        {
+            mk_Head = mk_Tail = null;
+            mk_Begin = mk_End;
+            mi_Count = 0;
+        }
+
+        public bool Contains(object ak_Value)
+        {
+            return (this.Find(ak_Value) != this.End);
+        }
+
+        public int IndexOf(object ak_Value)
+        {
+            int li_Index = 0;
+            foreach (object lk_Val in this)
+            {
+                if (object.Equals(lk_Val, ak_Value))
+                    return li_Index;
+                ++li_Index;
+            }
+            return -1;
+        }
+
+        void IList.Insert(int ai_Index, object ak_Value)
+        {
+            this.Insert(this.Begin + ai_Index, ak_Value);
+        }
+
+        void IList.Remove(object ak_Value)
+        {
+            k_NodeIterator lk_Found = (k_NodeIterator)this.Find(ak_Value);
+            if (lk_Found != this.End)
+                Erase(lk_Found);
+        }
+
+        public void RemoveAt(int ai_Index)
+        {
+            Erase(this.Begin + ai_Index);
+        }
+
+        public bool IsFixedSize
+        {
+            get { return false; }
+        }
+
+        bool IList.IsReadOnly
+        {
+            get { return false; }
+        }
+
+        public object this[int index]
+        {
+            get 
+            { 
+                k_Iterator lk_Iter = this.Begin + index;
+                return lk_Iter.Current; 
+            }
+            set 
+            { 
+                k_Iterator lk_Iter = this.Begin + index;
+                lk_Iter.Current = value; 
+            }
+        }
+
+        #endregion
+
+        #region ICollection Members
+
+        public void CopyTo(Array ak_Array, int ai_Index)
+        {
+            foreach (object lk_Obj in this)
+                ak_Array.SetValue(lk_Obj, ai_Index++);
+        }
+
+        public int Count
+        {
+            get { return mi_Count; }
+        }
+
+        public bool IsSynchronized
+        {
+            get { return false; }
+        }
+
+        public object SyncRoot
+        {
+            get { return this; }
+        }
+
+        #endregion
+
+        #region IEnumerable Members
+
+        public IEnumerator GetEnumerator()
+        {
+            return new k_IteratorEnumerator(this.Begin, this.End);
+        }
+
+        #endregion
+
+        #region ICloneable Members
+
+        public object Clone()
+        {
+            k_List lk_Clone = new k_List();
+            for (k_Iterator lk_Iter = this.Begin.Clone(); lk_Iter != this.End; lk_Iter.Next())
+                lk_Clone.Add(lk_Iter.Current);
+            return lk_Clone;
+        }
+
+        #endregion
+
+        private void PasteNodeRange(k_NodeIterator ak_Where, k_Node ak_First, k_Node ak_Last)
+        {
+            if (ak_Where != this.End)
+            {
+                k_Node lk_Next = ak_Where.Node;
+                k_Node lk_Prev = lk_Next.mk_Prev;
+
+                ak_Last.mk_Next = lk_Next;
+                ak_First.mk_Prev = lk_Prev;
+                if (lk_Next != null)
+                    lk_Next.mk_Prev = ak_Last;
+                if (lk_Prev != null)
+                    lk_Prev.mk_Next = ak_First;
+            }
+            else
+            {
+                if (mk_Tail != null)
+                {
+                    mk_Tail.mk_Next = ak_First;
+                    ak_First.mk_Prev = mk_Tail;
+                }
+                mk_Tail = ak_Last;
+            }
+
+            if (ak_Where == this.Begin)
+            {
+                mk_Head = ak_First;
+                mk_Begin = null;        // recalc on next get
+            }
+        }
+    }
+}

src/core/System/util/collections/Queue.cs

@@ -0,0 +1,108 @@
+using System;
+using System.Collections;
+
+namespace System.util.collections
+{
+    /// <summary>
+    /// k_Queue is a first-in, first-out (FIFO) data structure.
+    /// It hides functionality of the underlying container (e.g. k_List, k_Deque) 
+    /// and provides a a basic queue class.
+    /// </summary>
+    public class k_Queue : ICollection
+    {
+        private ISequence mk_Container;
+
+        public k_Queue()
+            : this(typeof(k_Deque))
+        {
+        }
+
+        public k_Queue(Type ak_ContainerType)
+        {
+            mk_Container = Activator.CreateInstance(ak_ContainerType) as ISequence;
+            if (mk_Container == null)
+                throw new ArgumentException("Container type must implement ISequence.", "ak_ContainerType");
+        }
+
+        public k_Iterator Begin 
+        {
+            get { return mk_Container.Begin; } 
+        }
+
+        public k_Iterator End 
+        {
+            get { return mk_Container.End; }
+        }
+
+        public object Front
+        {
+            get { return mk_Container.Front; }
+        }
+
+        public object Back
+        {
+            get { return mk_Container.Back; }
+        }
+
+        public bool IsEmpty
+        {
+            get { return mk_Container.IsEmpty; }
+        }
+
+        public k_Iterator Erase(k_Iterator ak_Where)
+        {
+            return mk_Container.Erase(ak_Where);
+        }
+
+        public void Push(object ak_Value)
+        {
+            mk_Container.PushBack(ak_Value);
+        }
+
+        public object Pop()
+        {
+            object lk_Obj = mk_Container.Front;
+            mk_Container.PopFront();
+            return lk_Obj;
+        }
+
+        public IContainer UnderlyingContainer
+        {
+            get { return mk_Container; }
+        }
+
+        #region ICollection Members
+
+        public void CopyTo(Array ak_Array, int ai_Index)
+        {
+            foreach (object lk_Obj in this)
+                ak_Array.SetValue(lk_Obj, ai_Index++);
+        }
+
+        public int Count
+        {
+            get { return mk_Container.Count; }
+        }
+
+        public bool IsSynchronized
+        {
+            get { return false; }
+        }
+
+        public object SyncRoot
+        {
+            get { return this; }
+        }
+
+        #endregion
+
+        #region IEnumerable Members
+
+        public IEnumerator GetEnumerator()
+        {
+            return new k_IteratorEnumerator(mk_Container.Begin, mk_Container.End);
+        }
+
+        #endregion
+    }
+}

src/core/System/util/collections/SkipList.cs

@@ -0,0 +1,699 @@
+using System;
+using System.Collections;
+
+namespace System.util.collections
+{
+    /// <summary>
+    /// A Skip List
+    /// </summary>
+    public class k_SkipList : ISortedMap
+    {
+        #region k_Node Implementation
+
+        private class k_Node
+        {
+            private object mk_Key;
+            private object mk_Value;
+
+            private k_Node[] mk_Next;
+
+            public k_Node(object ak_Key, object ak_Value, int ai_Height)
+            {
+                mk_Next = new k_Node[ai_Height];
+                mk_Key = ak_Key;
+                mk_Value = ak_Value;
+            }
+
+            public object Key
+            {
+                get { return mk_Key; }
+            }
+
+            public object Value
+            {
+                get { return mk_Value; }
+                set { mk_Value = Value; }
+            }
+
+            public DictionaryEntry Item
+            {
+                get { return new DictionaryEntry(mk_Key, mk_Value); }
+            }
+
+            public k_Node[] Next
+            {
+                get { return mk_Next; }
+            }
+
+            public int Height
+            {
+                get { return mk_Next.Length; }
+            }
+        }
+
+        #endregion
+
+        #region k_NodeIterator Implementation
+
+        private class k_NodeIterator : k_Iterator
+        {
+            private readonly k_SkipList mk_List;
+            private k_Node mk_Current;
+
+            public k_NodeIterator(k_SkipList ak_List, k_Node ak_Node)
+            {
+                mk_List = ak_List;
+                mk_Current = ak_Node;
+            }
+
+            public override object Current
+            {
+                get 
+                { 
+                    if (mk_Current == null)
+                        throw new k_InvalidPositionException();
+                    return mk_Current.Item; 
+                }
+                set
+                {
+                    DictionaryEntry lr_Entry = (DictionaryEntry)value;
+                    if (mk_List.mk_Comparer.Compare(lr_Entry.Key, mk_Current.Key) != 0)
+                        throw new ArgumentException("Key values must not be changed.");
+                    mk_Current.Value = lr_Entry.Value;
+                }
+            }
+
+            public override object Collection
+            {
+                get { return mk_List; }
+            }
+
+            public override void Move(int ai_Count)
+            {
+                k_Node lk_NewPos = mk_Current;
+
+                if (ai_Count > 0)
+                {
+                    while (ai_Count-- > 0)
+                    {
+                        if (lk_NewPos == null)
+                            throw new InvalidOperationException("Tried to moved beyond end element.");
+
+                        lk_NewPos = mk_List.Next(lk_NewPos);
+                    }
+                }
+                else
+                {
+                    while (ai_Count++ < 0)
+                    {
+                        if (lk_NewPos == null)
+                            lk_NewPos = mk_List.RightMost();
+                        else
+                            lk_NewPos = mk_List.Previous(lk_NewPos);
+
+                        if (lk_NewPos == null)
+                            throw new InvalidOperationException("Tried to move before first element.");
+                    }
+                }
+
+                mk_Current = lk_NewPos;
+            }
+
+            public override int Distance(k_Iterator ak_Iter)
+            {
+                k_NodeIterator lk_Iter = (k_NodeIterator)ak_Iter;
+                k_Iterator lk_End = mk_List.End;
+    
+                int li_KeyDiff;
+                if (this == lk_End || ak_Iter == lk_End)
+                    li_KeyDiff = (this == lk_End && this != ak_Iter) ? 1 : 0;
+                else
+                    li_KeyDiff = mk_List.mk_Comparer.Compare(mk_Current.Key, lk_Iter.mk_Current.Key);
+
+                if (li_KeyDiff <= 0)
+                {
+                    int li_Diff = 0;
+                    k_Iterator lk_Bck = this.Clone(); 
+                    for (; lk_Bck != lk_Iter && lk_Bck != lk_End; lk_Bck.Next())
+                        --li_Diff;
+
+                    if (lk_Bck == lk_Iter)
+                        return li_Diff;
+                }
+                
+                if (li_KeyDiff >= 0)
+                {
+                    int li_Diff = 0;
+                    k_Iterator lk_Fwd = lk_Iter.Clone(); 
+                    for (; lk_Fwd != this && lk_Fwd != lk_End; lk_Fwd.Next())
+                        ++li_Diff;
+
+                    if (lk_Fwd == this)
+                        return li_Diff;
+                }
+                
+                throw new Exception("Inconsistent state. Concurrency?");
+            }
+
+            public override bool Equals(object ak_Obj)
+            {
+                k_NodeIterator lk_Iter = ak_Obj as k_NodeIterator;
+                if (lk_Iter == null)
+                    return false;
+                return object.ReferenceEquals(mk_Current, lk_Iter.mk_Current);
+            }
+
+            public override int GetHashCode()
+            {
+                if (mk_Current == null)
+                    return mk_List.GetHashCode();
+                return mk_Current.GetHashCode();
+            }
+
+            public override k_Iterator Clone()
+            {
+                return new k_NodeIterator(mk_List, mk_Current);
+            }
+
+            internal k_Node Node
+            {
+                get { return mk_Current; }
+            }
+        }
+
+        private class k_PinnedNodeIterator : k_NodeIterator
+        {
+            public k_PinnedNodeIterator(k_SkipList ak_List, k_Node ak_Node)
+                : base(ak_List, ak_Node)
+            {
+            }
+
+            public override void Move(int ai_Count)
+            {
+                throw new k_IteratorPinnedException();
+            }
+        }
+
+        #endregion
+
+        private static Random mk_Rand = new Random();
+
+        private IComparer mk_Comparer;
+        private double md_Prob;
+        private int mi_MaxLevel;
+        private int mi_HighestNode;
+        private k_Node mk_Head;
+        private int mi_Count;
+        private k_Iterator mk_End;
+
+        public k_SkipList()
+            : this(System.Collections.Comparer.Default)
+        {
+        }
+
+        public k_SkipList(IComparer ak_Comparer)
+            : this(ak_Comparer, 1.0/Math.E, 16)
+        {
+        }
+
+        public k_SkipList(IComparer ak_Comparer, double ad_Prob, int ai_MaxLevel)
+        {
+            if (ad_Prob >= 1.0 || ad_Prob <= 0)
+                throw new ArgumentException("Invalid probability. Must be (0-1).", "ad_Prob");
+            md_Prob = ad_Prob;
+            mi_MaxLevel = ai_MaxLevel;
+            mk_Comparer = ak_Comparer;
+            mk_Head = new k_Node(null, null, ai_MaxLevel);
+            mk_End = new k_PinnedNodeIterator(this, null);
+        }
+
+        // IContainer Members
+        public k_Iterator Begin
+        {
+            get 
+            {
+                if (mi_Count == 0) 
+                    return this.End;
+                return new k_NodeIterator(this, this.LeftMost());
+            }
+        }
+
+        public k_Iterator End
+        {
+            get { return mk_End; }
+        }
+
+        public bool IsEmpty
+        {
+            get { return (mi_Count == 0); }
+        }
+
+        public k_Iterator Find(object ak_Value)
+        {
+            DictionaryEntry lr_Item = (DictionaryEntry)ak_Value;
+            k_NodeIterator lk_Found = (k_NodeIterator)LowerBound(lr_Item.Key);
+            if (lk_Found != this.End
+                && mk_Comparer.Compare(lr_Item.Key, lk_Found.Node.Key) == 0 && mk_Comparer.Compare(lr_Item.Value, lk_Found.Node.Value) == 0)
+                return lk_Found;
+            return this.End;
+        }
+
+        public k_Iterator Erase(k_Iterator ak_Where)
+        {
+            return Erase(ak_Where, ak_Where+1);
+        }
+
+        public k_Iterator Erase(k_Iterator ak_First, k_Iterator ak_Last)
+        {
+            if (ak_First == ak_Last)
+                return ak_Last.Clone();
+            
+            int li_Count = ak_Last - ak_First;
+            
+            k_Node lk_First = ((k_NodeIterator)ak_First).Node;
+            k_Node lk_Last = (ak_Last != this.End) ? ((k_NodeIterator)ak_Last).Node : null;
+            k_Node lk_Node = new k_Node(null, null, mi_HighestNode);
+
+            k_Node lk_Current = mk_Head;
+            for (int li_Level = mi_HighestNode-1; li_Level >= 0; --li_Level)
+            {
+                while (lk_Current.Next[li_Level] != null)
+                {
+                    if (ComparePos(lk_Current.Next[li_Level], lk_First) >= 0)
+                        break;
+                    lk_Current = lk_Current.Next[li_Level];
+                }
+                lk_Node.Next[li_Level] = lk_Current;
+            }
+
+            if (lk_Last == null)
+            {
+                for (int i=0; i<lk_Node.Height; ++i)
+                {
+                    k_Node lk_Left = lk_Node.Next[i];
+                    lk_Left.Next[i] = null;
+                }
+            }
+            else
+            {
+                for (int i=0; i<lk_Node.Height; ++i)
+                {
+                    k_Node lk_Left = lk_Node.Next[i];
+
+                        // for each level skip over erased range
+                    lk_Current = lk_Left.Next[i];
+                    while (lk_Current != null)
+                    {
+                        if (ComparePos(lk_Current, lk_Last) >= 0)
+                            break;
+                        lk_Current = lk_Current.Next[i];
+                    }
+                    lk_Left.Next[i] = lk_Current;
+                }
+            }
+
+            mi_Count -= li_Count;
+ 
+            while (mi_HighestNode > 0 && mk_Head.Next[mi_HighestNode-1] == null)
+                --mi_HighestNode;
+
+            return ak_Last;
+        }
+
+        // IMap Members
+        public k_Iterator FindKey(object ak_Key)
+        {
+            k_NodeIterator lk_Found = (k_NodeIterator)LowerBound(ak_Key);
+            if (lk_Found != this.End && mk_Comparer.Compare(ak_Key, lk_Found.Node.Key) == 0)
+                return lk_Found;
+            return this.End;
+        }
+
+        public void Add(DictionaryEntry ar_Entry)
+        {
+            Add(ar_Entry.Key, ar_Entry.Value);
+        }
+
+        public void Insert(k_Iterator ak_SrcBegin, k_Iterator ak_SrcEnd)
+        {
+            for (k_Iterator lk_Iter = ak_SrcBegin.Clone(); lk_Iter != ak_SrcEnd; lk_Iter.Next())
+                Add((DictionaryEntry)lk_Iter.Current);
+        }
+
+        // ISortedMap Members
+        public IComparer Comparer 
+        { 
+            get { return mk_Comparer; }
+        }
+
+        /// <summary>
+        /// Returns an iterator to the first element in a list with a key value 
+        /// that is equal to or greater than that of a specified key.
+        /// </summary>
+        /// <param name="ak_Key">
+        /// The argument key value to be compared with the sort key of an element 
+        /// from the list being searched.
+        /// </param>
+        /// <returns>
+        /// Location of an element in a list that with a key that is equal to 
+        /// or greater than the argument key, or this.End if no match is found for the key.
+        /// </returns>
+        public k_Iterator LowerBound(object ak_Key)
+        {
+            k_Node lk_Found = null;
+            k_Node lk_Current = mk_Head;
+            for (int li_Level = mi_HighestNode-1; li_Level >= 0; --li_Level)
+            {
+                k_Node lk_Next = lk_Current.Next[li_Level];
+                while (lk_Next != null)
+                {
+                    int li_Diff = mk_Comparer.Compare(lk_Next.Key, ak_Key);
+                    if (li_Diff >= 0)
+                    {
+                        lk_Found = lk_Next;
+                        break;
+                    }
+                            
+                    lk_Current = lk_Next;
+                    lk_Next = lk_Next.Next[li_Level];
+                }
+            }
+
+            return new k_NodeIterator(this, lk_Found);
+        }
+
+        /// <summary>
+        /// Returns an iterator to the first element in a list with a key value 
+        /// that is greater than that of a specified key.
+        /// </summary>
+        /// <param name="ak_Key">
+        /// The argument key value to be compared with the sort key of an element 
+        /// from the list being searched.
+        /// </param>
+        /// <returns>
+        /// Location of an element in a list that with a key that is greater
+        /// than the argument key, or this.End if no match is found for the key.
+        /// </returns>
+        public k_Iterator UpperBound(object ak_Key)
+        {
+            k_Node lk_Found = null;
+            k_Node lk_Current = mk_Head;
+            for (int li_Level = mi_HighestNode-1; li_Level >= 0; --li_Level)
+            {
+                k_Node lk_Next = lk_Current.Next[li_Level];
+                while (lk_Next != null)
+                {
+                    int li_Diff = mk_Comparer.Compare(lk_Next.Key, ak_Key);
+                    if (li_Diff > 0)
+                    {
+                        lk_Found = lk_Next;
+                        break;
+                    }
+                    
+                    lk_Current = lk_Next;
+                    lk_Next = lk_Next.Next[li_Level];
+                }
+            }
+
+            return new k_NodeIterator(this, lk_Found);
+        }
+
+        #region IDictionary Members
+
+        public void Add(object ak_Key, object ak_Value)
+        {
+            k_Node lk_Node = new k_Node(ak_Key, ak_Value, CalcNewNodeHeight());
+            if (lk_Node.Height > mi_HighestNode)
+                mi_HighestNode = lk_Node.Height;
+
+            FindInsertPos(lk_Node);
+            for (int i=0; i<lk_Node.Height; ++i)
+            {
+                k_Node lk_Left = lk_Node.Next[i];
+                k_Node lk_Tmp = lk_Left.Next[i];
+                lk_Left.Next[i] = lk_Node;
+                lk_Node.Next[i] = lk_Tmp;
+            }
+
+            ++mi_Count;
+        }
+
+        public void Clear()
+        {
+            Array.Clear(mk_Head.Next, 0, mk_Head.Next.Length);
+            mi_HighestNode = 0;
+            mi_Count = 0;
+        }
+
+        public bool Contains(object ak_Key)
+        {
+            return (FindKey(ak_Key) != this.End);
+        }
+
+        public IDictionaryEnumerator GetEnumerator()
+        {
+            return new k_IteratorDictEnumerator(this.Begin, this.End);
+        }
+
+        public void Remove(object ak_Key)
+        {
+            Erase(LowerBound(ak_Key), UpperBound(ak_Key));
+        }
+
+        public bool IsFixedSize
+        {
+            get { return false; }
+        }
+
+        public bool IsReadOnly
+        {
+            get { return false; }
+        }
+
+        public object this[object ak_Key]
+        {
+            get
+            {
+                k_NodeIterator lk_Iter = (k_NodeIterator)FindKey(ak_Key);
+                if (lk_Iter == this.End)
+                    return null;
+                return lk_Iter.Node.Value;
+            }
+            set
+            {
+                k_NodeIterator lk_Iter = (k_NodeIterator)FindKey(ak_Key);
+                if (lk_Iter == this.End)
+                    throw new ArgumentException("No element for key was found.", "ak_Key");
+                lk_Iter.Node.Value = value;
+            }
+        }
+
+        public ICollection Keys
+        {
+            get
+            {
+                object[] lk_Keys = new object[mi_Count];
+                int i = 0;
+                for (k_Iterator lk_Iter = this.Begin.Clone(); lk_Iter != this.End; lk_Iter.Next())
+                    lk_Keys[i++] = ((k_NodeIterator)lk_Iter).Node.Key;
+                return lk_Keys;
+            }
+        }
+
+        public ICollection Values
+        {
+            get
+            {
+                object[] lk_Values = new object[mi_Count];
+                int i=0;
+                for (k_Iterator lk_Iter = this.Begin.Clone(); lk_Iter != this.End; lk_Iter.Next())
+                    lk_Values[i++] = ((k_NodeIterator)lk_Iter).Node.Value;
+                return lk_Values;
+            }
+        }
+        
+        #endregion
+
+        #region ICollection Members
+
+        public void CopyTo(Array ak_Array, int ai_Index)
+        {
+            foreach (object lk_Obj in this)
+                ak_Array.SetValue(lk_Obj, ai_Index++);
+        }
+
+        public int Count
+        {
+            get { return mi_Count; }
+        }
+
+        public bool IsSynchronized
+        {
+            get { return false; }
+        }
+
+        public object SyncRoot
+        {
+            get { return this; }
+        }
+
+        #endregion
+
+        #region IEnumerable Members
+
+        IEnumerator System.Collections.IEnumerable.GetEnumerator()
+        {
+            return new k_IteratorEnumerator(this.Begin, this.End);
+        }
+
+        #endregion
+
+        #region ICloneable Members
+
+        public object Clone()
+        {
+            k_SkipList lk_Clone = new k_SkipList(mk_Comparer, md_Prob, mi_MaxLevel);
+            lk_Clone.mi_Count = mi_Count;
+            lk_Clone.mi_HighestNode = mi_HighestNode;
+            lk_Clone.mk_Head = CloneR(mk_Head, null);
+            return lk_Clone;
+        }
+
+        #endregion
+
+        private k_Node Previous(k_Node ak_Node)
+        {
+            k_Node lk_Current = mk_Head;
+            for (int li_Level = mi_HighestNode-1; li_Level >= 0; --li_Level)
+            {
+                while (lk_Current.Next[li_Level] != null)
+                {
+                    int li_Diff = mk_Comparer.Compare(lk_Current.Next[li_Level].Key, ak_Node.Key);
+                    if (li_Diff > 0)
+                        break;
+                    if (li_Diff == 0)
+                    {
+                        k_Node lk_Next = lk_Current;
+                        while (lk_Next != null && !object.ReferenceEquals(lk_Next.Next[0], ak_Node))
+                        {
+                            if (mk_Comparer.Compare(lk_Next.Key, ak_Node.Key) > 0)
+                                lk_Next = null;
+                            else
+                                lk_Next = lk_Next.Next[0];
+                        }
+                        if (lk_Next == null)
+                            break;
+                        
+                        return lk_Next;     // found previous node during right-scan of nodes with equal key value
+                    }
+                    lk_Current = lk_Current.Next[li_Level];
+                }
+            }
+            if (object.ReferenceEquals(mk_Head, lk_Current))
+                return null;
+            return lk_Current;
+        }
+
+        private k_Node Next(k_Node ak_Node)
+        {
+            return ak_Node.Next[0];
+        }
+
+        /// <summary>
+        /// Return leftmost node in list.
+        /// </summary>
+        /// <returns>Found node</returns>
+        private k_Node LeftMost()
+        {
+            return mk_Head.Next[0];
+        }
+
+        /// <summary>
+        /// Return rightmost node in list.
+        /// </summary>
+        /// <returns>Found node</returns>
+        private k_Node RightMost()
+        {
+            k_Node lk_Current = mk_Head.Next[mi_HighestNode-1];
+            for (int li_Level = mi_HighestNode-1; li_Level >= 0; --li_Level)
+            {
+                while (lk_Current.Next[li_Level] != null)
+                    lk_Current = lk_Current.Next[li_Level];
+            }
+            return lk_Current;
+        }
+
+        private void FindInsertPos(k_Node ak_Node)
+        {
+            k_Node lk_Current = mk_Head;
+            for (int li_Level = mi_HighestNode-1; li_Level >= 0; --li_Level)
+            {
+                while (lk_Current.Next[li_Level] != null && mk_Comparer.Compare(lk_Current.Next[li_Level].Key, ak_Node.Key) < 0)
+                    lk_Current = lk_Current.Next[li_Level];
+
+                if (li_Level < ak_Node.Height)
+                    ak_Node.Next[li_Level] = lk_Current;
+            }
+        }
+
+        private int CalcNewNodeHeight()
+        {
+            double ld_Rnd = mk_Rand.NextDouble();
+
+            int li_Level = 1;
+            for (double ld_Pow = md_Prob; li_Level < mi_MaxLevel; ++li_Level, ld_Pow*=md_Prob)
+            {
+                if (ld_Pow < ld_Rnd)
+                    break;
+            }
+
+            return li_Level;
+        }
+
+        private int ComparePos(k_Node ak_Left, k_Node ak_Right)
+        {
+            if (object.ReferenceEquals(ak_Left, ak_Right))
+                return 0;
+
+            int li_Diff = mk_Comparer.Compare(ak_Left.Key, ak_Right.Key);
+            if (li_Diff != 0)
+                return li_Diff;
+
+            k_Node lk_Current = ak_Left;
+            for (;;)
+            {
+                if (lk_Current == null || mk_Comparer.Compare(lk_Current.Key, ak_Right.Key) > 0)
+                    return 1;
+                else if (object.ReferenceEquals(lk_Current, ak_Right))
+                    return -1;
+
+                lk_Current = lk_Current.Next[0];
+            }
+        }
+
+        private k_Node CloneR(k_Node ak_Node, k_Node ak_NextHigher)
+        {
+            k_Node lk_New = new k_Node(ak_Node.Key, ak_Node.Value, ak_Node.Height);
+        
+            for (int i=ak_Node.Height-1; i>=0; --i)
+            {
+                // simply copy two links with equal target next to each other
+                if (i < ak_Node.Height-1 && object.ReferenceEquals(ak_Node.Next[i], ak_Node.Next[i+1]))
+                {
+                    lk_New.Next[i] = lk_New.Next[i+1];
+                    continue;
+                }
+
+                k_Node lk_Next = ak_Node.Next[i];
+                if (lk_Next != null && lk_Next.Height-1 <= i)
+                {
+                    k_Node lk_Higher = (i < ak_Node.Height-1) ? ak_Node.Next[i+1] : ak_NextHigher;
+                    lk_New.Next[i] = CloneR(lk_Next, lk_Higher);
+                }
+                else
+                    lk_New.Next[i] = ak_NextHigher;
+            }
+            return lk_New;
+        }
+    }
+}

src/core/System/util/collections/Stack.cs

@@ -0,0 +1,101 @@
+using System;
+using System.Collections;
+
+namespace System.util.collections
+{
+    /// <summary>
+    /// A push-down stack using an underlying k_Vector.
+    /// Last in first out (LIFO).
+    /// </summary>
+    public class k_Stack : ICollection
+    {
+        private ISequence mk_Items;        // stack container
+        private int mi_MaxSize;
+
+        public k_Stack()
+        {
+            mk_Items = new k_Vector();
+            mi_MaxSize = int.MaxValue;
+        }
+
+        public k_Stack(int ai_Capacity, bool ab_FixedSize)
+        {
+            mk_Items = new k_Vector(ai_Capacity);
+            mi_MaxSize = (ab_FixedSize) ? ai_Capacity : int.MaxValue;
+        }
+
+        public object Top
+        {
+            get { return mk_Items.Back; }
+            set { mk_Items.Back = value; }
+        }
+
+        public object this[int ai_Index]
+        {
+            get { return (mk_Items.Begin+ai_Index).Current; }
+            set { (mk_Items.Begin+ai_Index).Current = value; }
+        }
+
+        public void Push(object ak_Value)
+        {
+            if (mk_Items.Count >= mi_MaxSize)
+                throw new StackOverflowException("Stack overflow");
+
+            mk_Items.PushBack(ak_Value);
+        }
+
+        public object Pop()
+        {
+            if (mk_Items.Count == 0)
+                throw new StackOverflowException("Stack underflow");
+
+            object lk_Obj = mk_Items.Back;
+            mk_Items.PopBack();
+            return lk_Obj;
+        }
+
+        public bool IsEmpty
+        {
+            get { return mk_Items.IsEmpty; }
+        }
+
+        public void Clear()
+        {
+            mk_Items.Clear();
+        }
+
+        #region ICollection Members
+
+        public void CopyTo(Array ak_Array, int ai_Index)
+        {
+            for (k_Iterator lk_Iter = mk_Items.Begin.Clone(); lk_Iter != mk_Items.End; lk_Iter.Next())
+                ak_Array.SetValue(lk_Iter.Current, ai_Index++);
+        }
+
+        public int Count
+        {
+            get { return mk_Items.Count; }
+        }
+
+        public bool IsSynchronized
+        {
+            get { return false; }
+        }
+
+        public object SyncRoot
+        {
+            get { return this; }
+        }
+
+        #endregion
+
+        #region IEnumerable Members
+
+        public IEnumerator GetEnumerator()
+        {
+            return new k_IteratorEnumerator(mk_Items.Begin, mk_Items.End);
+        }
+
+        #endregion
+    }
+}

src/core/System/util/collections/Tree.cs

@@ -0,0 +1,830 @@
+using System;
+using System.Collections;
+
+namespace System.util.collections
+{
+    /// <summary>
+    /// k_Tree is a red-black balanced search tree (BST) implementation.
+    /// Complexity of find, insert and erase operations is near O(lg n).
+    /// </summary>
+    public class k_Tree : ISortedMap
+    {
+        #region k_Node Implementation
+
+        private class k_Node
+        {
+            private object mk_Key;
+            private object mk_Value;
+            private bool mb_Red;
+            public k_Node mk_Left, mk_Right, mk_Parent;        // public to simplify fixup & clone (passing by ref)
+            
+            public k_Node(object ak_Key, object ak_Value, k_Node ak_Parent)
+            {
+                mk_Key = ak_Key;
+                mk_Value = ak_Value;
+                mk_Parent = ak_Parent;
+                mb_Red = true;
+            }
+
+            public object Key
+            {
+                get { return mk_Key; }
+            }
+
+            public object Value
+            {
+                get { return mk_Value; }
+                set { mk_Value = value; }
+            }
+
+            public DictionaryEntry Item
+            {
+                get { return new DictionaryEntry(mk_Key, mk_Value); }
+            }
+
+            public bool Red
+            {
+                get { return mb_Red; }
+                set { mb_Red = value; }
+            }
+
+            public static void SwapItems(k_Node ak_A, k_Node ak_B)
+            {
+                object lk_Tmp = ak_A.mk_Key;
+                ak_A.mk_Key = ak_B.mk_Key;
+                ak_B.mk_Key = lk_Tmp;
+                
+                lk_Tmp = ak_A.mk_Value;
+                ak_A.mk_Value = ak_B.mk_Value;
+                ak_B.mk_Value = lk_Tmp;
+            }
+        }
+
+        #endregion
+
+        #region k_NodeIterator Implementation
+
+        private class k_NodeIterator : k_Iterator
+        {
+            private readonly k_Tree mk_Tree;
+            private k_Node mk_Current;
+
+            public k_NodeIterator(k_Tree ak_Tree, k_Node ak_Node)
+            {
+                mk_Tree = ak_Tree;
+                mk_Current = ak_Node;
+            }
+
+            public override object Current
+            {
+                get 
+                { 
+                    if (mk_Current == null)
+                        throw new k_InvalidPositionException();
+                    return mk_Current.Item; 
+                }
+                set
+                {
+                    DictionaryEntry lr_Entry = (DictionaryEntry)value;
+                    if (mk_Tree.mk_Comparer.Compare(lr_Entry.Key, mk_Current.Key) != 0)
+                        throw new ArgumentException("Key values must not be changed.");
+                    mk_Current.Value = lr_Entry.Value;
+                }
+            }
+
+            public override object Collection
+            {
+                get { return mk_Tree; }
+            }
+
+            public override void Move(int ai_Count)
+            {
+                k_Node lk_NewPos = mk_Current;
+
+                if (ai_Count > 0)
+                {
+                    while (ai_Count-- > 0)
+                    {
+                        if (lk_NewPos == null)
+                            throw new InvalidOperationException("Tried to moved beyond end element.");
+
+                        lk_NewPos = k_Tree.Next(lk_NewPos);
+                    }
+                }
+                else
+                {
+                    while (ai_Count++ < 0)
+                    {
+                        if (lk_NewPos == null)
+                            lk_NewPos = mk_Tree.mk_Right;
+                        else
+                            lk_NewPos = k_Tree.Previous(lk_NewPos);
+
+                        if (lk_NewPos == null)
+                            throw new InvalidOperationException("Tried to move before first element.");
+                    }
+                }
+                
+                mk_Current = lk_NewPos;
+            }
+
+            public override int Distance(k_Iterator ak_Iter)
+            {
+                k_NodeIterator lk_Iter = ak_Iter as k_NodeIterator;
+                if (lk_Iter == null || !object.ReferenceEquals(lk_Iter.Collection, this.Collection))
+                    throw new ArgumentException("Cannot determine distance of iterators belonging to different collections.");
+                
+                k_Iterator lk_End = mk_Tree.End;
+    
+                int li_KeyDiff;
+                if (this == lk_End || ak_Iter == lk_End)
+                    li_KeyDiff = (this == lk_End && this != ak_Iter) ? 1 : 0;
+                else
+                    li_KeyDiff = mk_Tree.mk_Comparer.Compare(mk_Current.Key, lk_Iter.mk_Current.Key);
+
+                if (li_KeyDiff <= 0)
+                {
+                    int li_Diff = 0;
+                    k_Iterator lk_Bck = this.Clone(); 
+                    for (; lk_Bck != ak_Iter && lk_Bck != lk_End; lk_Bck.Next())
+                        --li_Diff;
+
+                    if (lk_Bck == ak_Iter)
+                        return li_Diff;
+                }
+                
+                if (li_KeyDiff >= 0)
+                {
+                    int li_Diff = 0;
+                    k_Iterator lk_Fwd = ak_Iter.Clone(); 
+                    for (; lk_Fwd != this && lk_Fwd != lk_End; lk_Fwd.Next())
+                        ++li_Diff;
+
+                    if (lk_Fwd == this)
+                        return li_Diff;
+                }
+                
+                throw new Exception("Inconsistent state. Concurrency?");
+            }
+
+            public override bool Equals(object ak_Obj)
+            {
+                k_NodeIterator lk_Iter = ak_Obj as k_NodeIterator;
+                if (lk_Iter == null)
+                    return false;
+                return object.ReferenceEquals(mk_Current, lk_Iter.mk_Current);
+            }
+
+            public override int GetHashCode()
+            {
+                if (mk_Current == null)
+                    return mk_Tree.GetHashCode();
+                return mk_Current.GetHashCode();
+            }
+
+            public override k_Iterator Clone()
+            {
+                return new k_NodeIterator(mk_Tree, mk_Current);
+            }
+
+            internal k_Node Node
+            {
+                get { return mk_Current; }
+            }
+        }
+
+        private class k_PinnedNodeIterator : k_NodeIterator
+        {
+            public k_PinnedNodeIterator(k_Tree ak_Tree, k_Node ak_Node)
+                : base(ak_Tree, ak_Node)
+            {
+            }
+
+            public override void Move(int ai_Count)
+            {
+                throw new k_IteratorPinnedException();
+            }
+        }
+
+        #endregion
+
+        private k_Node mk_Head, mk_Left, mk_Right;
+        private k_Iterator mk_End;
+        private int mi_Count;
+        private IComparer mk_Comparer;
+        private bool mb_AllowDuplicateKeys;
+
+        public k_Tree()
+            : this(false)
+        {
+        }
+
+        public k_Tree(bool ab_AllowDuplicateKeys)
+            : this(ab_AllowDuplicateKeys, System.Collections.Comparer.Default)
+        {
+        }
+
+        public k_Tree(bool ab_AllowDuplicateKeys, IComparer ak_Comparer)
+        {
+            mb_AllowDuplicateKeys = ab_AllowDuplicateKeys;
+            mk_Comparer = ak_Comparer;
+            mk_End = new k_PinnedNodeIterator(this, null);
+        }
+
+        // IContainer Members
+        public k_Iterator Begin
+        {
+            get 
+            {
+                if (mi_Count == 0) 
+                    return this.End;
+                return new k_NodeIterator(this, mk_Left);
+            }
+        }
+
+        public k_Iterator End
+        {
+            get { return mk_End; }
+        }
+
+        public bool IsEmpty
+        {
+            get { return (mi_Count == 0); }
+        }
+
+        public k_Iterator Find(object ak_Value)
+        {
+            DictionaryEntry lr_Item = (DictionaryEntry)ak_Value;
+            k_Node lk_Found = FindInternal(mk_Head, lr_Item.Key);
+            if (lk_Found != null && mk_Comparer.Compare(lk_Found.Value, lr_Item.Value) == 0)
+                return new k_NodeIterator(this, lk_Found);
+            return this.End;
+        }
+
+        public k_Iterator Erase(k_Iterator ak_Where)
+        {
+            //System.Diagnostics.Debug.Assert(object.ReferenceEquals(this, ak_Where.Collection), "Iterator does not belong to this tree.");
+            k_Iterator lk_Successor = ak_Where + 1;
+            RemoveNode(((k_NodeIterator)ak_Where).Node);
+            return lk_Successor;
+        }
+
+        public k_Iterator Erase(k_Iterator ak_First, k_Iterator ak_Last)
+        {
+            if (ak_First == this.Begin && ak_Last == this.End)
+            {
+                Clear();
+                return ak_Last.Clone();
+            }
+            
+            k_Iterator lk_Current = ak_First;
+            while (lk_Current != ak_Last)
+                lk_Current = Erase(lk_Current);
+            return lk_Current;
+        }
+
+        // IMap Members
+        public void Add(DictionaryEntry ar_Item)
+        {
+            Add(ar_Item.Key, ar_Item.Value);
+        }
+
+        public k_Iterator FindKey(object ak_Key)
+        {
+            return new k_NodeIterator(this, FindInternal(mk_Head, ak_Key));
+        }
+
+        public void Insert(k_Iterator ak_SrcBegin, k_Iterator ak_SrcEnd)
+        {
+            for (k_Iterator lk_Iter = ak_SrcBegin.Clone(); lk_Iter != ak_SrcEnd; lk_Iter.Next())
+                Add((DictionaryEntry)lk_Iter.Current);
+        }
+
+        // ISortedMap Members
+        public IComparer Comparer 
+        { 
+            get { return mk_Comparer; }
+        }
+
+        public k_Iterator LowerBound(object ak_Key)
+        {
+            k_Node lk_Node = mk_Head;
+            k_Node lk_Found = null;
+            while (lk_Node != null)
+            {
+                if (mk_Comparer.Compare(lk_Node.Key, ak_Key) < 0)
+                    lk_Node = lk_Node.mk_Right;
+                else
+                {
+                    lk_Found = lk_Node;
+                    lk_Node = lk_Node.mk_Left;
+                }
+            }
+            return new k_NodeIterator(this, lk_Found);
+        }
+
+        public k_Iterator UpperBound(object ak_Key)
+        {
+            k_Node lk_Node = mk_Head;
+            k_Node lk_Found = null;
+            while (lk_Node != null)
+            {
+                if (mk_Comparer.Compare(lk_Node.Key, ak_Key) > 0)
+                {
+                    lk_Found = lk_Node;
+                    lk_Node = lk_Node.mk_Left;
+                }
+                else
+                    lk_Node = lk_Node.mk_Right;
+            }
+            return new k_NodeIterator(this, lk_Found);
+        }
+
+        #region IDictionary Members
+
+        public void Add(object ak_Key, object ak_Value)
+        {
+            Insert(ref mk_Head, null, ak_Key, ak_Value, false);
+            mk_Head.Red = false;
+            ++mi_Count;
+        }
+        
+        public void Clear()
+        {
+            mi_Count = 0;
+            mk_Head = null;
+            mk_Left = null;
+            mk_Right = null;
+        }
+
+        public bool Contains(object ak_Key)
+        {
+            return (FindInternal(mk_Head, ak_Key) != null);
+        }
+
+        public IDictionaryEnumerator GetEnumerator()
+        {
+            return new k_IteratorDictEnumerator(this.Begin, this.End);
+        }
+
+        public void Remove(object ak_Key)
+        {
+            RemoveNode(FindInternal(mk_Head, ak_Key));
+        }
+
+        public bool IsFixedSize
+        {
+            get { return false; }
+        }
+        
+        public bool IsReadOnly
+        {
+            get { return false; }
+        }
+
+        public object this[object ak_Key]
+        {
+            get 
+            {
+                k_Node lk_Node = FindInternal(mk_Head, ak_Key);
+                if (lk_Node == null)
+                    return null;
+                return lk_Node.Value;
+            }
+            set 
+            {
+                k_Node lk_Node = FindInternal(mk_Head, ak_Key);
+                if (lk_Node == null)
+                    Add(new DictionaryEntry(ak_Key, value));
+                else
+                    lk_Node.Value = value;
+            }
+        }
+
+        public ICollection Keys
+        {
+            get
+            {
+                int i=0;
+                object[] lk_Keys = new object[mi_Count];
+                foreach (DictionaryEntry lr_Entry in this)
+                    lk_Keys[i++] = lr_Entry.Key;
+                return lk_Keys;
+            }
+        }
+
+        public ICollection Values
+        {
+            get
+            {
+                int i=0;
+                object[] lk_Values = new object[mi_Count];
+                foreach (DictionaryEntry lr_Entry in this)
+                    lk_Values[i++] = lr_Entry.Value;
+                return lk_Values;
+            }
+        }
+            
+        #endregion
+
+        #region ICollection Members
+
+        public void CopyTo(Array ak_Array, int ai_Index)
+        {
+            foreach (DictionaryEntry lr_Entry in this)
+                ak_Array.SetValue(lr_Entry, ai_Index++);
+        }
+
+        public int Count
+        {
+            get { return mi_Count; }
+        }
+
+        public bool IsSynchronized
+        {
+            get {  return false; }
+        }
+
+        public object SyncRoot
+        {
+            get { return this; }
+        }
+
+        #endregion
+
+        #region IEnumerable Members
+
+        IEnumerator System.Collections.IEnumerable.GetEnumerator()
+        {
+            return new k_IteratorEnumerator(this.Begin, this.End);
+        }
+
+        #endregion
+
+        #region ICloneable Members
+
+        public object Clone()
+        {
+            k_Tree lk_Clone = new k_Tree(mb_AllowDuplicateKeys, mk_Comparer);
+            lk_Clone.mi_Count = mi_Count;
+            CloneRecursive(mk_Head, null, ref lk_Clone.mk_Head);
+            lk_Clone.mk_Left = k_Tree.LeftMost(lk_Clone.mk_Head);
+            lk_Clone.mk_Right = k_Tree.RightMost(lk_Clone.mk_Head);
+
+            return lk_Clone;
+        }
+
+        #endregion
+
+        private void CloneRecursive(k_Node ak_Node, k_Node ak_Parent, ref k_Node ak_Link)
+        {
+            if (ak_Node == null)
+                return;
+
+            ak_Link = new k_Node(ak_Node.Key, ak_Node.Value, ak_Parent);
+            ak_Link.Red = ak_Node.Red;
+
+            CloneRecursive(ak_Node.mk_Left, ak_Link, ref ak_Link.mk_Left);
+            CloneRecursive(ak_Node.mk_Right, ak_Link, ref ak_Link.mk_Right);
+        }
+
+        private bool IsRed(k_Node ak_Node)
+        {
+            return (ak_Node != null && ak_Node.Red);
+        }
+
+        private k_Node FindInternal(k_Node ak_Node, object ak_Key)
+        {
+            while (ak_Node != null)
+            {
+                int li_Diff = mk_Comparer.Compare(ak_Key, ak_Node.Key);
+                if (li_Diff == 0)
+                    return ak_Node;
+                ak_Node = (li_Diff < 0) ? ak_Node.mk_Left : ak_Node.mk_Right;
+            }
+            return null;
+        }
+
+        /// <summary>
+        /// Return leftmost node in subtree.
+        /// </summary>
+        /// <param name="ak_Node">Node where to start search</param>
+        /// <returns>Found node</returns>
+        private static k_Node LeftMost(k_Node ak_Node)
+        {
+            if (ak_Node == null)
+                return null;
+            while (ak_Node.mk_Left != null)
+                ak_Node = ak_Node.mk_Left;
+            return ak_Node;
+        }
+
+        /// <summary>
+        /// Return rightmost node in subtree.
+        /// </summary>
+        /// <param name="ak_Node">Node where to start search</param>
+        /// <returns>Found node</returns>
+        private static k_Node RightMost(k_Node ak_Node)
+        {
+            if (ak_Node == null)
+                return null;
+            while (ak_Node.mk_Right != null)
+                ak_Node = ak_Node.mk_Right;
+            return ak_Node;
+        }
+
+        private static k_Node Previous(k_Node ak_Node) // the next smaller
+        {
+            if (ak_Node.mk_Left != null)
+                return RightMost(ak_Node.mk_Left);
+
+            k_Node lk_Parent = ak_Node.mk_Parent;
+            while (lk_Parent != null && lk_Parent.mk_Left == ak_Node)
+            {
+                ak_Node = lk_Parent;
+                lk_Parent = lk_Parent.mk_Parent;
+            }
+            return lk_Parent;
+        }
+
+        private static k_Node Next(k_Node ak_Node)
+        {
+            if (ak_Node.mk_Right != null)
+                return LeftMost(ak_Node.mk_Right);
+            
+            k_Node lk_Parent = ak_Node.mk_Parent;
+            while (lk_Parent != null && lk_Parent.mk_Right == ak_Node)
+            {
+                ak_Node = lk_Parent;
+                lk_Parent = lk_Parent.mk_Parent;
+            }
+            return lk_Parent;
+        }
+
+        private void RemoveNode(k_Node ak_Node)
+        {
+            if (ak_Node == null)
+                return;
+            if (ak_Node == mk_Head)
+                UnlinkNode(ref mk_Head);
+            else  if (ak_Node == ak_Node.mk_Parent.mk_Right)
+                UnlinkNode(ref ak_Node.mk_Parent.mk_Right);
+            else
+                UnlinkNode(ref ak_Node.mk_Parent.mk_Left);
+        }
+
+        private void UnlinkNode(ref k_Node ak_Node)
+        {
+            bool lb_Red = ak_Node.Red;
+            k_Node lk_Erased = ak_Node;
+
+            k_Node lk_PatchNode = null;
+            if (ak_Node.mk_Right == null)
+                lk_PatchNode = ak_Node.mk_Left;
+            else if (ak_Node.mk_Left == null)
+                lk_PatchNode = ak_Node.mk_Right;
+            else 
+                lk_PatchNode = ak_Node;
+
+            k_Node lk_PatchParent = null, lk_FixNode = null;
+            if (lk_PatchNode == null)
+            {
+                lk_PatchParent = ak_Node.mk_Parent;
+                ak_Node = null;
+            }
+            else if (lk_PatchNode != ak_Node)
+            {
+                lk_PatchNode.mk_Parent = ak_Node.mk_Parent;
+                ak_Node = lk_PatchNode;
+                lk_PatchParent = lk_PatchNode.mk_Parent;
+            }
+            else
+            {
+                // two subtrees
+                lk_PatchNode = RightMost(ak_Node.mk_Left);
+                if (lk_PatchNode.mk_Parent.mk_Right == lk_PatchNode)
+                    lk_PatchNode.mk_Parent.mk_Right = lk_PatchNode.mk_Left;
+                else
+                    lk_PatchNode.mk_Parent.mk_Left = lk_PatchNode.mk_Left;
+                
+                lb_Red = lk_PatchNode.Red;
+                if (lk_PatchNode.mk_Left != null)
+                    lk_PatchNode.mk_Left.mk_Parent = lk_PatchNode.mk_Parent;
+                
+                lk_PatchParent = lk_PatchNode.mk_Parent;
+                lk_FixNode = lk_PatchNode.mk_Left;
+
+                k_Node.SwapItems(ak_Node, lk_PatchNode);
+            
+                // ensure that mk_Left and/or mk_Right are corrected after unlink
+                lk_Erased = lk_PatchNode;
+            }
+
+            if (!lb_Red && lk_PatchParent != null)
+            {
+                // erased node was black link - rebalance the tree
+                while (!IsRed(lk_FixNode) && lk_FixNode != mk_Head)
+                {
+                    if (lk_PatchParent.mk_Left != null || lk_PatchParent.mk_Right != null)
+                    {
+                        if (lk_PatchParent.mk_Left == lk_FixNode)
+                        {
+                            // fixup right subtree
+                            k_Node lk_Node = lk_PatchParent.mk_Right;
+
+                            if (IsRed(lk_Node))
+                            {
+                                lk_Node.Red = false;
+                                lk_PatchParent.Red = true;
+                                RotateLeft(lk_PatchParent);
+                                lk_Node = lk_PatchParent.mk_Right;
+                            }
+
+                            if (lk_Node != null)
+                            {
+                                if (!IsRed(lk_Node.mk_Left) && !IsRed(lk_Node.mk_Right))
+                                    lk_Node.Red = true;
+                                else
+                                {
+                                    if (!IsRed(lk_Node.mk_Right))
+                                    {
+                                        lk_Node.Red = true;
+                                        lk_Node.mk_Left.Red = false;
+                                        RotateRight(lk_Node);
+                                        lk_Node = lk_PatchParent.mk_Right;
+                                    }
+
+                                    lk_Node.Red = lk_PatchParent.Red;
+                                    lk_PatchParent.Red = false;
+                                    lk_Node.mk_Right.Red = false;
+                                    RotateLeft(lk_PatchParent);
+                                    break;
+                                }
+                            }
+                        }
+                        else
+                        {
+                            // fixup leftsubtree
+                            k_Node lk_Node = lk_PatchParent.mk_Left;
+
+                            if (IsRed(lk_Node))
+                            {
+                                lk_Node.Red = false;
+                                lk_PatchParent.Red = true;
+                                RotateRight(lk_PatchParent);
+                                lk_Node = lk_PatchParent.mk_Left;
+                            }
+
+                            if (lk_Node != null)
+                            {
+                                if (!IsRed(lk_Node.mk_Left) && !IsRed(lk_Node.mk_Right))
+                                    lk_Node.Red = true;
+                                else
+                                {
+                                    if (!IsRed(lk_Node.mk_Left))
+                                    {
+                                        lk_Node.Red = true;
+                                        lk_Node.mk_Right.Red = false;
+                                        RotateLeft(lk_Node);
+                                        lk_Node = lk_PatchParent.mk_Left;
+                                    }
+
+                                    lk_Node.Red = lk_PatchParent.Red;
+                                    lk_PatchParent.Red = false;
+                                    lk_Node.mk_Left.Red = false;
+                                    RotateRight(lk_PatchParent);
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    lk_FixNode = lk_PatchParent;
+                    lk_PatchParent = lk_PatchParent.mk_Parent;
+                }
+
+                if (lk_FixNode != null)
+                    lk_FixNode.Red = false;
+            }
+
+            --mi_Count;
+
+            if (object.ReferenceEquals(lk_Erased, mk_Right))
+                mk_Right = k_Tree.RightMost(mk_Head);
+            if (object.ReferenceEquals(lk_Erased, mk_Left))
+                mk_Left = k_Tree.LeftMost(mk_Head);
+        }
+
+        private void Insert(ref k_Node ak_Node, k_Node ak_Parent, object ak_Key, object ak_Value, bool ab_RightMove)
+        {
+            if (ak_Node == null)
+            {
+                ak_Node = new k_Node(ak_Key, ak_Value, ak_Parent);
+                if (object.ReferenceEquals(ak_Parent, mk_Right) && (ak_Parent == null || ab_RightMove))
+                    mk_Right = ak_Node;
+                if (object.ReferenceEquals(ak_Parent, mk_Left) && (ak_Parent == null || !ab_RightMove))
+                    mk_Left = ak_Node;
+                return;
+            }
+
+            if (IsRed(ak_Node.mk_Left) && IsRed(ak_Node.mk_Right))
+            {
+                ak_Node.Red = true;
+                ak_Node.mk_Left.Red = false;
+                ak_Node.mk_Right.Red = false;
+            }
+
+            int li_Diff = mk_Comparer.Compare(ak_Key, ak_Node.Key);
+            if (!mb_AllowDuplicateKeys && li_Diff == 0)
+                throw new ArgumentException("An element with the same key already exists in the tree.");
+
+            if (li_Diff < 0)
+            {
+                Insert(ref ak_Node.mk_Left, ak_Node, ak_Key, ak_Value, false);
+                if (IsRed(ak_Node) && IsRed(ak_Node.mk_Left) && ab_RightMove)
+                    ak_Node = RotateRight(ak_Node);
+                if (IsRed(ak_Node.mk_Left) && IsRed(ak_Node.mk_Left.mk_Left))
+                {
+                    ak_Node = RotateRight(ak_Node);
+                    ak_Node.Red = false;
+                    ak_Node.mk_Right.Red = true;
+                }
+            }
+            else
+            {
+                Insert(ref ak_Node.mk_Right, ak_Node, ak_Key, ak_Value, true);
+                if (IsRed(ak_Node) && IsRed(ak_Node.mk_Right) && !ab_RightMove)
+                    ak_Node = RotateLeft(ak_Node);
+                if (IsRed(ak_Node.mk_Right) && IsRed(ak_Node.mk_Right.mk_Right))
+                {
+                    ak_Node = RotateLeft(ak_Node);
+                    ak_Node.Red = false;
+                    ak_Node.mk_Left.Red = true;
+                }
+            }
+        }
+
+        /*
+         A right rotation: ak_Node.Left takes old position of ak_Node.
+         Makes the old root the right subtree of the new root.
+         
+              5                 2
+           2     7     ->    1     5  
+          1 3   6 8              3   7
+                                    6 8
+        */
+        private k_Node RotateRight(k_Node ak_Node)
+        {
+            k_Node lk_Tmp = ak_Node.mk_Left;
+
+            lk_Tmp.mk_Parent = ak_Node.mk_Parent;
+            ak_Node.mk_Parent = lk_Tmp;
+
+            ak_Node.mk_Left = lk_Tmp.mk_Right;
+            if (ak_Node.mk_Left != null)
+                ak_Node.mk_Left.mk_Parent = ak_Node;
+            lk_Tmp.mk_Right = ak_Node;
+
+            // correct parent
+            if (lk_Tmp.mk_Parent == null)
+                mk_Head = lk_Tmp;
+            else if (lk_Tmp.mk_Parent.mk_Right == ak_Node)
+                lk_Tmp.mk_Parent.mk_Right = lk_Tmp;
+            else
+                lk_Tmp.mk_Parent.mk_Left = lk_Tmp;
+
+            return lk_Tmp;
+        }
+
+        /*
+         A left rotation: ak_Node.Right takes old position of ak_Node.
+         Makes the old root the left subtree of the new root.
+         
+              5                   7
+           2     7     ->      5     8
+          1 3   6 8          2   6
+                            1 3      
+        */
+        private k_Node RotateLeft(k_Node ak_Node)
+        {
+            k_Node lk_Tmp = ak_Node.mk_Right;
+
+            lk_Tmp.mk_Parent = ak_Node.mk_Parent;
+            ak_Node.mk_Parent = lk_Tmp;
+
+            ak_Node.mk_Right = lk_Tmp.mk_Left;
+            if (ak_Node.mk_Right != null)
+                ak_Node.mk_Right.mk_Parent = ak_Node;
+            lk_Tmp.mk_Left = ak_Node;
+
+            // correct parent
+            if (lk_Tmp.mk_Parent == null)
+                mk_Head = lk_Tmp;
+            else if (lk_Tmp.mk_Parent.mk_Right == ak_Node)
+                lk_Tmp.mk_Parent.mk_Right = lk_Tmp;
+            else
+                lk_Tmp.mk_Parent.mk_Left = lk_Tmp;
+
+            return lk_Tmp;
+        }
+    }
+}

src/core/System/util/collections/Vector.cs

@@ -0,0 +1,143 @@
+using System;
+using System.Collections;
+
+namespace System.util.collections
+{
+    /// <summary>
+    /// One dimensional array of variable size
+    /// </summary>
+    public class k_Vector : ArrayList, ISequence
+    {
+        public k_Vector()
+            : base()
+        {
+        }
+
+        public k_Vector(int ai_Capacity) 
+            : base(ai_Capacity)
+        {
+        }
+
+        public k_Vector(ICollection ak_Collection)
+            : base(ak_Collection)
+        {
+        }
+
+        // IContainer Members
+        public k_Iterator Begin
+        {
+            get { return k_IListIterator.CreateBegin(this); }
+        }
+
+        public k_Iterator End
+        {
+            get { return k_IListIterator.CreateEnd(this); }
+        }
+
+        public bool IsEmpty
+        {
+            get { return (this.Count == 0); }
+        }
+
+        public k_Iterator Find(object ak_Value)
+        {
+            int li_Index = this.IndexOf(ak_Value);
+            if (li_Index < 0)
+                return this.End;
+            return new k_IListIterator(this, li_Index);
+        }
+
+        public k_Iterator Erase(k_Iterator ak_Where)
+        {
+            //System.Diagnostics.Debug.Assert(object.ReferenceEquals(this, ak_Where.Collection), "Iterator does not belong to this collection.");
+            int li_Index = ((k_IListIterator)ak_Where).Index;
+            if (li_Index < this.Count)
+                base.RemoveAt(li_Index);
+            return new k_IListIterator(this, li_Index);
+        }
+
+        public k_Iterator Erase(k_Iterator ak_First, k_Iterator ak_Last)
+        {
+            //System.Diagnostics.Debug.Assert(object.ReferenceEquals(this, ak_First.Collection) && object.ReferenceEquals(this, ak_Last.Collection), "Iterators do not belong to this collection.");
+            int li_FirstIndex = ((k_IListIterator)ak_First).Index;
+            int li_Count = ak_Last - ak_First;
+
+            base.RemoveRange(li_FirstIndex, li_Count);
+            
+            return new k_IListIterator(this, li_FirstIndex);
+        }
+
+        // ISequence Members
+        public object Front
+        {
+            get { return this.Begin.Current; }
+            set { this.Begin.Current = value; }
+        }
+
+        public object Back
+        {
+            get { return (this.End-1).Current; }
+            set { (this.End-1).Current = value; }
+        }
+
+        public void PushFront(object ak_Value)
+        {
+            Insert(this.Begin, ak_Value);
+        }
+        
+        public void PopFront()
+        {
+            Erase(this.Begin);
+        }
+
+        public void PushBack(object ak_Value)
+        {
+            Insert(this.End, ak_Value);
+        }
+
+        public void PopBack()
+        {
+            Erase(this.End-1);
+        }
+
+        public void Assign(k_Iterator ak_SrcBegin, k_Iterator ak_SrcEnd)
+        {
+            Clear();
+            Insert(this.End, ak_SrcBegin, ak_SrcEnd);
+        }
+
+        public void Assign(object ak_Value, int ai_Count)
+        {
+            Clear();
+            Insert(this.End, ak_Value, ai_Count);
+        }
+
+        public void Insert(k_Iterator ak_Where, object ak_Value)
+        {
+            //System.Diagnostics.Debug.Assert(object.ReferenceEquals(this, ak_Where.Collection), "Iterator does not belong to this collection.");
+            this.Insert(((k_IListIterator)ak_Where).Index, ak_Value);
+        }
+
+        public void Insert(k_Iterator ak_Where, k_Iterator ak_SrcBegin, k_Iterator ak_SrcEnd)
+        {
+            //System.Diagnostics.Debug.Assert(object.ReferenceEquals(this, ak_Where.Collection), "Iterator does not belong to this collection.");
+            InsertRange(((k_IListIterator)ak_Where).Index, new k_CollectionOnIterators(ak_SrcBegin, ak_SrcEnd));
+        }
+
+        public void Insert(k_Iterator ak_Where, object ak_Value, int ai_Count)
+        {
+            int li_Pos = ((k_IListIterator)ak_Where).Index;
+            for (int i=0; i<ai_Count; ++i)
+                base.Insert(li_Pos+i, ak_Value);
+        }
+
+        #region ICloneable Members
+
+        public override object Clone()
+        {
+            return new k_Vector(this);
+        }
+
+        #endregion
+    }
+}

src/core/System/util/zlib/Adler32.cs

@@ -0,0 +1,88 @@
+using System;
+/*
+ * $Id: Adler32.cs,v 1.1 2006/06/16 10:56:20 psoares33 Exp $
+ *
+Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+  1. Redistributions of source code must retain the above copyright notice,
+     this list of conditions and the following disclaimer.
+
+  2. Redistributions in binary form must reproduce the above copyright 
+     notice, this list of conditions and the following disclaimer in 
+     the documentation and/or other materials provided with the distribution.
+
+  3. The names of the authors may not be used to endorse or promote products
+     derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
+INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
+INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/*
+ * This program is based on zlib-1.1.3, so all credit should go authors
+ * Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu)
+ * and contributors of zlib.
+ */
+
+namespace System.util.zlib {
+
+    internal sealed class Adler32{
+
+        // largest prime smaller than 65536
+        private const int BASE=65521; 
+        // NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1
+        private const int NMAX=5552;
+
+        internal long adler32(long adler, byte[] buf, int index, int len){
+            if(buf == null){ return 1L; }
+
+            long s1=adler&0xffff;
+            long s2=(adler>>16)&0xffff;
+            int k;
+
+            while(len > 0) {
+                k=len<NMAX?len:NMAX;
+                len-=k;
+                while(k>=16){
+                    s1+=buf[index++]&0xff; s2+=s1;
+                    s1+=buf[index++]&0xff; s2+=s1;
+                    s1+=buf[index++]&0xff; s2+=s1;
+                    s1+=buf[index++]&0xff; s2+=s1;
+                    s1+=buf[index++]&0xff; s2+=s1;
+                    s1+=buf[index++]&0xff; s2+=s1;
+                    s1+=buf[index++]&0xff; s2+=s1;
+                    s1+=buf[index++]&0xff; s2+=s1;
+                    s1+=buf[index++]&0xff; s2+=s1;
+                    s1+=buf[index++]&0xff; s2+=s1;
+                    s1+=buf[index++]&0xff; s2+=s1;
+                    s1+=buf[index++]&0xff; s2+=s1;
+                    s1+=buf[index++]&0xff; s2+=s1;
+                    s1+=buf[index++]&0xff; s2+=s1;
+                    s1+=buf[index++]&0xff; s2+=s1;
+                    s1+=buf[index++]&0xff; s2+=s1;
+                    k-=16;
+                }
+                if(k!=0){
+                    do{
+                        s1+=buf[index++]&0xff; s2+=s1;
+                    }
+                    while(--k!=0);
+                }
+                s1%=BASE;
+                s2%=BASE;
+            }
+            return (s2<<16)|s1;
+        }
+
+    }
+}

src/core/System/util/zlib/InfBlocks.cs

@@ -0,0 +1,618 @@
+using System;
+/*
+ * $Id: InfBlocks.cs,v 1.1 2006/06/16 10:56:20 psoares33 Exp $
+ *
+Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+  1. Redistributions of source code must retain the above copyright notice,
+     this list of conditions and the following disclaimer.
+
+  2. Redistributions in binary form must reproduce the above copyright 
+     notice, this list of conditions and the following disclaimer in 
+     the documentation and/or other materials provided with the distribution.
+
+  3. The names of the authors may not be used to endorse or promote products
+     derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
+INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
+INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/*
+ * This program is based on zlib-1.1.3, so all credit should go authors
+ * Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu)
+ * and contributors of zlib.
+ */
+
+namespace System.util.zlib {
+
+    internal sealed class InfBlocks{
+        private const int MANY=1440;
+
+        // And'ing with mask[n] masks the lower n bits
+        static private int[] inflate_mask = {
+                                                0x00000000, 0x00000001, 0x00000003, 0x00000007, 0x0000000f,
+                                                0x0000001f, 0x0000003f, 0x0000007f, 0x000000ff, 0x000001ff,
+                                                0x000003ff, 0x000007ff, 0x00000fff, 0x00001fff, 0x00003fff,
+                                                0x00007fff, 0x0000ffff
+                                            };
+
+        // Table for deflate from PKZIP's appnote.txt.
+        static int[] border = { // Order of the bit length code lengths
+                                  16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15
+                              };
+
+        private const int Z_OK=0;
+        private const int Z_STREAM_END=1;
+        private const int Z_NEED_DICT=2;
+        private const int Z_ERRNO=-1;
+        private const int Z_STREAM_ERROR=-2;
+        private const int Z_DATA_ERROR=-3;
+        private const int Z_MEM_ERROR=-4;
+        private const int Z_BUF_ERROR=-5;
+        private const int Z_VERSION_ERROR=-6;
+
+        private const int TYPE=0;  // get type bits (3, including end bit)
+        private const int LENS=1;  // get lengths for stored
+        private const int STORED=2;// processing stored block
+        private const int TABLE=3; // get table lengths
+        private const int BTREE=4; // get bit lengths tree for a dynamic block
+        private const int DTREE=5; // get length, distance trees for a dynamic block
+        private const int CODES=6; // processing fixed or dynamic block
+        private const int DRY=7;   // output remaining window bytes
+        private const int DONE=8;  // finished last block, done
+        private const int BAD=9;   // ot a data error--stuck here
+
+        internal int mode;            // current inflate_block mode 
+
+        internal int left;            // if STORED, bytes left to copy 
+
+        internal int table;           // table lengths (14 bits) 
+        internal int index;           // index into blens (or border) 
+        internal int[] blens;         // bit lengths of codes 
+        internal int[] bb=new int[1]; // bit length tree depth 
+        internal int[] tb=new int[1]; // bit length decoding tree 
+
+        internal InfCodes codes=new InfCodes();      // if CODES, current state 
+
+        int last;            // true if this block is the last block 
+
+        // mode independent information 
+        internal int bitk;            // bits in bit buffer 
+        internal int bitb;            // bit buffer 
+        internal int[] hufts;         // single malloc for tree space 
+        internal byte[] window;       // sliding window 
+        internal int end;             // one byte after sliding window 
+        internal int read;            // window read pointer 
+        internal int write;           // window write pointer 
+        internal Object checkfn;      // check function 
+        internal long check;          // check on output 
+
+        internal InfTree inftree=new InfTree();
+
+        internal InfBlocks(ZStream z, Object checkfn, int w){
+            hufts=new int[MANY*3];
+            window=new byte[w];
+            end=w;
+            this.checkfn = checkfn;
+            mode = TYPE;
+            reset(z, null);
+        }
+
+        internal void reset(ZStream z, long[] c){
+            if(c!=null) c[0]=check;
+            if(mode==BTREE || mode==DTREE){
+            }
+            if(mode==CODES){
+                codes.free(z);
+            }
+            mode=TYPE;
+            bitk=0;
+            bitb=0;
+            read=write=0;
+
+            if(checkfn != null)
+                z.adler=check=z._adler.adler32(0L, null, 0, 0);
+        }
+
+        internal int proc(ZStream z, int r){
+            int t;              // temporary storage
+            int b;              // bit buffer
+            int k;              // bits in bit buffer
+            int p;              // input data pointer
+            int n;              // bytes available there
+            int q;              // output window write pointer
+            int m; {              // bytes to end of window or read pointer
+
+            // copy input/output information to locals (UPDATE macro restores)
+     p=z.next_in_index;n=z.avail_in;b=bitb;k=bitk;} {
+     q=write;m=(int)(q<read?read-q-1:end-q);}
+
+            // process input based on current state
+            while(true){
+                switch (mode){
+                    case TYPE:
+
+                        while(k<(3)){
+                            if(n!=0){
+                                r=Z_OK;
+                            }
+                            else{
+                                bitb=b; bitk=k; 
+                                z.avail_in=n;
+                                z.total_in+=p-z.next_in_index;z.next_in_index=p;
+                                write=q;
+                                return inflate_flush(z,r);
+                            };
+                            n--;
+                            b|=(z.next_in[p++]&0xff)<<k;
+                            k+=8;
+                        }
+                        t = (int)(b & 7);
+                        last = t & 1;
+
+                    switch (t >> 1){
+                        case 0: {                         // stored 
+           b>>=(3);k-=(3);}
+                            t = k & 7; {                    // go to byte boundary
+
+           b>>=(t);k-=(t);}
+                            mode = LENS;                  // get length of stored block
+                            break;
+                        case 1: {                         // fixed
+                            int[] bl=new int[1];
+                            int[] bd=new int[1];
+                            int[][] tl=new int[1][];
+                            int[][] td=new int[1][];
+
+                            InfTree.inflate_trees_fixed(bl, bd, tl, td, z);
+                            codes.init(bl[0], bd[0], tl[0], 0, td[0], 0, z);
+                        } {
+
+           b>>=(3);k-=(3);}
+
+                            mode = CODES;
+                            break;
+                        case 2: {                         // dynamic
+
+           b>>=(3);k-=(3);}
+
+                            mode = TABLE;
+                            break;
+                        case 3: {                         // illegal
+
+           b>>=(3);k-=(3);}
+                            mode = BAD;
+                            z.msg = "invalid block type";
+                            r = Z_DATA_ERROR;
+
+                            bitb=b; bitk=k; 
+                            z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
+                            write=q;
+                            return inflate_flush(z,r);
+                    }
+                        break;
+                    case LENS:
+
+                        while(k<(32)){
+                            if(n!=0){
+                                r=Z_OK;
+                            }
+                            else{
+                                bitb=b; bitk=k; 
+                                z.avail_in=n;
+                                z.total_in+=p-z.next_in_index;z.next_in_index=p;
+                                write=q;
+                                return inflate_flush(z,r);
+                            };
+                            n--;
+                            b|=(z.next_in[p++]&0xff)<<k;
+                            k+=8;
+                        }
+
+                        if ((((~b) >> 16) & 0xffff) != (b & 0xffff)){
+                            mode = BAD;
+                            z.msg = "invalid stored block lengths";
+                            r = Z_DATA_ERROR;
+
+                            bitb=b; bitk=k; 
+                            z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
+                            write=q;
+                            return inflate_flush(z,r);
+                        }
+                        left = (b & 0xffff);
+                        b = k = 0;                       // dump bits
+                        mode = left!=0 ? STORED : (last!=0 ? DRY : TYPE);
+                        break;
+                    case STORED:
+                        if (n == 0){
+                            bitb=b; bitk=k; 
+                            z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
+                            write=q;
+                            return inflate_flush(z,r);
+                        }
+
+                        if(m==0){
+                            if(q==end&&read!=0){
+                                q=0; m=(int)(q<read?read-q-1:end-q);
+                            }
+                            if(m==0){
+                                write=q; 
+                                r=inflate_flush(z,r);
+                                q=write;m=(int)(q<read?read-q-1:end-q);
+                                if(q==end&&read!=0){
+                                    q=0; m=(int)(q<read?read-q-1:end-q);
+                                }
+                                if(m==0){
+                                    bitb=b; bitk=k; 
+                                    z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
+                                    write=q;
+                                    return inflate_flush(z,r);
+                                }
+                            }
+                        }
+                        r=Z_OK;
+
+                        t = left;
+                        if(t>n) t = n;
+                        if(t>m) t = m;
+                        System.Array.Copy(z.next_in, p, window, q, t);
+                        p += t;  n -= t;
+                        q += t;  m -= t;
+                        if ((left -= t) != 0)
+                            break;
+                        mode = last!=0 ? DRY : TYPE;
+                        break;
+                    case TABLE:
+
+                        while(k<(14)){
+                            if(n!=0){
+                                r=Z_OK;
+                            }
+                            else{
+                                bitb=b; bitk=k; 
+                                z.avail_in=n;
+                                z.total_in+=p-z.next_in_index;z.next_in_index=p;
+                                write=q;
+                                return inflate_flush(z,r);
+                            };
+                            n--;
+                            b|=(z.next_in[p++]&0xff)<<k;
+                            k+=8;
+                        }
+
+                        table = t = (b & 0x3fff);
+                        if ((t & 0x1f) > 29 || ((t >> 5) & 0x1f) > 29) {
+                            mode = BAD;
+                            z.msg = "too many length or distance symbols";
+                            r = Z_DATA_ERROR;
+
+                            bitb=b; bitk=k; 
+                            z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
+                            write=q;
+                            return inflate_flush(z,r);
+                        }
+                        t = 258 + (t & 0x1f) + ((t >> 5) & 0x1f);
+                        if(blens==null || blens.Length<t){
+                            blens=new int[t];
+                        }
+                        else{
+                            for(int i=0; i<t; i++){blens[i]=0;}
+                        } {
+
+	 b>>=(14);k-=(14);}
+
+                        index = 0;
+                        mode = BTREE;
+                        goto case BTREE;
+                    case BTREE:
+                        while (index < 4 + (table >> 10)){
+                            while(k<(3)){
+                                if(n!=0){
+                                    r=Z_OK;
+                                }
+                                else{
+                                    bitb=b; bitk=k; 
+                                    z.avail_in=n;
+                                    z.total_in+=p-z.next_in_index;z.next_in_index=p;
+                                    write=q;
+                                    return inflate_flush(z,r);
+                                };
+                                n--;
+                                b|=(z.next_in[p++]&0xff)<<k;
+                                k+=8;
+                            }
+
+                            blens[border[index++]] = b&7; {
+
+	   b>>=(3);k-=(3);}
+                        }
+
+                        while(index < 19){
+                            blens[border[index++]] = 0;
+                        }
+
+                        bb[0] = 7;
+                        t = inftree.inflate_trees_bits(blens, bb, tb, hufts, z);
+                        if (t != Z_OK){
+                            r = t;
+                            if (r == Z_DATA_ERROR){
+                                blens=null;
+                                mode = BAD;
+                            }
+
+                            bitb=b; bitk=k; 
+                            z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
+                            write=q;
+                            return inflate_flush(z,r);
+                        }
+
+                        index = 0;
+                        mode = DTREE;
+                        goto case DTREE;
+                    case DTREE:
+                        while (true){
+                            t = table;
+                            if(!(index < 258 + (t & 0x1f) + ((t >> 5) & 0x1f))){
+                                break;
+                            }
+
+                            int i, j, c;
+
+                            t = bb[0];
+
+                            while(k<(t)){
+                                if(n!=0){
+                                    r=Z_OK;
+                                }
+                                else{
+                                    bitb=b; bitk=k; 
+                                    z.avail_in=n;
+                                    z.total_in+=p-z.next_in_index;z.next_in_index=p;
+                                    write=q;
+                                    return inflate_flush(z,r);
+                                };
+                                n--;
+                                b|=(z.next_in[p++]&0xff)<<k;
+                                k+=8;
+                            }
+
+                            if(tb[0]==-1){
+                                //System.err.println("null...");
+                            }
+
+                            t=hufts[(tb[0]+(b&inflate_mask[t]))*3+1];
+                            c=hufts[(tb[0]+(b&inflate_mask[t]))*3+2];
+
+                            if (c < 16){
+                                b>>=(t);k-=(t);
+                                blens[index++] = c;
+                            }
+                            else { // c == 16..18
+                                i = c == 18 ? 7 : c - 14;
+                                j = c == 18 ? 11 : 3;
+
+                                while(k<(t+i)){
+                                    if(n!=0){
+                                        r=Z_OK;
+                                    }
+                                    else{
+                                        bitb=b; bitk=k; 
+                                        z.avail_in=n;
+                                        z.total_in+=p-z.next_in_index;z.next_in_index=p;
+                                        write=q;
+                                        return inflate_flush(z,r);
+                                    };
+                                    n--;
+                                    b|=(z.next_in[p++]&0xff)<<k;
+                                    k+=8;
+                                }
+
+                                b>>=(t);k-=(t);
+
+                                j += (b & inflate_mask[i]);
+
+                                b>>=(i);k-=(i);
+
+                                i = index;
+                                t = table;
+                                if (i + j > 258 + (t & 0x1f) + ((t >> 5) & 0x1f) ||
+                                    (c == 16 && i < 1)){
+                                    blens=null;
+                                    mode = BAD;
+                                    z.msg = "invalid bit length repeat";
+                                    r = Z_DATA_ERROR;
+
+                                    bitb=b; bitk=k; 
+                                    z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
+                                    write=q;
+                                    return inflate_flush(z,r);
+                                }
+
+                                c = c == 16 ? blens[i-1] : 0;
+                                do{
+                                    blens[i++] = c;
+                                }
+                                while (--j!=0);
+                                index = i;
+                            }
+                        }
+
+                        tb[0]=-1; {
+                        int[] bl=new int[1];
+                        int[] bd=new int[1];
+                        int[] tl=new int[1];
+                        int[] td=new int[1];
+                        bl[0] = 9;         // must be <= 9 for lookahead assumptions
+                        bd[0] = 6;         // must be <= 9 for lookahead assumptions
+
+                        t = table;
+                        t = inftree.inflate_trees_dynamic(257 + (t & 0x1f), 
+                            1 + ((t >> 5) & 0x1f),
+                            blens, bl, bd, tl, td, hufts, z);
+
+                        if (t != Z_OK){
+                            if (t == Z_DATA_ERROR){
+                                blens=null;
+                                mode = BAD;
+                            }
+                            r = t;
+
+                            bitb=b; bitk=k; 
+                            z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
+                            write=q;
+                            return inflate_flush(z,r);
+                        }
+                        codes.init(bl[0], bd[0], hufts, tl[0], hufts, td[0], z);
+                    }
+                        mode = CODES;
+                        goto case CODES;
+                    case CODES:
+                        bitb=b; bitk=k;
+                        z.avail_in=n; z.total_in+=p-z.next_in_index;z.next_in_index=p;
+                        write=q;
+
+                        if ((r = codes.proc(this, z, r)) != Z_STREAM_END){
+                            return inflate_flush(z, r);
+                        }
+                        r = Z_OK;
+                        codes.free(z);
+
+                        p=z.next_in_index; n=z.avail_in;b=bitb;k=bitk;
+                        q=write;m=(int)(q<read?read-q-1:end-q);
+
+                        if (last==0){
+                            mode = TYPE;
+                            break;
+                        }
+                        mode = DRY;
+                        goto case DRY;
+                    case DRY:
+                        write=q; 
+                        r=inflate_flush(z, r); 
+                        q=write; m=(int)(q<read?read-q-1:end-q);
+                        if (read != write){
+                            bitb=b; bitk=k; 
+                            z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
+                            write=q;
+                            return inflate_flush(z, r);
+                        }
+                        mode = DONE;
+                        goto case DONE;
+                    case DONE:
+                        r = Z_STREAM_END;
+
+                        bitb=b; bitk=k; 
+                        z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
+                        write=q;
+                        return inflate_flush(z, r);
+                    case BAD:
+                        r = Z_DATA_ERROR;
+
+                        bitb=b; bitk=k; 
+                        z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
+                        write=q;
+                        return inflate_flush(z, r);
+
+                    default:
+                        r = Z_STREAM_ERROR;
+
+                        bitb=b; bitk=k; 
+                        z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
+                        write=q;
+                        return inflate_flush(z, r);
+                }
+            }
+        }
+
+        internal void free(ZStream z){
+            reset(z, null);
+            window=null;
+            hufts=null;
+            //ZFREE(z, s);
+        }
+
+        internal void set_dictionary(byte[] d, int start, int n){
+            System.Array.Copy(d, start, window, 0, n);
+            read = write = n;
+        }
+
+        // Returns true if inflate is currently at the end of a block generated
+        // by Z_SYNC_FLUSH or Z_FULL_FLUSH. 
+        internal int sync_point(){
+            return mode == LENS ? 1 : 0;
+        }
+
+        // copy as much as possible from the sliding window to the output area
+        internal int inflate_flush(ZStream z, int r){
+            int n;
+            int p;
+            int q;
+
+            // local copies of source and destination pointers
+            p = z.next_out_index;
+            q = read;
+
+            // compute number of bytes to copy as far as end of window
+            n = (int)((q <= write ? write : end) - q);
+            if (n > z.avail_out) n = z.avail_out;
+            if (n!=0 && r == Z_BUF_ERROR) r = Z_OK;
+
+            // update counters
+            z.avail_out -= n;
+            z.total_out += n;
+
+            // update check information
+            if(checkfn != null)
+                z.adler=check=z._adler.adler32(check, window, q, n);
+
+            // copy as far as end of window
+            System.Array.Copy(window, q, z.next_out, p, n);
+            p += n;
+            q += n;
+
+            // see if more to copy at beginning of window
+            if (q == end){
+                // wrap pointers
+                q = 0;
+                if (write == end)
+                    write = 0;
+
+                // compute bytes to copy
+                n = write - q;
+                if (n > z.avail_out) n = z.avail_out;
+                if (n!=0 && r == Z_BUF_ERROR) r = Z_OK;
+
+                // update counters
+                z.avail_out -= n;
+                z.total_out += n;
+
+                // update check information
+                if(checkfn != null)
+                    z.adler=check=z._adler.adler32(check, window, q, n);
+
+                // copy
+                System.Array.Copy(window, q, z.next_out, p, n);
+                p += n;
+                q += n;
+            }
+
+            // update pointers
+            z.next_out_index = p;
+            read = q;
+
+            // done
+            return r;
+        }
+    }
+}

src/core/System/util/zlib/InfCodes.cs

@@ -0,0 +1,611 @@
+using System;
+/*
+ * $Id: InfCodes.cs,v 1.1 2006/06/16 10:56:20 psoares33 Exp $
+ *
+Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+  1. Redistributions of source code must retain the above copyright notice,
+     this list of conditions and the following disclaimer.
+
+  2. Redistributions in binary form must reproduce the above copyright 
+     notice, this list of conditions and the following disclaimer in 
+     the documentation and/or other materials provided with the distribution.
+
+  3. The names of the authors may not be used to endorse or promote products
+     derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
+INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
+INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/*
+ * This program is based on zlib-1.1.3, so all credit should go authors
+ * Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu)
+ * and contributors of zlib.
+ */
+
+namespace System.util.zlib {
+
+    internal sealed class InfCodes{
+
+        static private int[] inflate_mask = {
+                                                0x00000000, 0x00000001, 0x00000003, 0x00000007, 0x0000000f,
+                                                0x0000001f, 0x0000003f, 0x0000007f, 0x000000ff, 0x000001ff,
+                                                0x000003ff, 0x000007ff, 0x00000fff, 0x00001fff, 0x00003fff,
+                                                0x00007fff, 0x0000ffff
+                                            };
+
+        private const int Z_OK=0;
+        private const int Z_STREAM_END=1;
+        private const int Z_NEED_DICT=2;
+        private const int Z_ERRNO=-1;
+        private const int Z_STREAM_ERROR=-2;
+        private const int Z_DATA_ERROR=-3;
+        private const int Z_MEM_ERROR=-4;
+        private const int Z_BUF_ERROR=-5;
+        private const int Z_VERSION_ERROR=-6;
+
+        // waiting for "i:"=input,
+        //             "o:"=output,
+        //             "x:"=nothing
+        private const int START=0;  // x: set up for LEN
+        private const int LEN=1;    // i: get length/literal/eob next
+        private const int LENEXT=2; // i: getting length extra (have base)
+        private const int DIST=3;   // i: get distance next
+        private const int DISTEXT=4;// i: getting distance extra
+        private const int COPY=5;   // o: copying bytes in window, waiting for space
+        private const int LIT=6;    // o: got literal, waiting for output space
+        private const int WASH=7;   // o: got eob, possibly still output waiting
+        private const int END=8;    // x: got eob and all data flushed
+        private const int BADCODE=9;// x: got error
+
+        int mode;      // current inflate_codes mode
+
+        // mode dependent information
+        int len;
+
+        int[] tree; // pointer into tree
+        int tree_index=0;
+        int need;   // bits needed
+
+        int lit;
+
+        // if EXT or COPY, where and how much
+        int get;              // bits to get for extra
+        int dist;             // distance back to copy from
+
+        byte lbits;           // ltree bits decoded per branch
+        byte dbits;           // dtree bits decoder per branch
+        int[] ltree;          // literal/length/eob tree
+        int ltree_index;      // literal/length/eob tree
+        int[] dtree;          // distance tree
+        int dtree_index;      // distance tree
+
+        internal InfCodes(){
+        }
+        internal void init(int bl, int bd,
+            int[] tl, int tl_index,
+            int[] td, int td_index, ZStream z){
+            mode=START;
+            lbits=(byte)bl;
+            dbits=(byte)bd;
+            ltree=tl;
+            ltree_index=tl_index;
+            dtree = td;
+            dtree_index=td_index;
+            tree=null;
+        }
+
+        internal int proc(InfBlocks s, ZStream z, int r){ 
+            int j;              // temporary storage
+            int tindex;         // temporary pointer
+            int e;              // extra bits or operation
+            int b=0;            // bit buffer
+            int k=0;            // bits in bit buffer
+            int p=0;            // input data pointer
+            int n;              // bytes available there
+            int q;              // output window write pointer
+            int m;              // bytes to end of window or read pointer
+            int f;              // pointer to copy strings from
+
+            // copy input/output information to locals (UPDATE macro restores)
+            p=z.next_in_index;n=z.avail_in;b=s.bitb;k=s.bitk;
+            q=s.write;m=q<s.read?s.read-q-1:s.end-q;
+
+            // process input and output based on current state
+            while (true){
+                switch (mode){
+                        // waiting for "i:"=input, "o:"=output, "x:"=nothing
+                    case START:         // x: set up for LEN
+                        if (m >= 258 && n >= 10){
+
+                            s.bitb=b;s.bitk=k;
+                            z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
+                            s.write=q;
+                            r = inflate_fast(lbits, dbits, 
+                                ltree, ltree_index, 
+                                dtree, dtree_index,
+                                s, z);
+
+                            p=z.next_in_index;n=z.avail_in;b=s.bitb;k=s.bitk;
+                            q=s.write;m=q<s.read?s.read-q-1:s.end-q;
+
+                            if (r != Z_OK){
+                                mode = r == Z_STREAM_END ? WASH : BADCODE;
+                                break;
+                            }
+                        }
+                        need = lbits;
+                        tree = ltree;
+                        tree_index=ltree_index;
+
+                        mode = LEN;
+                        goto case LEN;
+                    case LEN:           // i: get length/literal/eob next
+                        j = need;
+
+                        while(k<(j)){
+                            if(n!=0)r=Z_OK;
+                            else{
+
+                                s.bitb=b;s.bitk=k;
+                                z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
+                                s.write=q;
+                                return s.inflate_flush(z,r);
+                            }
+                            n--;
+                            b|=(z.next_in[p++]&0xff)<<k;
+                            k+=8;
+                        }
+
+                        tindex=(tree_index+(b&inflate_mask[j]))*3;
+
+                        b>>=(tree[tindex+1]);
+                        k-=(tree[tindex+1]);
+
+                        e=tree[tindex];
+
+                        if(e == 0){               // literal
+                            lit = tree[tindex+2];
+                            mode = LIT;
+                            break;
+                        }
+                        if((e & 16)!=0 ){          // length
+                            get = e & 15;
+                            len = tree[tindex+2];
+                            mode = LENEXT;
+                            break;
+                        }
+                        if ((e & 64) == 0){        // next table
+                            need = e;
+                            tree_index = tindex/3+tree[tindex+2];
+                            break;
+                        }
+                        if ((e & 32)!=0){               // end of block
+                            mode = WASH;
+                            break;
+                        }
+                        mode = BADCODE;        // invalid code
+                        z.msg = "invalid literal/length code";
+                        r = Z_DATA_ERROR;
+
+                        s.bitb=b;s.bitk=k;
+                        z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
+                        s.write=q;
+                        return s.inflate_flush(z,r);
+
+                    case LENEXT:        // i: getting length extra (have base)
+                        j = get;
+
+                        while(k<(j)){
+                            if(n!=0)r=Z_OK;
+                            else{
+
+                                s.bitb=b;s.bitk=k;
+                                z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
+                                s.write=q;
+                                return s.inflate_flush(z,r);
+                            }
+                            n--; b|=(z.next_in[p++]&0xff)<<k;
+                            k+=8;
+                        }
+
+                        len += (b & inflate_mask[j]);
+
+                        b>>=j;
+                        k-=j;
+
+                        need = dbits;
+                        tree = dtree;
+                        tree_index=dtree_index;
+                        mode = DIST;
+                        goto case DIST;
+                    case DIST:          // i: get distance next
+                        j = need;
+
+                        while(k<(j)){
+                            if(n!=0)r=Z_OK;
+                            else{
+
+                                s.bitb=b;s.bitk=k;
+                                z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
+                                s.write=q;
+                                return s.inflate_flush(z,r);
+                            }
+                            n--; b|=(z.next_in[p++]&0xff)<<k;
+                            k+=8;
+                        }
+
+                        tindex=(tree_index+(b & inflate_mask[j]))*3;
+
+                        b>>=tree[tindex+1];
+                        k-=tree[tindex+1];
+
+                        e = (tree[tindex]);
+                        if((e & 16)!=0){               // distance
+                            get = e & 15;
+                            dist = tree[tindex+2];
+                            mode = DISTEXT;
+                            break;
+                        }
+                        if ((e & 64) == 0){        // next table
+                            need = e;
+                            tree_index = tindex/3 + tree[tindex+2];
+                            break;
+                        }
+                        mode = BADCODE;        // invalid code
+                        z.msg = "invalid distance code";
+                        r = Z_DATA_ERROR;
+
+                        s.bitb=b;s.bitk=k;
+                        z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
+                        s.write=q;
+                        return s.inflate_flush(z,r);
+
+                    case DISTEXT:       // i: getting distance extra
+                        j = get;
+
+                        while(k<(j)){
+                            if(n!=0)r=Z_OK;
+                            else{
+
+                                s.bitb=b;s.bitk=k;
+                                z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
+                                s.write=q;
+                                return s.inflate_flush(z,r);
+                            }
+                            n--; b|=(z.next_in[p++]&0xff)<<k;
+                            k+=8;
+                        }
+
+                        dist += (b & inflate_mask[j]);
+
+                        b>>=j;
+                        k-=j;
+
+                        mode = COPY;
+                        goto case COPY;
+                    case COPY:          // o: copying bytes in window, waiting for space
+                        f = q - dist;
+                        while(f < 0){     // modulo window size-"while" instead
+                            f += s.end;     // of "if" handles invalid distances
+                        }
+                        while (len!=0){
+
+                            if(m==0){
+                                if(q==s.end&&s.read!=0){q=0;m=q<s.read?s.read-q-1:s.end-q;}
+                                if(m==0){
+                                    s.write=q; r=s.inflate_flush(z,r);
+                                    q=s.write;m=q<s.read?s.read-q-1:s.end-q;
+
+                                    if(q==s.end&&s.read!=0){q=0;m=q<s.read?s.read-q-1:s.end-q;}
+
+                                    if(m==0){
+                                        s.bitb=b;s.bitk=k;
+                                        z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
+                                        s.write=q;
+                                        return s.inflate_flush(z,r);
+                                    }  
+                                }
+                            }
+
+                            s.window[q++]=s.window[f++]; m--;
+
+                            if (f == s.end)
+                                f = 0;
+                            len--;
+                        }
+                        mode = START;
+                        break;
+                    case LIT:           // o: got literal, waiting for output space
+                        if(m==0){
+                            if(q==s.end&&s.read!=0){q=0;m=q<s.read?s.read-q-1:s.end-q;}
+                            if(m==0){
+                                s.write=q; r=s.inflate_flush(z,r);
+                                q=s.write;m=q<s.read?s.read-q-1:s.end-q;
+
+                                if(q==s.end&&s.read!=0){q=0;m=q<s.read?s.read-q-1:s.end-q;}
+                                if(m==0){
+                                    s.bitb=b;s.bitk=k;
+                                    z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
+                                    s.write=q;
+                                    return s.inflate_flush(z,r);
+                                }
+                            }
+                        }
+                        r=Z_OK;
+
+                        s.window[q++]=(byte)lit; m--;
+
+                        mode = START;
+                        break;
+                    case WASH:           // o: got eob, possibly more output
+                        if (k > 7){        // return unused byte, if any
+                            k -= 8;
+                            n++;
+                            p--;             // can always return one
+                        }
+
+                        s.write=q; r=s.inflate_flush(z,r);
+                        q=s.write;m=q<s.read?s.read-q-1:s.end-q;
+
+                        if (s.read != s.write){
+                            s.bitb=b;s.bitk=k;
+                            z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
+                            s.write=q;
+                            return s.inflate_flush(z,r);
+                        }
+                        mode = END;
+                        goto case END;
+                    case END:
+                        r = Z_STREAM_END;
+                        s.bitb=b;s.bitk=k;
+                        z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
+                        s.write=q;
+                        return s.inflate_flush(z,r);
+
+                    case BADCODE:       // x: got error
+
+                        r = Z_DATA_ERROR;
+
+                        s.bitb=b;s.bitk=k;
+                        z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
+                        s.write=q;
+                        return s.inflate_flush(z,r);
+
+                    default:
+                        r = Z_STREAM_ERROR;
+
+                        s.bitb=b;s.bitk=k;
+                        z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
+                        s.write=q;
+                        return s.inflate_flush(z,r);
+                }
+            }
+        }
+
+        internal void free(ZStream z){
+            //  ZFREE(z, c);
+        }
+
+        // Called with number of bytes left to write in window at least 258
+        // (the maximum string length) and number of input bytes available
+        // at least ten.  The ten bytes are six bytes for the longest length/
+        // distance pair plus four bytes for overloading the bit buffer.
+
+        internal int inflate_fast(int bl, int bd, 
+            int[] tl, int tl_index,
+            int[] td, int td_index,
+            InfBlocks s, ZStream z){
+            int t;                // temporary pointer
+            int[] tp;             // temporary pointer
+            int tp_index;         // temporary pointer
+            int e;                // extra bits or operation
+            int b;                // bit buffer
+            int k;                // bits in bit buffer
+            int p;                // input data pointer
+            int n;                // bytes available there
+            int q;                // output window write pointer
+            int m;                // bytes to end of window or read pointer
+            int ml;               // mask for literal/length tree
+            int md;               // mask for distance tree
+            int c;                // bytes to copy
+            int d;                // distance back to copy from
+            int r;                // copy source pointer
+
+            int tp_index_t_3;     // (tp_index+t)*3
+
+            // load input, output, bit values
+            p=z.next_in_index;n=z.avail_in;b=s.bitb;k=s.bitk;
+            q=s.write;m=q<s.read?s.read-q-1:s.end-q;
+
+            // initialize masks
+            ml = inflate_mask[bl];
+            md = inflate_mask[bd];
+
+            // do until not enough input or output space for fast loop
+            do {                          // assume called with m >= 258 && n >= 10
+                // get literal/length code
+            while(k<(20)){              // max bits for literal/length code
+                n--;
+                b|=(z.next_in[p++]&0xff)<<k;k+=8;
+            }
+
+                t= b&ml;
+                tp=tl; 
+                tp_index=tl_index;
+                tp_index_t_3=(tp_index+t)*3;
+                if ((e = tp[tp_index_t_3]) == 0){
+                    b>>=(tp[tp_index_t_3+1]); k-=(tp[tp_index_t_3+1]);
+
+                    s.window[q++] = (byte)tp[tp_index_t_3+2];
+                    m--;
+                    continue;
+                }
+                do {
+
+                    b>>=(tp[tp_index_t_3+1]); k-=(tp[tp_index_t_3+1]);
+
+                    if((e&16)!=0){
+                        e &= 15;
+                        c = tp[tp_index_t_3+2] + ((int)b & inflate_mask[e]);
+
+                        b>>=e; k-=e;
+
+                        // decode distance base of block to copy
+                        while(k<(15)){           // max bits for distance code
+                            n--;
+                            b|=(z.next_in[p++]&0xff)<<k;k+=8;
+                        }
+
+                        t= b&md;
+                        tp=td;
+                        tp_index=td_index;
+                        tp_index_t_3=(tp_index+t)*3;
+                        e = tp[tp_index_t_3];
+
+                        do {
+
+                            b>>=(tp[tp_index_t_3+1]); k-=(tp[tp_index_t_3+1]);
+
+                            if((e&16)!=0){
+                                // get extra bits to add to distance base
+                                e &= 15;
+                                while(k<(e)){         // get extra bits (up to 13)
+                                    n--;
+                                    b|=(z.next_in[p++]&0xff)<<k;k+=8;
+                                }
+
+                                d = tp[tp_index_t_3+2] + (b&inflate_mask[e]);
+
+                                b>>=(e); k-=(e);
+
+                                // do the copy
+                                m -= c;
+                                if (q >= d){                // offset before dest
+                                    //  just copy
+                                    r=q-d;
+                                    if(q-r>0 && 2>(q-r)){           
+                                        s.window[q++]=s.window[r++]; // minimum count is three,
+                                        s.window[q++]=s.window[r++]; // so unroll loop a little
+                                        c-=2;
+                                    }
+                                    else{
+                                        System.Array.Copy(s.window, r, s.window, q, 2);
+                                        q+=2; r+=2; c-=2;
+                                    }
+                                }
+                                else{                  // else offset after destination
+                                    r=q-d;
+                                    do{
+                                        r+=s.end;          // force pointer in window
+                                    }while(r<0);         // covers invalid distances
+                                    e=s.end-r;
+                                    if(c>e){             // if source crosses,
+                                        c-=e;              // wrapped copy
+                                        if(q-r>0 && e>(q-r)){           
+                                            do{s.window[q++] = s.window[r++];}
+                                            while(--e!=0);
+                                        }
+                                        else{
+                                            System.Array.Copy(s.window, r, s.window, q, e);
+                                            q+=e; r+=e; e=0;
+                                        }
+                                        r = 0;                  // copy rest from start of window
+                                    }
+
+                                }
+
+                                // copy all or what's left
+                                if(q-r>0 && c>(q-r)){           
+                                    do{s.window[q++] = s.window[r++];}
+                                    while(--c!=0);
+                                }
+                                else{
+                                    System.Array.Copy(s.window, r, s.window, q, c);
+                                    q+=c; r+=c; c=0;
+                                }
+                                break;
+                            }
+                            else if((e&64)==0){
+                                t+=tp[tp_index_t_3+2];
+                                t+=(b&inflate_mask[e]);
+                                tp_index_t_3=(tp_index+t)*3;
+                                e=tp[tp_index_t_3];
+                            }
+                            else{
+                                z.msg = "invalid distance code";
+
+                                c=z.avail_in-n;c=(k>>3)<c?k>>3:c;n+=c;p-=c;k-=c<<3;
+
+                                s.bitb=b;s.bitk=k;
+                                z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
+                                s.write=q;
+
+                                return Z_DATA_ERROR;
+                            }
+                        }
+                        while(true);
+                        break;
+                    }
+
+                    if((e&64)==0){
+                        t+=tp[tp_index_t_3+2];
+                        t+=(b&inflate_mask[e]);
+                        tp_index_t_3=(tp_index+t)*3;
+                        if((e=tp[tp_index_t_3])==0){
+
+                            b>>=(tp[tp_index_t_3+1]); k-=(tp[tp_index_t_3+1]);
+
+                            s.window[q++]=(byte)tp[tp_index_t_3+2];
+                            m--;
+                            break;
+                        }
+                    }
+                    else if((e&32)!=0){
+
+                        c=z.avail_in-n;c=(k>>3)<c?k>>3:c;n+=c;p-=c;k-=c<<3;
+ 
+                        s.bitb=b;s.bitk=k;
+                        z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
+                        s.write=q;
+
+                        return Z_STREAM_END;
+                    }
+                    else{
+                        z.msg="invalid literal/length code";
+
+                        c=z.avail_in-n;c=(k>>3)<c?k>>3:c;n+=c;p-=c;k-=c<<3;
+
+                        s.bitb=b;s.bitk=k;
+                        z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
+                        s.write=q;
+
+                        return Z_DATA_ERROR;
+                    }
+                } 
+                while(true);
+            } 
+            while(m>=258 && n>= 10);
+
+            // not enough input or output--restore pointers and return
+            c=z.avail_in-n;c=(k>>3)<c?k>>3:c;n+=c;p-=c;k-=c<<3;
+
+            s.bitb=b;s.bitk=k;
+            z.avail_in=n;z.total_in+=p-z.next_in_index;z.next_in_index=p;
+            s.write=q;
+
+            return Z_OK;
+        }
+    }
+}

src/core/System/util/zlib/InfTree.cs

@@ -0,0 +1,523 @@
+using System;
+/*
+ * $Id: InfTree.cs,v 1.1 2006/06/16 10:56:20 psoares33 Exp $
+ *
+Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+  1. Redistributions of source code must retain the above copyright notice,
+     this list of conditions and the following disclaimer.
+
+  2. Redistributions in binary form must reproduce the above copyright 
+     notice, this list of conditions and the following disclaimer in 
+     the documentation and/or other materials provided with the distribution.
+
+  3. The names of the authors may not be used to endorse or promote products
+     derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
+INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
+INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/*
+ * This program is based on zlib-1.1.3, so all credit should go authors
+ * Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu)
+ * and contributors of zlib.
+ */
+
+namespace System.util.zlib {
+
+    internal sealed class InfTree{
+
+        private const int MANY=1440;
+
+        private const int Z_OK=0;
+        private const int Z_STREAM_END=1;
+        private const int Z_NEED_DICT=2;
+        private const int Z_ERRNO=-1;
+        private const int Z_STREAM_ERROR=-2;
+        private const int Z_DATA_ERROR=-3;
+        private const int Z_MEM_ERROR=-4;
+        private const int Z_BUF_ERROR=-5;
+        private const int Z_VERSION_ERROR=-6;
+
+        private const int fixed_bl = 9;
+        private const int fixed_bd = 5;
+
+        static int[] fixed_tl = {
+                                    96,7,256, 0,8,80, 0,8,16, 84,8,115,
+                                    82,7,31, 0,8,112, 0,8,48, 0,9,192,
+                                    80,7,10, 0,8,96, 0,8,32, 0,9,160,
+                                    0,8,0, 0,8,128, 0,8,64, 0,9,224,
+                                    80,7,6, 0,8,88, 0,8,24, 0,9,144,
+                                    83,7,59, 0,8,120, 0,8,56, 0,9,208,
+                                    81,7,17, 0,8,104, 0,8,40, 0,9,176,
+                                    0,8,8, 0,8,136, 0,8,72, 0,9,240,
+                                    80,7,4, 0,8,84, 0,8,20, 85,8,227,
+                                    83,7,43, 0,8,116, 0,8,52, 0,9,200,
+                                    81,7,13, 0,8,100, 0,8,36, 0,9,168,
+                                    0,8,4, 0,8,132, 0,8,68, 0,9,232,
+                                    80,7,8, 0,8,92, 0,8,28, 0,9,152,
+                                    84,7,83, 0,8,124, 0,8,60, 0,9,216,
+                                    82,7,23, 0,8,108, 0,8,44, 0,9,184,
+                                    0,8,12, 0,8,140, 0,8,76, 0,9,248,
+                                    80,7,3, 0,8,82, 0,8,18, 85,8,163,
+                                    83,7,35, 0,8,114, 0,8,50, 0,9,196,
+                                    81,7,11, 0,8,98, 0,8,34, 0,9,164,
+                                    0,8,2, 0,8,130, 0,8,66, 0,9,228,
+                                    80,7,7, 0,8,90, 0,8,26, 0,9,148,
+                                    84,7,67, 0,8,122, 0,8,58, 0,9,212,
+                                    82,7,19, 0,8,106, 0,8,42, 0,9,180,
+                                    0,8,10, 0,8,138, 0,8,74, 0,9,244,
+                                    80,7,5, 0,8,86, 0,8,22, 192,8,0,
+                                    83,7,51, 0,8,118, 0,8,54, 0,9,204,
+                                    81,7,15, 0,8,102, 0,8,38, 0,9,172,
+                                    0,8,6, 0,8,134, 0,8,70, 0,9,236,
+                                    80,7,9, 0,8,94, 0,8,30, 0,9,156,
+                                    84,7,99, 0,8,126, 0,8,62, 0,9,220,
+                                    82,7,27, 0,8,110, 0,8,46, 0,9,188,
+                                    0,8,14, 0,8,142, 0,8,78, 0,9,252,
+                                    96,7,256, 0,8,81, 0,8,17, 85,8,131,
+                                    82,7,31, 0,8,113, 0,8,49, 0,9,194,
+                                    80,7,10, 0,8,97, 0,8,33, 0,9,162,
+                                    0,8,1, 0,8,129, 0,8,65, 0,9,226,
+                                    80,7,6, 0,8,89, 0,8,25, 0,9,146,
+                                    83,7,59, 0,8,121, 0,8,57, 0,9,210,
+                                    81,7,17, 0,8,105, 0,8,41, 0,9,178,
+                                    0,8,9, 0,8,137, 0,8,73, 0,9,242,
+                                    80,7,4, 0,8,85, 0,8,21, 80,8,258,
+                                    83,7,43, 0,8,117, 0,8,53, 0,9,202,
+                                    81,7,13, 0,8,101, 0,8,37, 0,9,170,
+                                    0,8,5, 0,8,133, 0,8,69, 0,9,234,
+                                    80,7,8, 0,8,93, 0,8,29, 0,9,154,
+                                    84,7,83, 0,8,125, 0,8,61, 0,9,218,
+                                    82,7,23, 0,8,109, 0,8,45, 0,9,186,
+                                    0,8,13, 0,8,141, 0,8,77, 0,9,250,
+                                    80,7,3, 0,8,83, 0,8,19, 85,8,195,
+                                    83,7,35, 0,8,115, 0,8,51, 0,9,198,
+                                    81,7,11, 0,8,99, 0,8,35, 0,9,166,
+                                    0,8,3, 0,8,131, 0,8,67, 0,9,230,
+                                    80,7,7, 0,8,91, 0,8,27, 0,9,150,
+                                    84,7,67, 0,8,123, 0,8,59, 0,9,214,
+                                    82,7,19, 0,8,107, 0,8,43, 0,9,182,
+                                    0,8,11, 0,8,139, 0,8,75, 0,9,246,
+                                    80,7,5, 0,8,87, 0,8,23, 192,8,0,
+                                    83,7,51, 0,8,119, 0,8,55, 0,9,206,
+                                    81,7,15, 0,8,103, 0,8,39, 0,9,174,
+                                    0,8,7, 0,8,135, 0,8,71, 0,9,238,
+                                    80,7,9, 0,8,95, 0,8,31, 0,9,158,
+                                    84,7,99, 0,8,127, 0,8,63, 0,9,222,
+                                    82,7,27, 0,8,111, 0,8,47, 0,9,190,
+                                    0,8,15, 0,8,143, 0,8,79, 0,9,254,
+                                    96,7,256, 0,8,80, 0,8,16, 84,8,115,
+                                    82,7,31, 0,8,112, 0,8,48, 0,9,193,
+
+                                    80,7,10, 0,8,96, 0,8,32, 0,9,161,
+                                    0,8,0, 0,8,128, 0,8,64, 0,9,225,
+                                    80,7,6, 0,8,88, 0,8,24, 0,9,145,
+                                    83,7,59, 0,8,120, 0,8,56, 0,9,209,
+                                    81,7,17, 0,8,104, 0,8,40, 0,9,177,
+                                    0,8,8, 0,8,136, 0,8,72, 0,9,241,
+                                    80,7,4, 0,8,84, 0,8,20, 85,8,227,
+                                    83,7,43, 0,8,116, 0,8,52, 0,9,201,
+                                    81,7,13, 0,8,100, 0,8,36, 0,9,169,
+                                    0,8,4, 0,8,132, 0,8,68, 0,9,233,
+                                    80,7,8, 0,8,92, 0,8,28, 0,9,153,
+                                    84,7,83, 0,8,124, 0,8,60, 0,9,217,
+                                    82,7,23, 0,8,108, 0,8,44, 0,9,185,
+                                    0,8,12, 0,8,140, 0,8,76, 0,9,249,
+                                    80,7,3, 0,8,82, 0,8,18, 85,8,163,
+                                    83,7,35, 0,8,114, 0,8,50, 0,9,197,
+                                    81,7,11, 0,8,98, 0,8,34, 0,9,165,
+                                    0,8,2, 0,8,130, 0,8,66, 0,9,229,
+                                    80,7,7, 0,8,90, 0,8,26, 0,9,149,
+                                    84,7,67, 0,8,122, 0,8,58, 0,9,213,
+                                    82,7,19, 0,8,106, 0,8,42, 0,9,181,
+                                    0,8,10, 0,8,138, 0,8,74, 0,9,245,
+                                    80,7,5, 0,8,86, 0,8,22, 192,8,0,
+                                    83,7,51, 0,8,118, 0,8,54, 0,9,205,
+                                    81,7,15, 0,8,102, 0,8,38, 0,9,173,
+                                    0,8,6, 0,8,134, 0,8,70, 0,9,237,
+                                    80,7,9, 0,8,94, 0,8,30, 0,9,157,
+                                    84,7,99, 0,8,126, 0,8,62, 0,9,221,
+                                    82,7,27, 0,8,110, 0,8,46, 0,9,189,
+                                    0,8,14, 0,8,142, 0,8,78, 0,9,253,
+                                    96,7,256, 0,8,81, 0,8,17, 85,8,131,
+                                    82,7,31, 0,8,113, 0,8,49, 0,9,195,
+                                    80,7,10, 0,8,97, 0,8,33, 0,9,163,
+                                    0,8,1, 0,8,129, 0,8,65, 0,9,227,
+                                    80,7,6, 0,8,89, 0,8,25, 0,9,147,
+                                    83,7,59, 0,8,121, 0,8,57, 0,9,211,
+                                    81,7,17, 0,8,105, 0,8,41, 0,9,179,
+                                    0,8,9, 0,8,137, 0,8,73, 0,9,243,
+                                    80,7,4, 0,8,85, 0,8,21, 80,8,258,
+                                    83,7,43, 0,8,117, 0,8,53, 0,9,203,
+                                    81,7,13, 0,8,101, 0,8,37, 0,9,171,
+                                    0,8,5, 0,8,133, 0,8,69, 0,9,235,
+                                    80,7,8, 0,8,93, 0,8,29, 0,9,155,
+                                    84,7,83, 0,8,125, 0,8,61, 0,9,219,
+                                    82,7,23, 0,8,109, 0,8,45, 0,9,187,
+                                    0,8,13, 0,8,141, 0,8,77, 0,9,251,
+                                    80,7,3, 0,8,83, 0,8,19, 85,8,195,
+                                    83,7,35, 0,8,115, 0,8,51, 0,9,199,
+                                    81,7,11, 0,8,99, 0,8,35, 0,9,167,
+                                    0,8,3, 0,8,131, 0,8,67, 0,9,231,
+                                    80,7,7, 0,8,91, 0,8,27, 0,9,151,
+                                    84,7,67, 0,8,123, 0,8,59, 0,9,215,
+                                    82,7,19, 0,8,107, 0,8,43, 0,9,183,
+                                    0,8,11, 0,8,139, 0,8,75, 0,9,247,
+                                    80,7,5, 0,8,87, 0,8,23, 192,8,0,
+                                    83,7,51, 0,8,119, 0,8,55, 0,9,207,
+                                    81,7,15, 0,8,103, 0,8,39, 0,9,175,
+                                    0,8,7, 0,8,135, 0,8,71, 0,9,239,
+                                    80,7,9, 0,8,95, 0,8,31, 0,9,159,
+                                    84,7,99, 0,8,127, 0,8,63, 0,9,223,
+                                    82,7,27, 0,8,111, 0,8,47, 0,9,191,
+                                    0,8,15, 0,8,143, 0,8,79, 0,9,255
+                                };
+        static int[] fixed_td = {
+                                    80,5,1, 87,5,257, 83,5,17, 91,5,4097,
+                                    81,5,5, 89,5,1025, 85,5,65, 93,5,16385,
+                                    80,5,3, 88,5,513, 84,5,33, 92,5,8193,
+                                    82,5,9, 90,5,2049, 86,5,129, 192,5,24577,
+                                    80,5,2, 87,5,385, 83,5,25, 91,5,6145,
+                                    81,5,7, 89,5,1537, 85,5,97, 93,5,24577,
+                                    80,5,4, 88,5,769, 84,5,49, 92,5,12289,
+                                    82,5,13, 90,5,3073, 86,5,193, 192,5,24577
+                                };
+
+        // Tables for deflate from PKZIP's appnote.txt.
+        static int[] cplens = { // Copy lengths for literal codes 257..285
+                                  3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
+                                  35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0
+                              };
+
+        // see note #13 above about 258
+        static int[] cplext = { // Extra bits for literal codes 257..285
+                                  0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,
+                                  3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 112, 112  // 112==invalid
+                              };
+
+        static int[] cpdist = { // Copy offsets for distance codes 0..29
+                                  1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
+                                  257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
+                                  8193, 12289, 16385, 24577
+                              };
+
+        static int[] cpdext = { // Extra bits for distance codes
+                                  0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6,
+                                  7, 7, 8, 8, 9, 9, 10, 10, 11, 11,
+                                  12, 12, 13, 13};
+
+        // If BMAX needs to be larger than 16, then h and x[] should be uLong.
+        const int BMAX=15;         // maximum bit length of any code
+
+        int[] hn = null;  // hufts used in space
+        int[] v = null;   // work area for huft_build 
+        int[] c = null;   // bit length count table
+        int[] r = null;   // table entry for structure assignment
+        int[] u = null;   // table stack
+        int[] x = null;   // bit offsets, then code stack
+
+        private int huft_build(int[] b, // code lengths in bits (all assumed <= BMAX)
+            int bindex, 
+            int n,   // number of codes (assumed <= 288)
+            int s,   // number of simple-valued codes (0..s-1)
+            int[] d, // list of base values for non-simple codes
+            int[] e, // list of extra bits for non-simple codes
+            int[] t, // result: starting table
+            int[] m, // maximum lookup bits, returns actual
+            int[] hp,// space for trees
+            int[] hn,// hufts used in space
+            int[] v  // working area: values in order of bit length
+            ){
+            // Given a list of code lengths and a maximum table size, make a set of
+            // tables to decode that set of codes.  Return Z_OK on success, Z_BUF_ERROR
+            // if the given code set is incomplete (the tables are still built in this
+            // case), Z_DATA_ERROR if the input is invalid (an over-subscribed set of
+            // lengths), or Z_MEM_ERROR if not enough memory.
+
+            int a;                       // counter for codes of length k
+            int f;                       // i repeats in table every f entries
+            int g;                       // maximum code length
+            int h;                       // table level
+            int i;                       // counter, current code
+            int j;                       // counter
+            int k;                       // number of bits in current code
+            int l;                       // bits per table (returned in m)
+            int mask;                    // (1 << w) - 1, to avoid cc -O bug on HP
+            int p;                       // pointer into c[], b[], or v[]
+            int q;                       // points to current table
+            int w;                       // bits before this table == (l * h)
+            int xp;                      // pointer into x
+            int y;                       // number of dummy codes added
+            int z;                       // number of entries in current table
+
+            // Generate counts for each bit length
+
+            p = 0; i = n;
+            do {
+                c[b[bindex+p]]++; p++; i--;   // assume all entries <= BMAX
+            }while(i!=0);
+
+            if(c[0] == n){                // null input--all zero length codes
+                t[0] = -1;
+                m[0] = 0;
+                return Z_OK;
+            }
+
+            // Find minimum and maximum length, bound *m by those
+            l = m[0];
+            for (j = 1; j <= BMAX; j++)
+                if(c[j]!=0) break;
+            k = j;                        // minimum code length
+            if(l < j){
+                l = j;
+            }
+            for (i = BMAX; i!=0; i--){
+                if(c[i]!=0) break;
+            }
+            g = i;                        // maximum code length
+            if(l > i){
+                l = i;
+            }
+            m[0] = l;
+
+            // Adjust last length count to fill out codes, if needed
+            for (y = 1 << j; j < i; j++, y <<= 1){
+                if ((y -= c[j]) < 0){
+                    return Z_DATA_ERROR;
+                }
+            }
+            if ((y -= c[i]) < 0){
+                return Z_DATA_ERROR;
+            }
+            c[i] += y;
+
+            // Generate starting offsets into the value table for each length
+            x[1] = j = 0;
+            p = 1;  xp = 2;
+            while (--i!=0) {                 // note that i == g from above
+                x[xp] = (j += c[p]);
+                xp++;
+                p++;
+            }
+
+            // Make a table of values in order of bit lengths
+            i = 0; p = 0;
+            do {
+                if ((j = b[bindex+p]) != 0){
+                    v[x[j]++] = i;
+                }
+                p++;
+            }
+            while (++i < n);
+            n = x[g];                     // set n to length of v
+
+            // Generate the Huffman codes and for each, make the table entries
+            x[0] = i = 0;                 // first Huffman code is zero
+            p = 0;                        // grab values in bit order
+            h = -1;                       // no tables yet--level -1
+            w = -l;                       // bits decoded == (l * h)
+            u[0] = 0;                     // just to keep compilers happy
+            q = 0;                        // ditto
+            z = 0;                        // ditto
+
+            // go through the bit lengths (k already is bits in shortest code)
+            for (; k <= g; k++){
+                a = c[k];
+                while (a--!=0){
+                    // here i is the Huffman code of length k bits for value *p
+                    // make tables up to required level
+                    while (k > w + l){
+                        h++;
+                        w += l;                 // previous table always l bits
+                        // compute minimum size table less than or equal to l bits
+                        z = g - w;
+                        z = (z > l) ? l : z;        // table size upper limit
+                        if((f=1<<(j=k-w))>a+1){     // try a k-w bit table
+                            // too few codes for k-w bit table
+                            f -= a + 1;               // deduct codes from patterns left
+                            xp = k;
+                            if(j < z){
+                                while (++j < z){        // try smaller tables up to z bits
+                                    if((f <<= 1) <= c[++xp])
+                                        break;              // enough codes to use up j bits
+                                    f -= c[xp];           // else deduct codes from patterns
+                                }
+                            }
+                        }
+                        z = 1 << j;                 // table entries for j-bit table
+
+                        // allocate new table
+                        if (hn[0] + z > MANY){       // (note: doesn't matter for fixed)
+                            return Z_DATA_ERROR;       // overflow of MANY
+                        }
+                        u[h] = q = /*hp+*/ hn[0];   // DEBUG
+                        hn[0] += z;
+ 
+                        // connect to last table, if there is one
+                        if(h!=0){
+                            x[h]=i;           // save pattern for backing up
+                            r[0]=(byte)j;     // bits in this table
+                            r[1]=(byte)l;     // bits to dump before this table
+                            j=i>>(w - l);
+                            r[2] = (int)(q - u[h-1] - j);               // offset to this table
+                            System.Array.Copy(r, 0, hp, (u[h-1]+j)*3, 3); // connect to last table
+                        }
+                        else{
+                            t[0] = q;               // first table is returned result
+                        }
+                    }
+
+                    // set up table entry in r
+                    r[1] = (byte)(k - w);
+                    if (p >= n){
+                        r[0] = 128 + 64;      // out of values--invalid code
+                    }
+                    else if (v[p] < s){
+                        r[0] = (byte)(v[p] < 256 ? 0 : 32 + 64);  // 256 is end-of-block
+                        r[2] = v[p++];          // simple code is just the value
+                    }
+                    else{
+                        r[0]=(byte)(e[v[p]-s]+16+64); // non-simple--look up in lists
+                        r[2]=d[v[p++] - s];
+                    }
+
+                    // fill code-like entries with r
+                    f=1<<(k-w);
+                    for (j=i>>w;j<z;j+=f){
+                        System.Array.Copy(r, 0, hp, (q+j)*3, 3);
+                    }
+
+                    // backwards increment the k-bit code i
+                    for (j = 1 << (k - 1); (i & j)!=0; j >>= 1){
+                        i ^= j;
+                    }
+                    i ^= j;
+
+                    // backup over finished tables
+                    mask = (1 << w) - 1;      // needed on HP, cc -O bug
+                    while ((i & mask) != x[h]){
+                        h--;                    // don't need to update q
+                        w -= l;
+                        mask = (1 << w) - 1;
+                    }
+                }
+            }
+            // Return Z_BUF_ERROR if we were given an incomplete table
+            return y != 0 && g != 1 ? Z_BUF_ERROR : Z_OK;
+        }
+
+        internal int inflate_trees_bits(int[] c,  // 19 code lengths
+            int[] bb, // bits tree desired/actual depth
+            int[] tb, // bits tree result
+            int[] hp, // space for trees
+            ZStream z // for messages
+            ){
+            int result;
+            initWorkArea(19);
+            hn[0]=0;
+            result = huft_build(c, 0, 19, 19, null, null, tb, bb, hp, hn, v);
+
+            if(result == Z_DATA_ERROR){
+                z.msg = "oversubscribed dynamic bit lengths tree";
+            }
+            else if(result == Z_BUF_ERROR || bb[0] == 0){
+                z.msg = "incomplete dynamic bit lengths tree";
+                result = Z_DATA_ERROR;
+            }
+            return result;
+        }
+
+        internal int inflate_trees_dynamic(int nl,   // number of literal/length codes
+            int nd,   // number of distance codes
+            int[] c,  // that many (total) code lengths
+            int[] bl, // literal desired/actual bit depth
+            int[] bd, // distance desired/actual bit depth 
+            int[] tl, // literal/length tree result
+            int[] td, // distance tree result
+            int[] hp, // space for trees
+            ZStream z // for messages
+            ){
+            int result;
+
+            // build literal/length tree
+            initWorkArea(288);
+            hn[0]=0;
+            result = huft_build(c, 0, nl, 257, cplens, cplext, tl, bl, hp, hn, v);
+            if (result != Z_OK || bl[0] == 0){
+                if(result == Z_DATA_ERROR){
+                    z.msg = "oversubscribed literal/length tree";
+                }
+                else if (result != Z_MEM_ERROR){
+                    z.msg = "incomplete literal/length tree";
+                    result = Z_DATA_ERROR;
+                }
+                return result;
+            }
+
+            // build distance tree
+            initWorkArea(288);
+            result = huft_build(c, nl, nd, 0, cpdist, cpdext, td, bd, hp, hn, v);
+
+            if (result != Z_OK || (bd[0] == 0 && nl > 257)){
+                if (result == Z_DATA_ERROR){
+                    z.msg = "oversubscribed distance tree";
+                }
+                else if (result == Z_BUF_ERROR) {
+                    z.msg = "incomplete distance tree";
+                    result = Z_DATA_ERROR;
+                }
+                else if (result != Z_MEM_ERROR){
+                    z.msg = "empty distance tree with lengths";
+                    result = Z_DATA_ERROR;
+                }
+                return result;
+            }
+
+            return Z_OK;
+        }
+
+        internal static int inflate_trees_fixed(int[] bl,  //literal desired/actual bit depth
+            int[] bd,  //distance desired/actual bit depth
+            int[][] tl,//literal/length tree result
+            int[][] td,//distance tree result 
+            ZStream z  //for memory allocation
+            ){
+            bl[0]=fixed_bl;
+            bd[0]=fixed_bd;
+            tl[0]=fixed_tl;
+            td[0]=fixed_td;
+            return Z_OK;
+        }
+
+        private void initWorkArea(int vsize){
+            if(hn==null){
+                hn=new int[1];
+                v=new int[vsize];
+                c=new int[BMAX+1];
+                r=new int[3];
+                u=new int[BMAX];
+                x=new int[BMAX+1];
+            }
+            if(v.Length<vsize){ v=new int[vsize]; }
+            for(int i=0; i<vsize; i++){v[i]=0;}
+            for(int i=0; i<BMAX+1; i++){c[i]=0;}
+            for(int i=0; i<3; i++){r[i]=0;}
+            //  for(int i=0; i<BMAX; i++){u[i]=0;}
+            System.Array.Copy(c, 0, u, 0, BMAX);
+            //  for(int i=0; i<BMAX+1; i++){x[i]=0;}
+            System.Array.Copy(c, 0, x, 0, BMAX+1);
+        }
+    }
+}

src/core/System/util/zlib/Inflate.cs

@@ -0,0 +1,387 @@
+using System;
+/*
+ * $Id: Inflate.cs,v 1.1 2006/06/16 10:56:20 psoares33 Exp $
+ *
+Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+  1. Redistributions of source code must retain the above copyright notice,
+     this list of conditions and the following disclaimer.
+
+  2. Redistributions in binary form must reproduce the above copyright 
+     notice, this list of conditions and the following disclaimer in 
+     the documentation and/or other materials provided with the distribution.
+
+  3. The names of the authors may not be used to endorse or promote products
+     derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
+INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
+INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/*
+ * This program is based on zlib-1.1.3, so all credit should go authors
+ * Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu)
+ * and contributors of zlib.
+ */
+
+namespace System.util.zlib {
+
+    internal sealed class Inflate{
+  
+        private const int MAX_WBITS=15; // 32K LZ77 window
+
+        // preset dictionary flag in zlib header
+        private const int PRESET_DICT=0x20;
+
+        internal const int Z_NO_FLUSH=0;
+        internal const int Z_PARTIAL_FLUSH=1;
+        internal const int Z_SYNC_FLUSH=2;
+        internal const int Z_FULL_FLUSH=3;
+        internal const int Z_FINISH=4;
+
+        private const int Z_DEFLATED=8;
+
+        private const int Z_OK=0;
+        private const int Z_STREAM_END=1;
+        private const int Z_NEED_DICT=2;
+        private const int Z_ERRNO=-1;
+        private const int Z_STREAM_ERROR=-2;
+        private const int Z_DATA_ERROR=-3;
+        private const int Z_MEM_ERROR=-4;
+        private const int Z_BUF_ERROR=-5;
+        private const int Z_VERSION_ERROR=-6;
+
+        private const int METHOD=0;   // waiting for method byte
+        private const int FLAG=1;     // waiting for flag byte
+        private const int DICT4=2;    // four dictionary check bytes to go
+        private const int DICT3=3;    // three dictionary check bytes to go
+        private const int DICT2=4;    // two dictionary check bytes to go
+        private const int DICT1=5;    // one dictionary check byte to go
+        private const int DICT0=6;    // waiting for inflateSetDictionary
+        private const int BLOCKS=7;   // decompressing blocks
+        private const int CHECK4=8;   // four check bytes to go
+        private const int CHECK3=9;   // three check bytes to go
+        private const int CHECK2=10;  // two check bytes to go
+        private const int CHECK1=11;  // one check byte to go
+        private const int DONE=12;    // finished check, done
+        private const int BAD=13;     // got an error--stay here
+
+        internal int mode;                            // current inflate mode
+
+        // mode dependent information
+        internal int method;        // if FLAGS, method byte
+
+        // if CHECK, check values to compare
+        internal long[] was=new long[1] ; // computed check value
+        internal long need;               // stream check value
+
+        // if BAD, inflateSync's marker bytes count
+        internal int marker;
+
+        // mode independent information
+        internal int  nowrap;          // flag for no wrapper
+        internal int wbits;            // log2(window size)  (8..15, defaults to 15)
+
+        internal InfBlocks blocks;     // current inflate_blocks state
+
+        internal int inflateReset(ZStream z){
+            if(z == null || z.istate == null) return Z_STREAM_ERROR;
+    
+            z.total_in = z.total_out = 0;
+            z.msg = null;
+            z.istate.mode = z.istate.nowrap!=0 ? BLOCKS : METHOD;
+            z.istate.blocks.reset(z, null);
+            return Z_OK;
+        }
+
+        internal int inflateEnd(ZStream z){
+            if(blocks != null)
+                blocks.free(z);
+            blocks=null;
+            //    ZFREE(z, z->state);
+            return Z_OK;
+        }
+
+        internal int inflateInit(ZStream z, int w){
+            z.msg = null;
+            blocks = null;
+
+            // handle undocumented nowrap option (no zlib header or check)
+            nowrap = 0;
+            if(w < 0){
+                w = - w;
+                nowrap = 1;
+            }
+
+            // set window size
+            if(w<8 ||w>15){
+                inflateEnd(z);
+                return Z_STREAM_ERROR;
+            }
+            wbits=w;
+
+            z.istate.blocks=new InfBlocks(z, 
+                z.istate.nowrap!=0 ? null : this,
+                1<<w);
+
+            // reset state
+            inflateReset(z);
+            return Z_OK;
+        }
+
+        internal int inflate(ZStream z, int f){
+            int r;
+            int b;
+
+            if(z == null || z.istate == null || z.next_in == null)
+                return Z_STREAM_ERROR;
+            f = f == Z_FINISH ? Z_BUF_ERROR : Z_OK;
+            r = Z_BUF_ERROR;
+            while (true){
+                //System.out.println("mode: "+z.istate.mode);
+                switch (z.istate.mode){
+                    case METHOD:
+
+                        if(z.avail_in==0)return r;r=f;
+
+                        z.avail_in--; z.total_in++;
+                        if(((z.istate.method = z.next_in[z.next_in_index++])&0xf)!=Z_DEFLATED){
+                            z.istate.mode = BAD;
+                            z.msg="unknown compression method";
+                            z.istate.marker = 5;       // can't try inflateSync
+                            break;
+                        }
+                        if((z.istate.method>>4)+8>z.istate.wbits){
+                            z.istate.mode = BAD;
+                            z.msg="invalid window size";
+                            z.istate.marker = 5;       // can't try inflateSync
+                            break;
+                        }
+                        z.istate.mode=FLAG;
+                        goto case FLAG;
+                    case FLAG:
+
+                        if(z.avail_in==0)return r;r=f;
+
+                        z.avail_in--; z.total_in++;
+                        b = (z.next_in[z.next_in_index++])&0xff;
+
+                        if((((z.istate.method << 8)+b) % 31)!=0){
+                            z.istate.mode = BAD;
+                            z.msg = "incorrect header check";
+                            z.istate.marker = 5;       // can't try inflateSync
+                            break;
+                        }
+
+                        if((b&PRESET_DICT)==0){
+                            z.istate.mode = BLOCKS;
+                            break;
+                        }
+                        z.istate.mode = DICT4;
+                        goto case DICT4;
+                    case DICT4:
+
+                        if(z.avail_in==0)return r;r=f;
+
+                        z.avail_in--; z.total_in++;
+                        z.istate.need=((z.next_in[z.next_in_index++]&0xff)<<24)&0xff000000L;
+                        z.istate.mode=DICT3;
+                        goto case DICT3;
+                    case DICT3:
+
+                        if(z.avail_in==0)return r;r=f;
+
+                        z.avail_in--; z.total_in++;
+                        z.istate.need+=((z.next_in[z.next_in_index++]&0xff)<<16)&0xff0000L;
+                        z.istate.mode=DICT2;
+                        goto case DICT2;
+                    case DICT2:
+
+                        if(z.avail_in==0)return r;r=f;
+
+                        z.avail_in--; z.total_in++;
+                        z.istate.need+=((z.next_in[z.next_in_index++]&0xff)<<8)&0xff00L;
+                        z.istate.mode=DICT1;
+                        goto case DICT1;
+                    case DICT1:
+
+                        if(z.avail_in==0)return r;r=f;
+
+                        z.avail_in--; z.total_in++;
+                        z.istate.need += (z.next_in[z.next_in_index++]&0xffL);
+                        z.adler = z.istate.need;
+                        z.istate.mode = DICT0;
+                        return Z_NEED_DICT;
+                    case DICT0:
+                        z.istate.mode = BAD;
+                        z.msg = "need dictionary";
+                        z.istate.marker = 0;       // can try inflateSync
+                        return Z_STREAM_ERROR;
+                    case BLOCKS:
+
+                        r = z.istate.blocks.proc(z, r);
+                        if(r == Z_DATA_ERROR){
+                            z.istate.mode = BAD;
+                            z.istate.marker = 0;     // can try inflateSync
+                            break;
+                        }
+                        if(r == Z_OK){
+                            r = f;
+                        }
+                        if(r != Z_STREAM_END){
+                            return r;
+                        }
+                        r = f;
+                        z.istate.blocks.reset(z, z.istate.was);
+                        if(z.istate.nowrap!=0){
+                            z.istate.mode=DONE;
+                            break;
+                        }
+                        z.istate.mode=CHECK4;
+                        goto case CHECK4;
+                    case CHECK4:
+
+                        if(z.avail_in==0)return r;r=f;
+
+                        z.avail_in--; z.total_in++;
+                        z.istate.need=((z.next_in[z.next_in_index++]&0xff)<<24)&0xff000000L;
+                        z.istate.mode=CHECK3;
+                        goto case CHECK3;
+                    case CHECK3:
+
+                        if(z.avail_in==0)return r;r=f;
+
+                        z.avail_in--; z.total_in++;
+                        z.istate.need+=((z.next_in[z.next_in_index++]&0xff)<<16)&0xff0000L;
+                        z.istate.mode = CHECK2;
+                        goto case CHECK2;
+                    case CHECK2:
+
+                        if(z.avail_in==0)return r;r=f;
+
+                        z.avail_in--; z.total_in++;
+                        z.istate.need+=((z.next_in[z.next_in_index++]&0xff)<<8)&0xff00L;
+                        z.istate.mode = CHECK1;
+                        goto case CHECK1;
+                    case CHECK1:
+
+                        if(z.avail_in==0)return r;r=f;
+
+                        z.avail_in--; z.total_in++;
+                        z.istate.need+=(z.next_in[z.next_in_index++]&0xffL);
+
+                        if(((int)(z.istate.was[0])) != ((int)(z.istate.need))){
+                            z.istate.mode = BAD;
+                            z.msg = "incorrect data check";
+                            z.istate.marker = 5;       // can't try inflateSync
+                            break;
+                        }
+
+                        z.istate.mode = DONE;
+                        goto case DONE;
+                    case DONE:
+                        return Z_STREAM_END;
+                    case BAD:
+                        return Z_DATA_ERROR;
+                    default:
+                        return Z_STREAM_ERROR;
+                }
+            }
+        }
+
+
+        internal int inflateSetDictionary(ZStream z, byte[] dictionary, int dictLength){
+            int index=0;
+            int length = dictLength;
+            if(z==null || z.istate == null|| z.istate.mode != DICT0)
+                return Z_STREAM_ERROR;
+
+            if(z._adler.adler32(1L, dictionary, 0, dictLength)!=z.adler){
+                return Z_DATA_ERROR;
+            }
+
+            z.adler = z._adler.adler32(0, null, 0, 0);
+
+            if(length >= (1<<z.istate.wbits)){
+                length = (1<<z.istate.wbits)-1;
+                index=dictLength - length;
+            }
+            z.istate.blocks.set_dictionary(dictionary, index, length);
+            z.istate.mode = BLOCKS;
+            return Z_OK;
+        }
+
+        static private byte[] mark = {(byte)0, (byte)0, (byte)0xff, (byte)0xff};
+
+        internal int inflateSync(ZStream z){
+            int n;       // number of bytes to look at
+            int p;       // pointer to bytes
+            int m;       // number of marker bytes found in a row
+            long r, w;   // temporaries to save total_in and total_out
+
+            // set up
+            if(z == null || z.istate == null)
+                return Z_STREAM_ERROR;
+            if(z.istate.mode != BAD){
+                z.istate.mode = BAD;
+                z.istate.marker = 0;
+            }
+            if((n=z.avail_in)==0)
+                return Z_BUF_ERROR;
+            p=z.next_in_index;
+            m=z.istate.marker;
+
+            // search
+            while (n!=0 && m < 4){
+                if(z.next_in[p] == mark[m]){
+                    m++;
+                }
+                else if(z.next_in[p]!=0){
+                    m = 0;
+                }
+                else{
+                    m = 4 - m;
+                }
+                p++; n--;
+            }
+
+            // restore
+            z.total_in += p-z.next_in_index;
+            z.next_in_index = p;
+            z.avail_in = n;
+            z.istate.marker = m;
+
+            // return no joy or set up to restart on a new block
+            if(m != 4){
+                return Z_DATA_ERROR;
+            }
+            r=z.total_in;  w=z.total_out;
+            inflateReset(z);
+            z.total_in=r;  z.total_out = w;
+            z.istate.mode = BLOCKS;
+            return Z_OK;
+        }
+
+        // Returns true if inflate is currently at the end of a block generated
+        // by Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP
+        // implementation to provide an additional safety check. PPP uses Z_SYNC_FLUSH
+        // but removes the length bytes of the resulting empty stored block. When
+        // decompressing, PPP checks that at the end of input packet, inflate is
+        // waiting for these length bytes.
+        internal int inflateSyncPoint(ZStream z){
+            if(z == null || z.istate == null || z.istate.blocks == null)
+                return Z_STREAM_ERROR;
+            return z.istate.blocks.sync_point();
+        }
+    }
+}

src/core/System/util/zlib/JZlib.cs

@@ -0,0 +1,70 @@
+using System;
+/*
+ * $Id: JZlib.cs,v 1.1 2006/06/16 10:56:20 psoares33 Exp $
+ *
+Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+  1. Redistributions of source code must retain the above copyright notice,
+     this list of conditions and the following disclaimer.
+
+  2. Redistributions in binary form must reproduce the above copyright 
+     notice, this list of conditions and the following disclaimer in 
+     the documentation and/or other materials provided with the distribution.
+
+  3. The names of the authors may not be used to endorse or promote products
+     derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
+INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
+INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/*
+ * This program is based on zlib-1.1.3, so all credit should go authors
+ * Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu)
+ * and contributors of zlib.
+ */
+
+namespace System.util.zlib {
+
+    public sealed class JZlib{
+        private const String version_="1.0.2";
+        public static String version(){return version_;}
+
+        // compression levels
+        public const int Z_NO_COMPRESSION=0;
+        public const int Z_BEST_SPEED=1;
+        public const int Z_BEST_COMPRESSION=9;
+        public const int Z_DEFAULT_COMPRESSION=(-1);
+
+        // compression strategy
+        public const int Z_FILTERED=1;
+        public const int Z_HUFFMAN_ONLY=2;
+        public const int Z_DEFAULT_STRATEGY=0;
+
+        public const int Z_NO_FLUSH=0;
+        public const int Z_PARTIAL_FLUSH=1;
+        public const int Z_SYNC_FLUSH=2;
+        public const int Z_FULL_FLUSH=3;
+        public const int Z_FINISH=4;
+
+        public const int Z_OK=0;
+        public const int Z_STREAM_END=1;
+        public const int Z_NEED_DICT=2;
+        public const int Z_ERRNO=-1;
+        public const int Z_STREAM_ERROR=-2;
+        public const int Z_DATA_ERROR=-3;
+        public const int Z_MEM_ERROR=-4;
+        public const int Z_BUF_ERROR=-5;
+        public const int Z_VERSION_ERROR=-6;
+    }
+}

src/core/System/util/zlib/StaticTree.cs

@@ -0,0 +1,152 @@
+using System;
+/*
+ * $Id: StaticTree.cs,v 1.1 2006/06/16 10:56:20 psoares33 Exp $
+ *
+Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+  1. Redistributions of source code must retain the above copyright notice,
+     this list of conditions and the following disclaimer.
+
+  2. Redistributions in binary form must reproduce the above copyright 
+     notice, this list of conditions and the following disclaimer in 
+     the documentation and/or other materials provided with the distribution.
+
+  3. The names of the authors may not be used to endorse or promote products
+     derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
+INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
+INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/*
+ * This program is based on zlib-1.1.3, so all credit should go authors
+ * Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu)
+ * and contributors of zlib.
+ */
+
+namespace System.util.zlib {
+
+    internal sealed class StaticTree{
+        private const int MAX_BITS=15;
+
+        private const int BL_CODES=19;
+        private const int D_CODES=30;
+        private const int LITERALS=256;
+        private const int LENGTH_CODES=29;
+        private const int L_CODES=(LITERALS+1+LENGTH_CODES);
+
+        // Bit length codes must not exceed MAX_BL_BITS bits
+        internal const int MAX_BL_BITS=7; 
+
+        internal static short[] static_ltree = {
+                                                   12,  8, 140,  8,  76,  8, 204,  8,  44,  8,
+                                                   172,  8, 108,  8, 236,  8,  28,  8, 156,  8,
+                                                   92,  8, 220,  8,  60,  8, 188,  8, 124,  8,
+                                                   252,  8,   2,  8, 130,  8,  66,  8, 194,  8,
+                                                   34,  8, 162,  8,  98,  8, 226,  8,  18,  8,
+                                                   146,  8,  82,  8, 210,  8,  50,  8, 178,  8,
+                                                   114,  8, 242,  8,  10,  8, 138,  8,  74,  8,
+                                                   202,  8,  42,  8, 170,  8, 106,  8, 234,  8,
+                                                   26,  8, 154,  8,  90,  8, 218,  8,  58,  8,
+                                                   186,  8, 122,  8, 250,  8,   6,  8, 134,  8,
+                                                   70,  8, 198,  8,  38,  8, 166,  8, 102,  8,
+                                                   230,  8,  22,  8, 150,  8,  86,  8, 214,  8,
+                                                   54,  8, 182,  8, 118,  8, 246,  8,  14,  8,
+                                                   142,  8,  78,  8, 206,  8,  46,  8, 174,  8,
+                                                   110,  8, 238,  8,  30,  8, 158,  8,  94,  8,
+                                                   222,  8,  62,  8, 190,  8, 126,  8, 254,  8,
+                                                   1,  8, 129,  8,  65,  8, 193,  8,  33,  8,
+                                                   161,  8,  97,  8, 225,  8,  17,  8, 145,  8,
+                                                   81,  8, 209,  8,  49,  8, 177,  8, 113,  8,
+                                                   241,  8,   9,  8, 137,  8,  73,  8, 201,  8,
+                                                   41,  8, 169,  8, 105,  8, 233,  8,  25,  8,
+                                                   153,  8,  89,  8, 217,  8,  57,  8, 185,  8,
+                                                   121,  8, 249,  8,   5,  8, 133,  8,  69,  8,
+                                                   197,  8,  37,  8, 165,  8, 101,  8, 229,  8,
+                                                   21,  8, 149,  8,  85,  8, 213,  8,  53,  8,
+                                                   181,  8, 117,  8, 245,  8,  13,  8, 141,  8,
+                                                   77,  8, 205,  8,  45,  8, 173,  8, 109,  8,
+                                                   237,  8,  29,  8, 157,  8,  93,  8, 221,  8,
+                                                   61,  8, 189,  8, 125,  8, 253,  8,  19,  9,
+                                                   275,  9, 147,  9, 403,  9,  83,  9, 339,  9,
+                                                   211,  9, 467,  9,  51,  9, 307,  9, 179,  9,
+                                                   435,  9, 115,  9, 371,  9, 243,  9, 499,  9,
+                                                   11,  9, 267,  9, 139,  9, 395,  9,  75,  9,
+                                                   331,  9, 203,  9, 459,  9,  43,  9, 299,  9,
+                                                   171,  9, 427,  9, 107,  9, 363,  9, 235,  9,
+                                                   491,  9,  27,  9, 283,  9, 155,  9, 411,  9,
+                                                   91,  9, 347,  9, 219,  9, 475,  9,  59,  9,
+                                                   315,  9, 187,  9, 443,  9, 123,  9, 379,  9,
+                                                   251,  9, 507,  9,   7,  9, 263,  9, 135,  9,
+                                                   391,  9,  71,  9, 327,  9, 199,  9, 455,  9,
+                                                   39,  9, 295,  9, 167,  9, 423,  9, 103,  9,
+                                                   359,  9, 231,  9, 487,  9,  23,  9, 279,  9,
+                                                   151,  9, 407,  9,  87,  9, 343,  9, 215,  9,
+                                                   471,  9,  55,  9, 311,  9, 183,  9, 439,  9,
+                                                   119,  9, 375,  9, 247,  9, 503,  9,  15,  9,
+                                                   271,  9, 143,  9, 399,  9,  79,  9, 335,  9,
+                                                   207,  9, 463,  9,  47,  9, 303,  9, 175,  9,
+                                                   431,  9, 111,  9, 367,  9, 239,  9, 495,  9,
+                                                   31,  9, 287,  9, 159,  9, 415,  9,  95,  9,
+                                                   351,  9, 223,  9, 479,  9,  63,  9, 319,  9,
+                                                   191,  9, 447,  9, 127,  9, 383,  9, 255,  9,
+                                                   511,  9,   0,  7,  64,  7,  32,  7,  96,  7,
+                                                   16,  7,  80,  7,  48,  7, 112,  7,   8,  7,
+                                                   72,  7,  40,  7, 104,  7,  24,  7,  88,  7,
+                                                   56,  7, 120,  7,   4,  7,  68,  7,  36,  7,
+                                                   100,  7,  20,  7,  84,  7,  52,  7, 116,  7,
+                                                   3,  8, 131,  8,  67,  8, 195,  8,  35,  8,
+                                                   163,  8,  99,  8, 227,  8
+                                               };
+
+        internal static short[] static_dtree = {
+                                                   0, 5, 16, 5,  8, 5, 24, 5,  4, 5,
+                                                   20, 5, 12, 5, 28, 5,  2, 5, 18, 5,
+                                                   10, 5, 26, 5,  6, 5, 22, 5, 14, 5,
+                                                   30, 5,  1, 5, 17, 5,  9, 5, 25, 5,
+                                                   5, 5, 21, 5, 13, 5, 29, 5,  3, 5,
+                                                   19, 5, 11, 5, 27, 5,  7, 5, 23, 5
+                                               };
+
+        internal static StaticTree static_l_desc =
+            new StaticTree(static_ltree, Tree.extra_lbits,
+            LITERALS+1, L_CODES, MAX_BITS);
+
+        internal static StaticTree static_d_desc =
+            new StaticTree(static_dtree, Tree.extra_dbits,
+            0,  D_CODES, MAX_BITS);
+
+        internal static StaticTree static_bl_desc =
+            new StaticTree(null, Tree.extra_blbits,
+            0, BL_CODES, MAX_BL_BITS);
+
+        internal short[] static_tree;     // static tree or null
+        internal int[] extra_bits;        // extra bits for each code or null
+        internal int extra_base;          // base index for extra_bits
+        internal int elems;               // max number of elements in the tree
+        internal int max_length;          // max bit length for the codes
+
+        internal StaticTree(short[] static_tree,
+            int[] extra_bits,
+            int extra_base,
+            int elems,
+            int max_length
+            ){
+            this.static_tree=static_tree;
+            this.extra_bits=extra_bits;
+            this.extra_base=extra_base;
+            this.elems=elems;
+            this.max_length=max_length;
+        }
+    }
+}

src/core/System/util/zlib/Tree.cs

@@ -0,0 +1,367 @@
+using System;
+/*
+ * $Id: Tree.cs,v 1.2 2006/07/31 14:30:59 psoares33 Exp $
+ *
+Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+  1. Redistributions of source code must retain the above copyright notice,
+     this list of conditions and the following disclaimer.
+
+  2. Redistributions in binary form must reproduce the above copyright 
+     notice, this list of conditions and the following disclaimer in 
+     the documentation and/or other materials provided with the distribution.
+
+  3. The names of the authors may not be used to endorse or promote products
+     derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
+INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
+INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/*
+ * This program is based on zlib-1.1.3, so all credit should go authors
+ * Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu)
+ * and contributors of zlib.
+ */
+
+namespace System.util.zlib {
+
+    internal sealed class Tree{
+        private const int MAX_BITS=15;
+        private const int BL_CODES=19;
+        private const int D_CODES=30;
+        private const int LITERALS=256;
+        private const int LENGTH_CODES=29;
+        private const int L_CODES=(LITERALS+1+LENGTH_CODES);
+        private const int HEAP_SIZE=(2*L_CODES+1);
+
+        // Bit length codes must not exceed MAX_BL_BITS bits
+        internal const int MAX_BL_BITS=7; 
+
+        // end of block literal code
+        internal const int END_BLOCK=256; 
+
+        // repeat previous bit length 3-6 times (2 bits of repeat count)
+        internal const int REP_3_6=16; 
+
+        // repeat a zero length 3-10 times  (3 bits of repeat count)
+        internal const int REPZ_3_10=17; 
+
+        // repeat a zero length 11-138 times  (7 bits of repeat count)
+        internal const int REPZ_11_138=18; 
+
+        // extra bits for each length code
+        internal static int[] extra_lbits={
+                                             0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0
+                                         };
+
+        // extra bits for each distance code
+        internal static int[] extra_dbits={
+                                             0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13
+                                         };
+
+        // extra bits for each bit length code
+        internal static int[] extra_blbits={
+                                              0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7
+                                          };
+
+        internal static byte[] bl_order={
+                                            16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15};
+
+
+        // The lengths of the bit length codes are sent in order of decreasing
+        // probability, to avoid transmitting the lengths for unused bit
+        // length codes.
+
+        internal const int Buf_size=8*2;
+
+        // see definition of array dist_code below
+        internal const int DIST_CODE_LEN=512;
+
+        internal static byte[] _dist_code = {
+                                                0,  1,  2,  3,  4,  4,  5,  5,  6,  6,  6,  6,  7,  7,  7,  7,  8,  8,  8,  8,
+                                                8,  8,  8,  8,  9,  9,  9,  9,  9,  9,  9,  9, 10, 10, 10, 10, 10, 10, 10, 10,
+                                                10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+                                                11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+                                                12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13,
+                                                13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+                                                13, 13, 13, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+                                                14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+                                                14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+                                                14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15,
+                                                15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+                                                15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+                                                15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,  0,  0, 16, 17,
+                                                18, 18, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22,
+                                                23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+                                                24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
+                                                26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
+                                                26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27,
+                                                27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+                                                27, 27, 27, 27, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+                                                28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+                                                28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+                                                28, 28, 28, 28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+                                                29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+                                                29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+                                                29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29
+                                            };
+
+        internal static byte[] _length_code={
+                                                0,  1,  2,  3,  4,  5,  6,  7,  8,  8,  9,  9, 10, 10, 11, 11, 12, 12, 12, 12,
+                                                13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16,
+                                                17, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19,
+                                                19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
+                                                21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22,
+                                                22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23,
+                                                23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+                                                24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+                                                25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
+                                                25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26, 26,
+                                                26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
+                                                26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+                                                27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28
+                                            };
+
+        internal static int[] base_length = {
+                                               0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 20, 24, 28, 32, 40, 48, 56,
+                                               64, 80, 96, 112, 128, 160, 192, 224, 0
+                                           };
+
+        internal static int[] base_dist = {
+                                             0,   1,      2,     3,     4,    6,     8,    12,    16,     24,
+                                             32,  48,     64,    96,   128,  192,   256,   384,   512,    768,
+                                             1024, 1536,  2048,  3072,  4096,  6144,  8192, 12288, 16384, 24576
+                                         };
+
+        // Mapping from a distance to a distance code. dist is the distance - 1 and
+        // must not have side effects. _dist_code[256] and _dist_code[257] are never
+        // used.
+        internal static int d_code(int dist){
+            return ((dist) < 256 ? _dist_code[dist] : _dist_code[256+((dist)>>7)]);
+        }
+
+        internal short[] dyn_tree;      // the dynamic tree
+        internal int     max_code;      // largest code with non zero frequency
+        internal StaticTree stat_desc;  // the corresponding static tree
+
+        // Compute the optimal bit lengths for a tree and update the total bit length
+        // for the current block.
+        // IN assertion: the fields freq and dad are set, heap[heap_max] and
+        //    above are the tree nodes sorted by increasing frequency.
+        // OUT assertions: the field len is set to the optimal bit length, the
+        //     array bl_count contains the frequencies for each bit length.
+        //     The length opt_len is updated; static_len is also updated if stree is
+        //     not null.
+        internal void gen_bitlen(Deflate s){
+            short[] tree = dyn_tree;
+            short[] stree = stat_desc.static_tree;
+            int[] extra = stat_desc.extra_bits;
+            int based = stat_desc.extra_base;
+            int max_length = stat_desc.max_length;
+            int h;              // heap index
+            int n, m;           // iterate over the tree elements
+            int bits;           // bit length
+            int xbits;          // extra bits
+            short f;            // frequency
+            int overflow = 0;   // number of elements with bit length too large
+
+            for (bits = 0; bits <= MAX_BITS; bits++) s.bl_count[bits] = 0;
+
+            // In a first pass, compute the optimal bit lengths (which may
+            // overflow in the case of the bit length tree).
+            tree[s.heap[s.heap_max]*2+1] = 0; // root of the heap
+
+            for(h=s.heap_max+1; h<HEAP_SIZE; h++){
+                n = s.heap[h];
+                bits = tree[tree[n*2+1]*2+1] + 1;
+                if (bits > max_length){ bits = max_length; overflow++; }
+                tree[n*2+1] = (short)bits;
+                // We overwrite tree[n*2+1] which is no longer needed
+
+                if (n > max_code) continue;  // not a leaf node
+
+                s.bl_count[bits]++;
+                xbits = 0;
+                if (n >= based) xbits = extra[n-based];
+                f = tree[n*2];
+                s.opt_len += f * (bits + xbits);
+                if (stree!=null) s.static_len += f * (stree[n*2+1] + xbits);
+            }
+            if (overflow == 0) return;
+
+            // This happens for example on obj2 and pic of the Calgary corpus
+            // Find the first bit length which could increase:
+            do {
+                bits = max_length-1;
+            while(s.bl_count[bits]==0) bits--;
+                s.bl_count[bits]--;      // move one leaf down the tree
+                s.bl_count[bits+1]+=2;   // move one overflow item as its brother
+                s.bl_count[max_length]--;
+                // The brother of the overflow item also moves one step up,
+                // but this does not affect bl_count[max_length]
+                overflow -= 2;
+            }
+            while (overflow > 0);
+
+            for (bits = max_length; bits != 0; bits--) {
+                n = s.bl_count[bits];
+                while (n != 0) {
+                    m = s.heap[--h];
+                    if (m > max_code) continue;
+                    if (tree[m*2+1] != bits) {
+                        s.opt_len += (int)(((long)bits - (long)tree[m*2+1])*(long)tree[m*2]);
+                        tree[m*2+1] = (short)bits;
+                    }
+                    n--;
+                }
+            }
+        }
+
+        // Construct one Huffman tree and assigns the code bit strings and lengths.
+        // Update the total bit length for the current block.
+        // IN assertion: the field freq is set for all tree elements.
+        // OUT assertions: the fields len and code are set to the optimal bit length
+        //     and corresponding code. The length opt_len is updated; static_len is
+        //     also updated if stree is not null. The field max_code is set.
+        internal void build_tree(Deflate s){
+            short[] tree=dyn_tree;
+            short[] stree=stat_desc.static_tree;
+            int elems=stat_desc.elems;
+            int n, m;          // iterate over heap elements
+            int max_code=-1;   // largest code with non zero frequency
+            int node;          // new node being created
+
+            // Construct the initial heap, with least frequent element in
+            // heap[1]. The sons of heap[n] are heap[2*n] and heap[2*n+1].
+            // heap[0] is not used.
+            s.heap_len = 0;
+            s.heap_max = HEAP_SIZE;
+
+            for(n=0; n<elems; n++) {
+                if(tree[n*2] != 0) {
+                    s.heap[++s.heap_len] = max_code = n;
+                    s.depth[n] = 0;
+                }
+                else{
+                    tree[n*2+1] = 0;
+                }
+            }
+
+            // The pkzip format requires that at least one distance code exists,
+            // and that at least one bit should be sent even if there is only one
+            // possible code. So to avoid special checks later on we force at least
+            // two codes of non zero frequency.
+            while (s.heap_len < 2) {
+                node = s.heap[++s.heap_len] = (max_code < 2 ? ++max_code : 0);
+                tree[node*2] = 1;
+                s.depth[node] = 0;
+                s.opt_len--; if (stree!=null) s.static_len -= stree[node*2+1];
+                // node is 0 or 1 so it does not have extra bits
+            }
+            this.max_code = max_code;
+
+            // The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree,
+            // establish sub-heaps of increasing lengths:
+
+            for(n=s.heap_len/2;n>=1; n--)
+                s.pqdownheap(tree, n);
+
+            // Construct the Huffman tree by repeatedly combining the least two
+            // frequent nodes.
+
+            node=elems;                 // next internal node of the tree
+            do{
+                // n = node of least frequency
+                n=s.heap[1];
+                s.heap[1]=s.heap[s.heap_len--];
+                s.pqdownheap(tree, 1);
+                m=s.heap[1];                // m = node of next least frequency
+
+                s.heap[--s.heap_max] = n; // keep the nodes sorted by frequency
+                s.heap[--s.heap_max] = m;
+
+                // Create a new node father of n and m
+                tree[node*2] = (short)(tree[n*2] + tree[m*2]);
+                s.depth[node] = (byte)(System.Math.Max(s.depth[n],s.depth[m])+1);
+                tree[n*2+1] = tree[m*2+1] = (short)node;
+
+                // and insert the new node in the heap
+                s.heap[1] = node++;
+                s.pqdownheap(tree, 1);
+            }
+            while(s.heap_len>=2);
+
+            s.heap[--s.heap_max] = s.heap[1];
+
+            // At this point, the fields freq and dad are set. We can now
+            // generate the bit lengths.
+
+            gen_bitlen(s);
+
+            // The field len is now set, we can generate the bit codes
+            gen_codes(tree, max_code, s.bl_count);
+        }
+
+        // Generate the codes for a given tree and bit counts (which need not be
+        // optimal).
+        // IN assertion: the array bl_count contains the bit length statistics for
+        // the given tree and the field len is set for all tree elements.
+        // OUT assertion: the field code is set for all tree elements of non
+        //     zero code length.
+        internal static void gen_codes(short[] tree, // the tree to decorate
+            int max_code, // largest code with non zero frequency
+            short[] bl_count // number of codes at each bit length
+            ){
+            short[] next_code=new short[MAX_BITS+1]; // next code value for each bit length
+            short code = 0;            // running code value
+            int bits;                  // bit index
+            int n;                     // code index
+
+            // The distribution counts are first used to generate the code values
+            // without bit reversal.
+            for (bits = 1; bits <= MAX_BITS; bits++) {
+                next_code[bits] = code = (short)((code + bl_count[bits-1]) << 1);
+            }
+
+            // Check that the bit counts in bl_count are consistent. The last code
+            // must be all ones.
+            //Assert (code + bl_count[MAX_BITS]-1 == (1<<MAX_BITS)-1,
+            //        "inconsistent bit counts");
+            //Tracev((stderr,"\ngen_codes: max_code %d ", max_code));
+
+            for (n = 0;  n <= max_code; n++) {
+                int len = tree[n*2+1];
+                if (len == 0) continue;
+                // Now reverse the bits
+                tree[n*2] = (short)(bi_reverse(next_code[len]++, len));
+            }
+        }
+
+        // Reverse the first len bits of a code, using straightforward code (a faster
+        // method would use a table)
+        // IN assertion: 1 <= len <= 15
+        internal static int bi_reverse(int code, // the value to invert
+            int len   // its bit length
+            ){
+            int res = 0;
+            do{
+                res|=code&1;
+                code>>=1;
+                res<<=1;
+            } 
+            while(--len>0);
+            return res>>1;
+        }
+    }
+}

src/core/System/util/zlib/ZDeflaterOutputStream.cs

@@ -0,0 +1,196 @@
+using System;
+using System.IO;
+/*
+ * $Id: ZDeflaterOutputStream.cs,v 1.3 2007/06/22 14:14:13 psoares33 Exp $
+ *
+ * Copyright 2006 by Paulo Soares.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License isp distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code isp 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code isp Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code isp Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library isp free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library isp distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+
+namespace System.util.zlib {
+    /// <summary>
+    /// Summary description for DeflaterOutputStream.
+    /// </summary>
+    public class ZDeflaterOutputStream : Stream {
+        protected ZStream z=new ZStream();
+        protected int flushLevel=JZlib.Z_NO_FLUSH;
+        private const int BUFSIZE = 4192;
+        protected byte[] buf=new byte[BUFSIZE];
+        private byte[] buf1=new byte[1];
+
+        protected Stream outp;
+
+        public ZDeflaterOutputStream(Stream outp) : this(outp, 6, false) {
+        }
+    
+        public ZDeflaterOutputStream(Stream outp, int level) : this(outp, level, false) {
+        }
+    
+        public ZDeflaterOutputStream(Stream outp, int level, bool nowrap) {
+            this.outp=outp;
+            z.deflateInit(level, nowrap);
+        }
+    
+    
+        public override bool CanRead {
+            get {
+                // TODO:  Add DeflaterOutputStream.CanRead getter implementation
+                return false;
+            }
+        }
+    
+        public override bool CanSeek {
+            get {
+                // TODO:  Add DeflaterOutputStream.CanSeek getter implementation
+                return false;
+            }
+        }
+    
+        public override bool CanWrite {
+            get {
+                // TODO:  Add DeflaterOutputStream.CanWrite getter implementation
+                return true;
+            }
+        }
+    
+        public override long Length {
+            get {
+                // TODO:  Add DeflaterOutputStream.Length getter implementation
+                return 0;
+            }
+        }
+    
+        public override long Position {
+            get {
+                // TODO:  Add DeflaterOutputStream.Position getter implementation
+                return 0;
+            }
+            set {
+                // TODO:  Add DeflaterOutputStream.Position setter implementation
+            }
+        }
+    
+        public override void Write(byte[] b, int off, int len) {
+            if(len==0)
+                return;
+            int err;
+            z.next_in=b;
+            z.next_in_index=off;
+            z.avail_in=len;
+            do{
+                z.next_out=buf;
+                z.next_out_index=0;
+                z.avail_out=BUFSIZE;
+                err=z.deflate(flushLevel);
+                if(err!=JZlib.Z_OK)
+                    throw new IOException("deflating: "+z.msg);
+                if (z.avail_out < BUFSIZE)
+                    outp.Write(buf, 0, BUFSIZE-z.avail_out);
+            } 
+            while(z.avail_in>0 || z.avail_out==0);
+        }
+    
+        public override long Seek(long offset, SeekOrigin origin) {
+            // TODO:  Add DeflaterOutputStream.Seek implementation
+            return 0;
+        }
+    
+        public override void SetLength(long value) {
+            // TODO:  Add DeflaterOutputStream.SetLength implementation
+
+        }
+    
+        public override int Read(byte[] buffer, int offset, int count) {
+            // TODO:  Add DeflaterOutputStream.Read implementation
+            return 0;
+        }
+    
+        public override void Flush() {
+            outp.Flush();
+        }
+    
+        public override void WriteByte(byte b) {
+            buf1[0]=(byte)b;
+            Write(buf1, 0, 1);
+        }
+
+        public void Finish() {
+            int err;
+            do{
+                z.next_out=buf;
+                z.next_out_index=0;
+                z.avail_out=BUFSIZE;
+                err=z.deflate(JZlib.Z_FINISH);
+                if(err!=JZlib.Z_STREAM_END && err != JZlib.Z_OK)
+                    throw new IOException("deflating: "+z.msg);
+                if(BUFSIZE-z.avail_out>0){
+                    outp.Write(buf, 0, BUFSIZE-z.avail_out);
+                }
+            }
+            while(z.avail_in>0 || z.avail_out==0);
+            Flush();
+        }
+
+        public void End() {
+            if(z==null)
+                return;
+            z.deflateEnd();
+            z.free();
+            z=null;
+        }
+        
+        public override void Close() {
+            try{
+                try{Finish();}
+                catch (IOException) {}
+            }
+            finally{
+                End();
+                outp.Close();
+                outp=null;
+            }
+        }
+    }
+}

src/core/System/util/zlib/ZInflaterInputStream.cs

@@ -0,0 +1,174 @@
+using System;
+using System.IO;
+/*
+ * $Id: ZInflaterInputStream.cs,v 1.4 2007/06/22 14:14:16 psoares33 Exp $
+ *
+ * Copyright 2006 by Paulo Soares.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License isp distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code isp 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code isp Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code isp Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library isp free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library isp distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+
+namespace System.util.zlib {
+    /// <summary>
+    /// Summary description for DeflaterOutputStream.
+    /// </summary>
+    public class ZInflaterInputStream : Stream {
+        protected ZStream z=new ZStream();
+        protected int flushLevel=JZlib.Z_NO_FLUSH;
+        private const int BUFSIZE = 4192;
+        protected byte[] buf=new byte[BUFSIZE];
+        private byte[] buf1=new byte[1];
+
+        protected Stream inp=null;
+        private bool nomoreinput=false;
+
+        public ZInflaterInputStream(Stream inp) : this(inp, false) {
+        }
+    
+        public ZInflaterInputStream(Stream inp, bool nowrap) {
+            this.inp=inp;
+            z.inflateInit(nowrap);
+            z.next_in=buf;
+            z.next_in_index=0;
+            z.avail_in=0;
+        }
+    
+        public override bool CanRead {
+            get {
+                // TODO:  Add DeflaterOutputStream.CanRead getter implementation
+                return true;
+            }
+        }
+    
+        public override bool CanSeek {
+            get {
+                // TODO:  Add DeflaterOutputStream.CanSeek getter implementation
+                return false;
+            }
+        }
+    
+        public override bool CanWrite {
+            get {
+                // TODO:  Add DeflaterOutputStream.CanWrite getter implementation
+                return false;
+            }
+        }
+    
+        public override long Length {
+            get {
+                // TODO:  Add DeflaterOutputStream.Length getter implementation
+                return 0;
+            }
+        }
+    
+        public override long Position {
+            get {
+                // TODO:  Add DeflaterOutputStream.Position getter implementation
+                return 0;
+            }
+            set {
+                // TODO:  Add DeflaterOutputStream.Position setter implementation
+            }
+        }
+    
+        public override void Write(byte[] b, int off, int len) {
+        }
+    
+        public override long Seek(long offset, SeekOrigin origin) {
+            // TODO:  Add DeflaterOutputStream.Seek implementation
+            return 0;
+        }
+    
+        public override void SetLength(long value) {
+            // TODO:  Add DeflaterOutputStream.SetLength implementation
+
+        }
+    
+        public override int Read(byte[] b, int off, int len) {
+            if(len==0)
+                return(0);
+            int err;
+            z.next_out=b;
+            z.next_out_index=off;
+            z.avail_out=len;
+            do {
+                if((z.avail_in==0)&&(!nomoreinput)) { // if buffer is empty and more input is avaiable, refill it
+                    z.next_in_index=0;
+                    z.avail_in=inp.Read(buf, 0, BUFSIZE);//(BUFSIZE<z.avail_out ? BUFSIZE : z.avail_out));
+                    if(z.avail_in==0) {
+                        z.avail_in=0;
+                        nomoreinput=true;
+                    }
+                }
+                err=z.inflate(flushLevel);
+                if(nomoreinput&&(err==JZlib.Z_BUF_ERROR))
+                    return(-1);
+                if(err!=JZlib.Z_OK && err!=JZlib.Z_STREAM_END)
+                    throw new IOException("inflating: "+z.msg);
+                if((nomoreinput||err==JZlib.Z_STREAM_END)&&(z.avail_out==len))
+                    return(0);
+            } 
+            while(z.avail_out==len&&err==JZlib.Z_OK);
+            //System.err.print("("+(len-z.avail_out)+")");
+            return(len-z.avail_out);
+        }
+    
+        public override void Flush() {
+            inp.Flush();
+        }
+    
+        public override void WriteByte(byte b) {
+        }
+
+        public override void Close() {
+            inp.Close();
+        }
+    
+        public override int ReadByte() {
+            if(Read(buf1, 0, 1)<=0)
+                return -1;
+            return(buf1[0]&0xFF);
+        }
+    }
+}

src/core/System/util/zlib/ZStream.cs

@@ -0,0 +1,214 @@
+using System;
+/*
+ * $Id: ZStream.cs,v 1.1 2006/06/16 10:56:20 psoares33 Exp $
+ *
+Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+  1. Redistributions of source code must retain the above copyright notice,
+     this list of conditions and the following disclaimer.
+
+  2. Redistributions in binary form must reproduce the above copyright 
+     notice, this list of conditions and the following disclaimer in 
+     the documentation and/or other materials provided with the distribution.
+
+  3. The names of the authors may not be used to endorse or promote products
+     derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
+INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
+INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/*
+ * This program is based on zlib-1.1.3, so all credit should go authors
+ * Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu)
+ * and contributors of zlib.
+ */
+
+namespace System.util.zlib {
+
+    public sealed class ZStream{
+
+        private const int MAX_WBITS=15;        // 32K LZ77 window
+        private const int DEF_WBITS=MAX_WBITS;
+
+        private const int Z_NO_FLUSH=0;
+        private const int Z_PARTIAL_FLUSH=1;
+        private const int Z_SYNC_FLUSH=2;
+        private const int Z_FULL_FLUSH=3;
+        private const int Z_FINISH=4;
+
+        private const int MAX_MEM_LEVEL=9;
+
+        private const int Z_OK=0;
+        private const int Z_STREAM_END=1;
+        private const int Z_NEED_DICT=2;
+        private const int Z_ERRNO=-1;
+        private const int Z_STREAM_ERROR=-2;
+        private const int Z_DATA_ERROR=-3;
+        private const int Z_MEM_ERROR=-4;
+        private const int Z_BUF_ERROR=-5;
+        private const int Z_VERSION_ERROR=-6;
+
+        public byte[] next_in;     // next input byte
+        public int next_in_index;
+        public int avail_in;       // number of bytes available at next_in
+        public long total_in;      // total nb of input bytes read so far
+
+        public byte[] next_out;    // next output byte should be put there
+        public int next_out_index;
+        public int avail_out;      // remaining free space at next_out
+        public long total_out;     // total nb of bytes output so far
+
+        public String msg;
+
+        internal Deflate dstate; 
+        internal Inflate istate; 
+
+        internal int data_type; // best guess about the data type: ascii or binary
+
+        public long adler;
+        internal Adler32 _adler=new Adler32();
+
+        public int inflateInit(){
+            return inflateInit(DEF_WBITS);
+        }
+        public int inflateInit(bool nowrap){
+            return inflateInit(DEF_WBITS, nowrap);
+        }
+        public int inflateInit(int w){
+            return inflateInit(w, false);
+        }
+
+        public int inflateInit(int w, bool nowrap){
+            istate=new Inflate();
+            return istate.inflateInit(this, nowrap?-w:w);
+        }
+
+        public int inflate(int f){
+            if(istate==null) return Z_STREAM_ERROR;
+            return istate.inflate(this, f);
+        }
+        public int inflateEnd(){
+            if(istate==null) return Z_STREAM_ERROR;
+            int ret=istate.inflateEnd(this);
+            istate = null;
+            return ret;
+        }
+        public int inflateSync(){
+            if(istate == null)
+                return Z_STREAM_ERROR;
+            return istate.inflateSync(this);
+        }
+        public int inflateSetDictionary(byte[] dictionary, int dictLength){
+            if(istate == null)
+                return Z_STREAM_ERROR;
+            return istate.inflateSetDictionary(this, dictionary, dictLength);
+        }
+
+        public int deflateInit(int level){
+            return deflateInit(level, MAX_WBITS);
+        }
+        public int deflateInit(int level, bool nowrap){
+            return deflateInit(level, MAX_WBITS, nowrap);
+        }
+        public int deflateInit(int level, int bits){
+            return deflateInit(level, bits, false);
+        }
+        public int deflateInit(int level, int bits, bool nowrap){
+            dstate=new Deflate();
+            return dstate.deflateInit(this, level, nowrap?-bits:bits);
+        }
+        public int deflate(int flush){
+            if(dstate==null){
+                return Z_STREAM_ERROR;
+            }
+            return dstate.deflate(this, flush);
+        }
+        public int deflateEnd(){
+            if(dstate==null) return Z_STREAM_ERROR;
+            int ret=dstate.deflateEnd();
+            dstate=null;
+            return ret;
+        }
+        public int deflateParams(int level, int strategy){
+            if(dstate==null) return Z_STREAM_ERROR;
+            return dstate.deflateParams(this, level, strategy);
+        }
+        public int deflateSetDictionary (byte[] dictionary, int dictLength){
+            if(dstate == null)
+                return Z_STREAM_ERROR;
+            return dstate.deflateSetDictionary(this, dictionary, dictLength);
+        }
+
+        // Flush as much pending output as possible. All deflate() output goes
+        // through this function so some applications may wish to modify it
+        // to avoid allocating a large strm->next_out buffer and copying into it.
+        // (See also read_buf()).
+        internal void flush_pending(){
+            int len=dstate.pending;
+
+            if(len>avail_out) len=avail_out;
+            if(len==0) return;
+
+            if(dstate.pending_buf.Length<=dstate.pending_out ||
+                next_out.Length<=next_out_index ||
+                dstate.pending_buf.Length<(dstate.pending_out+len) ||
+                next_out.Length<(next_out_index+len)){
+                //      System.out.println(dstate.pending_buf.length+", "+dstate.pending_out+
+                //			 ", "+next_out.length+", "+next_out_index+", "+len);
+                //      System.out.println("avail_out="+avail_out);
+            }
+
+            System.Array.Copy(dstate.pending_buf, dstate.pending_out,
+                next_out, next_out_index, len);
+
+            next_out_index+=len;
+            dstate.pending_out+=len;
+            total_out+=len;
+            avail_out-=len;
+            dstate.pending-=len;
+            if(dstate.pending==0){
+                dstate.pending_out=0;
+            }
+        }
+
+        // Read a new buffer from the current input stream, update the adler32
+        // and total number of bytes read.  All deflate() input goes through
+        // this function so some applications may wish to modify it to avoid
+        // allocating a large strm->next_in buffer and copying from it.
+        // (See also flush_pending()).
+        internal int read_buf(byte[] buf, int start, int size) {
+            int len=avail_in;
+
+            if(len>size) len=size;
+            if(len==0) return 0;
+
+            avail_in-=len;
+
+            if(dstate.noheader==0) {
+                adler=_adler.adler32(adler, next_in, next_in_index, len);
+            }
+            System.Array.Copy(next_in, next_in_index, buf, start, len);
+            next_in_index  += len;
+            total_in += len;
+            return len;
+        }
+
+        public void free(){
+            next_in=null;
+            next_out=null;
+            msg=null;
+            _adler=null;
+        }
+    }
+}

src/core/iTextSharp/text/Anchor.cs

@@ -0,0 +1,284 @@
+using System;
+using System.Collections;
+using System.util;
+
+using iTextSharp.text.html;
+using iTextSharp.text.factories;
+
+/*
+ * $Id: Anchor.cs,v 1.9 2008/05/13 11:25:08 psoares33 Exp $
+ * 
+ *
+ * Copyright 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iTextSharp, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+
+namespace iTextSharp.text 
+{
+    /// <summary>
+    /// An Anchor can be a reference or a destination of a reference.
+    /// </summary>
+    /// <remarks>
+    /// An Anchor is a special kind of <see cref="T:iTextSharp.text.Phrase"/>.
+    /// It is constructed in the same way.
+    /// </remarks>
+    /// <seealso cref="T:iTextSharp.text.Element"/>
+    /// <seealso cref="T:iTextSharp.text.Phrase"/>
+    public class Anchor : Phrase 
+    {
+    
+        // membervariables
+    
+        /// <summary>
+        /// This is the name of the Anchor.
+        /// </summary>
+        protected string name = null;
+    
+        /// <summary>
+        /// This is the reference of the Anchor.
+        /// </summary>
+        protected string reference = null;
+    
+        // constructors
+    
+        /// <summary>
+        /// Constructs an Anchor without specifying a leading.
+        /// </summary>
+        /// <overloads>
+        /// Has nine overloads.
+        /// </overloads>
+        public Anchor() : base(16) {}
+    
+        /// <summary>
+        /// Constructs an Anchor with a certain leading.
+        /// </summary>
+        /// <param name="leading">the leading</param>
+        public Anchor(float leading) : base(leading) {}
+    
+        /// <summary>
+        /// Constructs an Anchor with a certain Chunk.
+        /// </summary>
+        /// <param name="chunk">a Chunk</param>
+        public Anchor(Chunk chunk) : base(chunk) {}
+    
+        /// <summary>
+        /// Constructs an Anchor with a certain string.
+        /// </summary>
+        /// <param name="str">a string</param>
+        public Anchor(string str) : base(str) {}
+    
+        /// <summary>
+        /// Constructs an Anchor with a certain string
+        /// and a certain Font.
+        /// </summary>
+        /// <param name="str">a string</param>
+        /// <param name="font">a Font</param>
+        public Anchor(string str, Font font) : base(str, font) {}
+    
+        /// <summary>
+        /// Constructs an Anchor with a certain Chunk
+        /// and a certain leading.
+        /// </summary>
+        /// <param name="leading">the leading</param>
+        /// <param name="chunk">a Chunk</param>
+        public Anchor(float leading, Chunk chunk) : base(leading, chunk) {}
+    
+        /// <summary>
+        /// Constructs an Anchor with a certain leading
+        /// and a certain string.
+        /// </summary>
+        /// <param name="leading">the leading</param>
+        /// <param name="str">a string</param>
+        public Anchor(float leading, string str) : base(leading, str) {}
+    
+        /// <summary>
+        /// Constructs an Anchor with a certain leading,
+        /// a certain string and a certain Font.
+        /// </summary>
+        /// <param name="leading">the leading</param>
+        /// <param name="str">a string</param>
+        /// <param name="font">a Font</param>
+        public Anchor(float leading, string str, Font font) : base(leading, str, font) {}
+    
+        /**
+        * Constructs an <CODE>Anchor</CODE> with a certain <CODE>Phrase</CODE>.
+        *
+        * @param   phrase      a <CODE>Phrase</CODE>
+        */    
+        public Anchor(Phrase phrase) : base(phrase) {
+            if (phrase is Anchor) {
+                Anchor a = (Anchor) phrase;
+                Name = a.name;
+                Reference = a.reference;
+            }
+        }
+        // implementation of the Element-methods
+    
+        /// <summary>
+        /// Processes the element by adding it (or the different parts) to an
+        /// <see cref="T:iTextSharp.text.IElementListener"/>
+        /// </summary>
+        /// <param name="listener">an IElementListener</param>
+        /// <returns>true if the element was processed successfully</returns>
+        public override bool Process(IElementListener listener) 
+        {
+            try 
+            {
+                bool localDestination = (reference != null && reference.StartsWith("#"));
+                bool notGotoOK = true;
+                foreach (Chunk chunk in this.Chunks) 
+                {
+                    if (name != null && notGotoOK && !chunk.IsEmpty()) 
+                    {
+                        chunk.SetLocalDestination(name);
+                        notGotoOK = false;
+                    }
+                    if (localDestination) 
+                    {
+                        chunk.SetLocalGoto(reference.Substring(1));
+                    }
+                    else if (reference != null)
+                        chunk.SetAnchor(reference);
+                    listener.Add(chunk);
+                }
+                return true;
+            }
+            catch (DocumentException) 
+            {
+                return false;
+            }
+        }
+    
+        /// <summary>
+        /// Gets all the chunks in this element.
+        /// </summary>
+        /// <value>an ArrayList</value>
+        public override ArrayList Chunks 
+        {
+            get 
+            {
+                ArrayList tmp = new ArrayList();
+                bool localDestination = (reference != null && reference.StartsWith("#"));
+                bool notGotoOK = true;
+                foreach (Chunk chunk in this) 
+                {
+                    if (name != null && notGotoOK && !chunk.IsEmpty()) 
+                    {
+                        chunk.SetLocalDestination(name);
+                        notGotoOK = false;
+                    }
+                    if (localDestination) 
+                    {
+                        chunk.SetLocalGoto(reference.Substring(1));
+                    }
+                    else if (reference != null) 
+                    {
+                        chunk.SetAnchor(reference);
+                    }
+
+                    tmp.Add(chunk);
+                }
+                return tmp;
+            }
+        }
+    
+        /// <summary>
+        /// Gets the type of the text element.
+        /// </summary>
+        /// <value>a type</value>
+        public override int Type 
+        {
+            get 
+            {
+                return Element.ANCHOR;
+            }
+        }
+    
+        // methods
+    
+        /// <summary>
+        /// Name of this Anchor.
+        /// </summary>
+        public string Name {
+            get {
+                return this.name;
+            }
+
+            set {
+                this.name = value;
+            }
+        }
+    
+        // methods to retrieve information
+    
+        /// <summary>
+        /// reference of this Anchor.
+        /// </summary>
+        public string Reference {
+            get {
+                return reference;
+            }
+
+            set {
+                this.reference = value;
+            }
+        }
+    
+        /// <summary>
+        /// reference of this Anchor.
+        /// </summary>
+        /// <value>an Uri</value>
+        public Uri Url {
+            get {
+                try {
+                    return new Uri(reference);
+                }
+                catch {
+                    return null;
+                }
+            }
+        }
+    }
+}

src/core/iTextSharp/text/Annotation.cs

@@ -0,0 +1,525 @@
+using System;
+using System.Collections;
+using System.util;
+using iTextSharp.text.factories;
+
+/*
+ * $Id: Annotation.cs,v 1.12 2008/05/13 11:25:08 psoares33 Exp $
+ * 
+ *
+ * Copyright 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+
+namespace iTextSharp.text 
+{
+    /// <summary>
+    /// An Annotation is a little note that can be added to a page
+    /// on a document.
+    /// </summary>
+    /// <seealso cref="T:iTextSharp.text.Element"/>
+    /// <seealso cref="T:iTextSharp.text.Anchor"/>
+    public class Annotation : IElement 
+    {
+    
+        // membervariables
+    
+        /// <summary>This is a possible annotation type.</summary>
+        public const int TEXT = 0;    
+        /// <summary>This is a possible annotation type.</summary>
+        public const int URL_NET = 1;    
+        /// <summary>This is a possible annotation type.</summary>
+        public const int URL_AS_STRING = 2;    
+        /// <summary>This is a possible annotation type.</summary>
+        public const int FILE_DEST = 3;    
+        /// <summary>This is a possible annotation type.</summary>
+        public const int FILE_PAGE = 4;    
+        /// <summary>This is a possible annotation type.</summary>
+        public const int NAMED_DEST = 5;    
+        /// <summary>This is a possible annotation type.</summary>
+        public const int LAUNCH = 6;
+        /// <summary>This is a possible annotation type.</summary>
+        public const int SCREEN = 7;
+    
+        /// <summary>This is a possible attribute.</summary>
+        public const string TITLE = "title";
+        /// <summary>This is a possible attribute.</summary>
+        public const string CONTENT = "content";
+        /// <summary>This is a possible attribute.</summary>
+        public const string URL = "url";
+        /// <summary>This is a possible attribute.</summary>
+        public const string FILE = "file";
+        /// <summary>This is a possible attribute.</summary>
+        public const string DESTINATION = "destination";
+        /// <summary>This is a possible attribute.</summary>
+        public const string PAGE = "page";
+        /// <summary>This is a possible attribute.</summary>
+        public const string NAMED = "named";
+        /// <summary>This is a possible attribute.</summary>
+        public const string APPLICATION = "application";
+        /// <summary>This is a possible attribute.</summary>
+        public const string PARAMETERS = "parameters";
+        /// <summary>This is a possible attribute.</summary>
+        public const string OPERATION = "operation";
+        /// <summary>This is a possible attribute.</summary>
+        public const string DEFAULTDIR = "defaultdir";
+        /// <summary>This is a possible attribute.</summary>
+        public const string LLX = "llx";
+        /// <summary>This is a possible attribute.</summary>
+        public const string LLY = "lly";
+        /// <summary>This is a possible attribute.</summary>
+        public const string URX = "urx";
+        /// <summary>This is a possible attribute.</summary>
+        public const string URY = "ury";
+        /// <summary>This is a possible attribute.</summary>
+        public const string MIMETYPE = "mime";
+    
+        /// <summary>This is the type of annotation.</summary>
+        protected int annotationtype;
+    
+        /// <summary>This is the title of the Annotation.</summary>
+        protected Hashtable annotationAttributes = new Hashtable();
+
+        /// <summary>This is the lower left x-value</summary>
+        private float llx = float.NaN;
+        /// <summary>This is the lower left y-value</summary>
+        private float lly = float.NaN;
+        /// <summary>This is the upper right x-value</summary>
+        private float urx = float.NaN;
+        /// <summary>This is the upper right y-value</summary>
+        private float ury = float.NaN;
+    
+        // constructors
+    
+        /// <summary>
+        /// Constructs an Annotation with a certain title and some text.
+        /// </summary>
+        /// <param name="llx">the lower left x-value</param>
+        /// <param name="lly">the lower left y-value</param>
+        /// <param name="urx">the upper right x-value</param>
+        /// <param name="ury">the upper right y-value</param>
+        private Annotation(float llx, float lly, float urx, float ury) 
+        {
+            this.llx = llx;
+            this.lly = lly;
+            this.urx = urx;
+            this.ury = ury;
+        }
+    
+        public Annotation(Annotation an) {
+            annotationtype = an.annotationtype;
+            annotationAttributes = an.annotationAttributes;
+            llx = an.llx;
+            lly = an.lly;
+            urx = an.urx;
+            ury = an.ury;
+        }
+
+        /// <summary>
+        /// Constructs an Annotation with a certain title and some text.
+        /// </summary>
+        /// <param name="title">the title of the annotation</param>
+        /// <param name="text">the content of the annotation</param>
+        public Annotation(string title, string text) 
+        {
+            annotationtype = TEXT;
+            annotationAttributes[TITLE] = title;
+            annotationAttributes[CONTENT] = text;
+        }
+    
+        /// <summary>
+        /// Constructs an Annotation with a certain title and some text.
+        /// </summary>
+        /// <param name="title">the title of the annotation</param>
+        /// <param name="text">the content of the annotation</param>
+        /// <param name="llx">the lower left x-value</param>
+        /// <param name="lly">the lower left y-value</param>
+        /// <param name="urx">the upper right x-value</param>
+        /// <param name="ury">the upper right y-value</param>
+        public Annotation(string title, string text, float llx, float lly, float urx, float ury) : this(llx, lly, urx, ury) 
+        {
+            annotationtype = TEXT;
+            annotationAttributes[TITLE] = title;
+            annotationAttributes[CONTENT] = text;
+        }
+    
+        /// <summary>
+        /// Constructs an Annotation.
+        /// </summary>
+        /// <param name="llx">the lower left x-value</param>
+        /// <param name="lly">the lower left y-value</param>
+        /// <param name="urx">the upper right x-value</param>
+        /// <param name="ury">the upper right y-value</param>
+        /// <param name="url">the external reference</param>
+        public Annotation(float llx, float lly, float urx, float ury, Uri url) : this(llx, lly, urx, ury) 
+        {
+            annotationtype = URL_NET;
+            annotationAttributes[URL] = url;
+        }
+    
+        /// <summary>
+        /// Constructs an Annotation.
+        /// </summary>
+        /// <param name="llx">the lower left x-value</param>
+        /// <param name="lly">the lower left y-value</param>
+        /// <param name="urx">the upper right x-value</param>
+        /// <param name="ury">the upper right y-value</param>
+        /// <param name="url">the external reference</param>
+        public Annotation(float llx, float lly, float urx, float ury, string url) : this(llx, lly, urx, ury) 
+        {
+            annotationtype = URL_AS_STRING;
+            annotationAttributes[FILE] = url;
+        }
+    
+        /// <summary>
+        /// Constructs an Annotation.
+        /// </summary>
+        /// <param name="llx">the lower left x-value</param>
+        /// <param name="lly">the lower left y-value</param>
+        /// <param name="urx">the upper right x-value</param>
+        /// <param name="ury">the upper right y-value</param>
+        /// <param name="file">an external PDF file</param>
+        /// <param name="dest">the destination in this file</param>
+        public Annotation(float llx, float lly, float urx, float ury, string file, string dest) : this(llx, lly, urx, ury) 
+        {
+            annotationtype = FILE_DEST;
+            annotationAttributes[FILE] = file;
+            annotationAttributes[DESTINATION] = dest;
+        }
+
+        /// <summary>
+        /// Creates a Screen anotation to embed media clips
+        /// </summary>
+        /// <param name="llx">the lower left x-value</param>
+        /// <param name="lly">the lower left y-value</param>
+        /// <param name="urx">the upper right x-value</param>
+        /// <param name="ury">the upper right y-value</param>
+        /// <param name="moviePath">path to the media clip file</param>
+        /// <param name="mimeType">mime type of the media</param>
+        /// <param name="showOnDisplay">if true play on display of the page</param>
+        public Annotation(float llx, float lly, float urx, float ury,
+            string moviePath, string mimeType, bool showOnDisplay) : this(llx, lly, urx, ury)
+        {
+            annotationtype = SCREEN;
+            annotationAttributes[FILE] = moviePath;
+            annotationAttributes[MIMETYPE] = mimeType;
+            annotationAttributes[PARAMETERS] = new bool[] {false /* embedded */, showOnDisplay };
+        }
+    
+        /// <summary>
+        /// Constructs an Annotation.
+        /// </summary>
+        /// <param name="llx">the lower left x-value</param>
+        /// <param name="lly">the lower left y-value</param>
+        /// <param name="urx">the upper right x-value</param>
+        /// <param name="ury">the upper right y-value</param>
+        /// <param name="file">an external PDF file</param>
+        /// <param name="page">a page number in this file</param>
+        public Annotation(float llx, float lly, float urx, float ury, string file, int page) : this(llx, lly, urx, ury) 
+        {
+            annotationtype = FILE_PAGE;
+            annotationAttributes[FILE] = file;
+            annotationAttributes[PAGE] = page;
+        }
+    
+        /// <summary>
+        /// Constructs an Annotation.
+        /// </summary>
+        /// <param name="llx">the lower left x-value</param>
+        /// <param name="lly">the lower left y-value</param>
+        /// <param name="urx">the upper right x-value</param>
+        /// <param name="ury">the upper right y-value</param>
+        /// <param name="named">a named destination in this file</param>
+        /// <overloads>
+        /// Has nine overloads.
+        /// </overloads>
+        public Annotation(float llx, float lly, float urx, float ury, int named) : this(llx, lly, urx, ury) 
+        {
+            annotationtype = NAMED_DEST;
+            annotationAttributes[NAMED] = named;
+        }
+    
+        /// <summary>
+        /// Constructs an Annotation.
+        /// </summary>
+        /// <param name="llx">the lower left x-value</param>
+        /// <param name="lly">the lower left y-value</param>
+        /// <param name="urx">the upper right x-value</param>
+        /// <param name="ury">the upper right y-value</param>
+        /// <param name="application">an external application</param>
+        /// <param name="parameters">parameters to pass to this application</param>
+        /// <param name="operation">the operation to pass to this application</param>
+        /// <param name="defaultdir">the default directory to run this application in</param>
+        public Annotation(float llx, float lly, float urx, float ury, string application, string parameters, string operation, string defaultdir) : this(llx, lly, urx, ury) 
+        {
+            annotationtype = LAUNCH;
+            annotationAttributes[APPLICATION] = application;
+            annotationAttributes[PARAMETERS] = parameters;
+            annotationAttributes[OPERATION] = operation;
+            annotationAttributes[DEFAULTDIR] = defaultdir;
+        }
+    
+        // implementation of the Element-methods
+    
+        /// <summary>
+        /// Gets the type of the text element
+        /// </summary>
+        public int Type 
+        {
+            get 
+            {
+                return Element.ANNOTATION;
+            }
+        }
+    
+        // methods
+    
+        /// <summary>
+        /// Processes the element by adding it (or the different parts) to an
+        /// IElementListener.
+        /// </summary>
+        /// <param name="listener">an IElementListener</param>
+        /// <returns>true if the element was process successfully</returns>
+        public bool Process(IElementListener listener) 
+        {
+            try 
+            {
+                return listener.Add(this);
+            }
+            catch (DocumentException) 
+            {
+                return false;
+            }
+        }
+    
+        /// <summary>
+        /// Gets all the chunks in this element.
+        /// </summary>
+        /// <value>an ArrayList</value>
+        public ArrayList Chunks 
+        {
+            get 
+            {
+                return new ArrayList();
+            }
+        }
+   
+        // methods
+    
+        /// <summary>
+        /// Sets the dimensions of this annotation.
+        /// </summary>
+        /// <param name="llx">the lower left x-value</param>
+        /// <param name="lly">the lower left y-value</param>
+        /// <param name="urx">the upper right x-value</param>
+        /// <param name="ury">the upper right y-value</param>
+        public void SetDimensions (float llx, float lly, float urx, float ury) 
+        {
+            this.llx = llx;
+            this.lly = lly;
+            this.urx = urx;
+            this.ury = ury;
+        }
+    
+        // methods to retrieve information
+    
+        /// <summary>
+        /// Returns the lower left x-value.
+        /// </summary>
+        /// <returns>a value</returns>
+        public float GetLlx() 
+        {
+            return llx;
+        }
+    
+        /// <summary>
+        /// Returns the lower left y-value.
+        /// </summary>
+        /// <returns>a value</returns>
+        public float GetLly() 
+        {
+            return lly;
+        }
+    
+        /// <summary>
+        /// Returns the uppper right x-value.
+        /// </summary>
+        /// <returns>a value</returns>
+        public float GetUrx() 
+        {
+            return urx;
+        }
+    
+        /// <summary>
+        /// Returns the uppper right y-value.
+        /// </summary>
+        /// <returns>a value</returns>
+        public float GetUry() 
+        {
+            return ury;
+        }
+    
+        /// <summary>
+        /// Returns the lower left x-value.
+        /// </summary>
+        /// <param name="def">the default value</param>
+        /// <returns>a value</returns>
+        public float GetLlx(float def) 
+        {
+            if (float.IsNaN(llx))
+                return def;
+            return llx;
+        }
+    
+        /// <summary>
+        /// Returns the lower left y-value.
+        /// </summary>
+        /// <param name="def">the default value</param>
+        /// <returns>a value</returns>
+        public float GetLly(float def) 
+        {
+            if (float.IsNaN(lly))
+                return def;
+            return lly;
+        }
+    
+        /// <summary>
+        /// Returns the upper right x-value.
+        /// </summary>
+        /// <param name="def">the default value</param>
+        /// <returns>a value</returns>
+        public float GetUrx(float def) 
+        {
+            if (float.IsNaN(urx))
+                return def;
+            return urx;
+        }
+    
+        /// <summary>
+        /// Returns the upper right y-value.
+        /// </summary>
+        /// <param name="def">the default value</param>
+        /// <returns>a value</returns>
+        public float GetUry(float def) 
+        {
+            if (float.IsNaN(ury))
+                return def;
+            return ury;
+        }
+    
+        /// <summary>
+        /// Returns the type of this Annotation.
+        /// </summary>
+        /// <value>a type</value>
+        public int AnnotationType 
+        {
+            get 
+            {
+                return annotationtype;
+            }
+        }
+    
+        /// <summary>
+        /// Returns the title of this Annotation.
+        /// </summary>
+        /// <value>a name</value>
+        public string Title 
+        {
+            get 
+            {
+                string s = (string)annotationAttributes[TITLE];
+                if (s == null) 
+                    s = "";
+                return s;
+            }
+        }
+    
+        /// <summary>
+        /// Gets the content of this Annotation.
+        /// </summary>
+        /// <value>a reference</value>
+        public string Content 
+        {
+            get 
+            {
+                string s = (string)annotationAttributes[CONTENT];
+                if (s == null) s = "";
+                return s;
+            }
+        }
+    
+        /// <summary>
+        /// Gets the content of this Annotation.
+        /// </summary>
+        /// <value>a reference</value>
+        public Hashtable Attributes 
+        {
+            get 
+            {
+                return annotationAttributes;
+            }
+        }
+    
+        /**
+        * @see com.lowagie.text.Element#isContent()
+        * @since   iText 2.0.8
+        */
+        public bool IsContent() {
+            return true;
+        }
+
+        /**
+        * @see com.lowagie.text.Element#isNestable()
+        * @since   iText 2.0.8
+        */
+        public bool IsNestable() {
+            return true;
+        }
+
+        public override string ToString() {
+            return base.ToString();
+        }
+    }
+}

src/core/iTextSharp/text/BadElementException.cs

@@ -0,0 +1,66 @@
+using System;
+
+/*
+ * $Id: BadElementException.cs,v 1.3 2008/05/13 11:25:08 psoares33 Exp $
+ * 
+ *
+ * Copyright 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+
+namespace iTextSharp.text 
+{
+    /// <summary>
+    /// Signals an attempt to create an Element that hasn't got the right form.
+    /// </summary>
+    /// <seealso cref="T:iTextSharp.text.Cell"/>
+    /// <seealso cref="T:iTextSharp.text.Table"/>
+    public class BadElementException : DocumentException 
+    {
+        public BadElementException() : base() {}
+
+        public BadElementException(string message) : base(message) {}
+    }
+}

src/core/iTextSharp/text/Cell.cs

@@ -0,0 +1,873 @@
+using System;
+using System.Collections;
+using System.util;
+
+using iTextSharp.text.html;
+using iTextSharp.text.pdf;
+using iTextSharp.text.factories;
+
+/*
+ * $Id: Cell.cs,v 1.17 2008/05/13 11:25:08 psoares33 Exp $
+ * 
+ *
+ * Copyright 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+
+namespace iTextSharp.text {
+    /// <summary>
+    /// A Cell is a Rectangle containing other Elements.
+    /// </summary>
+    /// <remarks>
+    /// A Cell is a Rectangle containing other
+    /// Elements.
+    /// <p/>
+    /// A Cell must be added to a Table.
+    /// The Table will place the Cell in
+    /// a Row.
+    /// </remarks>
+    /// <example>
+    /// <code>
+    /// Table table = new Table(3);
+    /// table.SetBorderWidth(1);
+    /// table.SetBorderColor(new Color(0, 0, 255));
+    /// table.SetCellpadding(5);
+    /// table.SetCellspacing(5);
+    /// <strong>Cell cell = new Cell("header");
+    /// cell.SetHeader(true);
+    /// cell.SetColspan(3);</strong>
+    /// table.AddCell(cell);
+    /// <strong>cell = new Cell("example cell with colspan 1 and rowspan 2");
+    /// cell.SetRowspan(2);
+    /// cell.SetBorderColor(new Color(255, 0, 0));</strong>
+    /// table.AddCell(cell);
+    /// table.AddCell("1.1");
+    /// table.AddCell("2.1");
+    /// table.AddCell("1.2");
+    /// table.AddCell("2.2");
+    /// </code>
+    /// </example>
+    /// <seealso cref="T:iTextSharp.text.Rectangle"/>
+    /// <seealso cref="T:iTextSharp.text.Element"/>
+    /// <seealso cref="T:iTextSharp.text.Table"/>
+    /// <seealso cref="T:iTextSharp.text.Row"/>
+    public class Cell : Rectangle, ITextElementArray {
+
+        // static membervariable
+
+        public static Cell DummyCell {
+            get {
+                Cell cell = new Cell(true);
+                cell.Colspan = 3;
+                cell.Border = NO_BORDER;
+                return cell;
+            }
+        }
+
+        // membervariables
+
+        ///<summary> This is the ArrayList of Elements. </summary>
+        protected ArrayList arrayList = null;
+
+        ///<summary> This is the horizontal Element. </summary>
+        protected int horizontalAlignment = Element.ALIGN_UNDEFINED;
+
+        ///<summary> This is the vertical Element. </summary>
+        protected int verticalAlignment = Element.ALIGN_UNDEFINED;
+
+        ///<summary> This is the vertical Element. </summary>
+        protected float width;
+        protected bool percentage = false;
+
+        ///<summary> This is the colspan. </summary>
+        protected int colspan = 1;
+
+        ///<summary> This is the rowspan. </summary>
+        protected int rowspan = 1;
+
+        ///<summary> This is the leading. </summary>
+        float leading = float.NaN;
+
+        ///<summary> Is this Cell a header? </summary>
+        protected bool header;
+
+        /// <summary>
+        /// Indicates that the largest ascender height should be used to determine the
+        /// height of the first line.  Note that this only has an effect when rendered
+        /// to PDF.  Setting this to true can help with vertical alignment problems.
+        /// </summary>
+        protected bool useAscender = false;
+
+        /// <summary>
+        /// Indicates that the largest descender height should be added to the height of
+        /// the last line (so characters like y don't dip into the border).   Note that
+        /// this only has an effect when rendered to PDF.
+        /// </summary>
+        protected bool useDescender = false;
+
+        /// <summary>
+        /// Adjusts the cell contents to compensate for border widths.  Note that
+        /// this only has an effect when rendered to PDF.
+        /// </summary>
+        protected bool useBorderPadding;
+
+        ///<summary> Will the element have to be wrapped? </summary>
+        protected bool noWrap;
+
+        // constructors
+
+        /**
+         * Constructs an empty Cell.
+         */
+        /// <summary>
+        /// Constructs an empty Cell.
+        /// </summary>
+        /// <overloads>
+        /// Has five overloads.
+        /// </overloads>
+        public Cell() : base(0, 0, 0, 0) {
+            // creates a Rectangle with BY DEFAULT a border of 0.5
+            
+            this.Border = UNDEFINED;
+            this.BorderWidth = 0.5F;
+            
+            // initializes the arraylist and adds an element
+            arrayList = new ArrayList();
+        }
+
+        /// <summary>
+        /// Constructs an empty Cell (for internal use only).
+        /// </summary>
+        /// <param name="dummy">a dummy value</param>
+        public Cell(bool dummy) : this() {
+            arrayList.Add(new Paragraph(0));
+        }
+
+        /// <summary>
+        /// Constructs a Cell with a certain content.
+        /// </summary>
+        /// <remarks>
+        /// The string will be converted into a Paragraph.
+        /// </remarks>
+        /// <param name="content">a string</param>
+        public Cell(string content) : this() {
+            AddElement(new Paragraph(content));
+        }
+
+        /// <summary>
+        /// Constructs a Cell with a certain Element.
+        /// </summary>
+        /// <remarks>
+        /// if the element is a ListItem, Row or
+        /// Cell, an exception will be thrown.
+        /// </remarks>
+        /// <param name="element">the element</param>
+        public Cell(IElement element) : this() {
+            if (element is Phrase) {
+                Leading = ((Phrase)element).Leading;
+            }
+            AddElement(element);
+        }
+
+        // implementation of the Element-methods
+
+        /// <summary>
+        /// Processes the element by adding it (or the different parts) to an
+        /// IElementListener.
+        /// </summary>
+        /// <param name="listener">an IElementListener</param>
+        /// <returns>true if the element was processed successfully</returns>
+        public override bool Process(IElementListener listener) {
+            try {
+                return listener.Add(this);
+            }
+            catch (DocumentException) {
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Gets the type of the text element.
+        /// </summary>
+        /// <value>a type</value>
+        public override int Type {
+            get {
+                return Element.CELL;
+            }
+        }
+
+        /// <summary>
+        /// Gets all the chunks in this element.
+        /// </summary>
+        /// <value>an ArrayList</value>
+        public override ArrayList Chunks {
+            get {
+                ArrayList tmp = new ArrayList();
+                foreach (IElement ele in arrayList) {
+                    tmp.AddRange(ele.Chunks);
+                }
+                return tmp;
+            }
+        }
+
+        // methods to set the membervariables
+
+        /**
+         * Adds an element to this Cell.
+         * <P>
+         * Remark: you can't add ListItems, Rows, Cells,
+         * JPEGs, GIFs or PNGs to a Cell.
+         *
+         * @param element The Element to add
+         * @throws BadElementException if the method was called with a ListItem, Row or Cell
+         */
+        /// <summary>
+        /// Adds an element to this Cell.
+        /// </summary>
+        /// <remarks>
+        /// You can't add ListItems, Rows, Cells,
+        /// JPEGs, GIFs or PNGs to a Cell.
+        /// </remarks>
+        /// <param name="element">the Element to add</param>
+        public void AddElement(IElement element) {
+            if (IsTable()) {
+                Table table = (Table) arrayList[0];
+                Cell tmp = new Cell(element);
+                tmp.Border = NO_BORDER;
+                tmp.Colspan = table.Columns;
+                table.AddCell(tmp);
+                return;
+            }
+            switch (element.Type) {
+                case Element.LISTITEM:
+                case Element.ROW:
+                case Element.CELL:
+                    throw new BadElementException("You can't add listitems, rows or cells to a cell.");
+                case Element.JPEG:
+                case Element.IMGRAW:
+                case Element.IMGTEMPLATE:
+                    arrayList.Add(element);
+                    break;
+                case Element.LIST:
+                    if (float.IsNaN(this.Leading)) {
+                        leading = ((List) element).TotalLeading;
+                    }
+                    if (((List) element).IsEmpty()) return;
+                    arrayList.Add(element);
+                    return;
+                case Element.ANCHOR:
+                case Element.PARAGRAPH:
+                case Element.PHRASE:
+                    if (float.IsNaN(leading)) {
+                        leading = ((Phrase) element).Leading;
+                    }
+                    if (((Phrase) element).IsEmpty()) return;
+                    arrayList.Add(element);
+                    return;
+                case Element.CHUNK:
+                    if (((Chunk) element).IsEmpty()) return;
+                    arrayList.Add(element);
+                    return;
+                case Element.TABLE:
+                    Table table = new Table(3);
+                    float[] widths = new float[3];
+                    widths[1] = ((Table)element).Width;
+
+                    switch (((Table)element).Alignment) {
+                        case Element.ALIGN_LEFT:
+                            widths[0] = 0f;
+                            widths[2] = 100f - widths[1];
+                            break;
+                        case Element.ALIGN_CENTER:
+                            widths[0] = (100f - widths[1]) / 2f;
+                            widths[2] = widths[0];
+                            break;
+                        case Element.ALIGN_RIGHT:
+                            widths[0] = 100f - widths[1];
+                            widths[2] = 0f;
+                            break;
+                    }
+                    table.Widths = widths;
+                    Cell tmp;
+                    if (arrayList.Count == 0) {
+                        table.AddCell(Cell.DummyCell);
+                    }
+                    else {
+                        tmp = new Cell();
+                        tmp.Border = NO_BORDER;
+                        tmp.Colspan = 3;
+                        foreach (IElement ele in arrayList) {
+                            tmp.Add(ele);
+                        }
+                        table.AddCell(tmp);
+                    }
+                    tmp = new Cell();
+                    tmp.Border = NO_BORDER;
+                    table.AddCell(tmp);
+                    table.InsertTable((Table)element);
+                    tmp = new Cell();
+                    tmp.Border = NO_BORDER;
+                    table.AddCell(tmp);
+                    table.AddCell(Cell.DummyCell);
+                    Clear();
+                    arrayList.Add(table);
+                    return;
+                default:
+                    arrayList.Add(element);
+                    break;
+            }
+        }
+
+        /// <summary>
+        /// Add an Object to this cell.
+        /// </summary>
+        /// <param name="o">the object to add</param>
+        /// <returns>always true</returns>
+        public bool Add(Object o) {
+            try {
+                this.AddElement((IElement) o);
+                return true;
+            }
+            catch (BadElementException bee) {
+                throw new Exception(bee.Message);
+            }
+            catch {
+                throw new Exception("You can only add objects that implement the Element interface.");
+            }
+        }
+
+        /// <summary>
+        /// Sets the alignment of this cell.
+        /// </summary>
+        /// <param name="alignment">the new alignment as a string</param>
+        public void SetHorizontalAlignment(string alignment) {
+            if (Util.EqualsIgnoreCase(alignment, ElementTags.ALIGN_CENTER)) {
+                this.HorizontalAlignment = Element.ALIGN_CENTER;
+                return;
+            }
+            if (Util.EqualsIgnoreCase(alignment, ElementTags.ALIGN_RIGHT)) {
+                this.HorizontalAlignment = Element.ALIGN_RIGHT;
+                return;
+            }
+            if (Util.EqualsIgnoreCase(alignment, ElementTags.ALIGN_JUSTIFIED)) {
+                this.HorizontalAlignment = Element.ALIGN_JUSTIFIED;
+                return;
+            }
+            if (Util.EqualsIgnoreCase(alignment, ElementTags.ALIGN_JUSTIFIED_ALL)) {
+                this.HorizontalAlignment = Element.ALIGN_JUSTIFIED_ALL;
+                return;
+            }
+            this.HorizontalAlignment = Element.ALIGN_LEFT;
+        }
+
+        /// <summary>
+        /// Sets the alignment of this paragraph.
+        /// </summary>
+        /// <param name="alignment">the new alignment as a string</param>
+        public void SetVerticalAlignment(string alignment) {
+            if (Util.EqualsIgnoreCase(alignment, ElementTags.ALIGN_MIDDLE)) {
+                this.VerticalAlignment = Element.ALIGN_MIDDLE;
+                return;
+            }
+            if (Util.EqualsIgnoreCase(alignment, ElementTags.ALIGN_BOTTOM)) {
+                this.VerticalAlignment = Element.ALIGN_BOTTOM;
+                return;
+            }
+            if (Util.EqualsIgnoreCase(alignment, ElementTags.ALIGN_BASELINE)) {
+                this.VerticalAlignment = Element.ALIGN_BASELINE;
+                return;
+            }
+            this.VerticalAlignment = Element.ALIGN_TOP;
+        }
+
+        /// <summary>
+        /// Sets the width.
+        /// </summary>
+        /// <value>the new value</value>
+        public override float Width {
+            set {
+                width = value;
+            }
+            get {
+                return width;
+            }
+        }
+
+        /**
+        * Sets the width.
+        * It can be an absolute value "100" or a percentage "20%"
+        *
+        * @param   value   the new value
+        */
+        public void SetWidth(String value) {
+            if (value.EndsWith("%")) {
+                value = value.Substring(0, value.Length - 1);
+                percentage = true;
+            }
+            width = int.Parse(value);
+        }
+        
+        /**
+        * Gets the width as a String.
+        *
+        * @return  a value
+        */
+        public String GetWidthAsString() {
+            String w = width.ToString(System.Globalization.CultureInfo.InvariantCulture);
+            if (w.EndsWith(".0")) w = w.Substring(0, w.Length - 2);
+            if (percentage) w += "%";
+            return w;
+        }
+
+        // methods to retrieve information
+
+        /// <summary>
+        /// Gets the number of Elements in the Cell.
+        /// </summary>
+        /// <value>a size</value>
+        public int Size {
+            get {
+                return arrayList.Count;
+            }
+        }
+
+        /// <summary>
+        /// Checks if the Cell is empty.
+        /// </summary>
+        /// <returns>false if there are non-empty Elements in the Cell.</returns>
+        public bool IsEmpty() {
+            switch (this.Size) {
+                case 0:
+                    return true;
+                case 1:
+                    IElement element = (IElement)arrayList[0];
+                switch (element.Type) {
+                    case Element.CHUNK:
+                        return ((Chunk) element).IsEmpty();
+                    case Element.ANCHOR:
+                    case Element.PHRASE:
+                    case Element.PARAGRAPH:
+                        return ((Phrase) element).IsEmpty();
+                    case Element.LIST:
+                        return ((List) element).IsEmpty();                        
+                }
+                    return false;
+                default:
+                    return false;
+            }
+        }
+
+        /// <summary>
+        /// Makes sure there is at least 1 object in the Cell.
+        /// Otherwise it might not be shown in the table.
+        /// </summary>
+        internal void Fill() {
+            if (this.Size == 0) arrayList.Add(new Paragraph(0));
+        }
+
+        /// <summary>
+        /// Checks if the Cell is empty.
+        /// </summary>
+        /// <returns>false if there are non-empty Elements in the Cell.</returns>
+        public bool IsTable() {
+            return (this.Size == 1) && (((IElement)arrayList[0]).Type == Element.TABLE);
+        }
+
+        /// <summary>
+        /// Gets Elements.
+        /// </summary>
+        /// <value>an ArrayList</value>
+        public ArrayList Elements {
+            get {
+                return arrayList;
+            }
+        }
+
+        /// <summary>
+        /// Gets/Sets the horizontal Element.
+        /// </summary>
+        /// <value>a value</value>
+        public int HorizontalAlignment {
+            get {
+                return horizontalAlignment;
+            }
+
+            set {
+                horizontalAlignment = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets/sets the vertical Element.
+        /// </summary>
+        /// <value>a value</value>
+        public int VerticalAlignment {
+            get {
+                return verticalAlignment;
+            }
+
+            set {
+                verticalAlignment = value;
+            }
+        }
+
+        /**
+         * Gets the colspan.
+         *
+         * @return    a value
+         */
+        /// <summary>
+        /// Gets/sets the colspan.
+        /// </summary>
+        /// <value>a value</value>
+        public int Colspan {
+            get {
+                return colspan;
+            }
+
+            set {
+                colspan = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets/sets the rowspan.
+        /// </summary>
+        /// <value>a value</value>
+        public int Rowspan {
+            get {
+                return rowspan;
+            }
+
+            set {
+                rowspan = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets/sets the leading.
+        /// </summary>
+        /// <value>a value</value>
+        public float Leading {
+            get {
+                if (float.IsNaN(leading)) {
+                    return 16;
+                }
+                return leading;
+            }
+
+            set {
+                leading = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets/sets header
+        /// </summary>
+        /// <value>a value</value>
+        public bool Header {
+            get {
+                return header;
+            }
+
+            set {
+                header = value;
+            }
+        }
+
+        /**
+         * Get nowrap.
+         *
+         * @return    a value
+         */
+        /// <summary>
+        /// Get/set nowrap.
+        /// </summary>
+        /// <value>a value</value>
+        public bool NoWrap {
+            get {
+                return (maxLines == 1);
+            }
+
+            set {
+                maxLines = 1;
+            }
+        }
+
+        /// <summary>
+        /// Clears all the Elements of this Cell.
+        /// </summary>
+        public void Clear() {
+            arrayList.Clear();
+        }
+
+        /// <summary>
+        /// This property throws an Exception.
+        /// </summary>
+        /// <value>none</value>
+        public override float Top {
+            get {
+                throw new Exception("Dimensions of a Cell can't be calculated. See the FAQ.");
+            }
+
+            set {
+                throw new Exception("Dimensions of a Cell can't be calculated. See the FAQ.");
+            }
+        }
+
+        /// <summary>
+        /// This property throws an Exception.
+        /// </summary>
+        /// <value>none</value>
+        public override float Bottom {
+            get {
+                throw new Exception("Dimensions of a Cell can't be calculated. See the FAQ.");
+            }
+
+            set {
+                throw new Exception("Dimensions of a Cell can't be calculated. See the FAQ.");
+            }
+        }
+
+        /// <summary>
+        /// This property throws an Exception.
+        /// </summary>
+        /// <value>none</value>
+        public override float Left {
+            get {
+                throw new Exception("Dimensions of a Cell can't be calculated. See the FAQ.");
+            }
+
+            set {
+                throw new Exception("Dimensions of a Cell can't be calculated. See the FAQ.");
+            }
+        }
+
+        /// <summary>
+        /// This property throws an Exception.
+        /// </summary>
+        /// <value>none</value>
+        public override float Right {
+            get {
+                throw new Exception("Dimensions of a Cell can't be calculated. See the FAQ.");
+            }
+
+            set {
+                throw new Exception("Dimensions of a Cell can't be calculated. See the FAQ.");
+            }
+        }
+
+        /// <summary>
+        /// This method throws an Exception.
+        /// </summary>
+        /// <param name="margin">new value</param>
+        /// <returns>none</returns>
+        public float GetTop(int margin) {
+            throw new Exception("Dimensions of a Cell can't be calculated. See the FAQ.");
+        }
+
+        /// <summary>
+        /// This method throws an Exception.
+        /// </summary>
+        /// <param name="margin">new value</param>
+        /// <returns>none</returns>
+        public float GetBottom(int margin) {
+            throw new Exception("Dimensions of a Cell can't be calculated. See the FAQ.");
+        }
+
+        /// <summary>
+        /// This method throws an Exception.
+        /// </summary>
+        /// <param name="margin">new value</param>
+        /// <returns>none</returns>
+        public float GetLeft(int margin) {
+            throw new Exception("Dimensions of a Cell can't be calculated. See the FAQ.");
+        }
+
+        /// <summary>
+        /// This method throws an Exception.
+        /// </summary>
+        /// <param name="margin">new value</param>
+        /// <returns>none</returns>
+        public float GetRight(int margin) {
+            throw new Exception("Dimensions of a Cell can't be calculated. See the FAQ.");
+        }
+
+        /// <summary>
+        /// Checks if a given tag corresponds with this object.
+        /// </summary>
+        /// <param name="tag">the given tag</param>
+        /// <returns>true if the tag corresponds</returns>
+        public static bool IsTag(string tag) {
+            return ElementTags.CELL.Equals(tag);
+        }
+
+        
+        ///<summary>Does this <CODE>Cell</CODE> force a group change? </summary>
+        protected bool groupChange = true;
+
+        /// <summary>
+        /// Does this <CODE>Cell</CODE> force a group change?
+        /// </summary>
+        public bool GroupChange {
+            get {
+                return groupChange;
+            }
+
+            set {
+                groupChange = value;
+            }
+        }
+
+        /// <summary>
+        /// get/set maxLines value
+        /// </summary>
+        public int MaxLines {
+            get {
+                return maxLines;
+            }
+
+            set {
+                maxLines = value;
+            }
+        }
+
+        /// <summary>
+        /// Maximum number of lines allowed in the cell.  
+        /// The default value of this property is not to limit the maximum number of lines
+        /// (contributed by dperezcar@fcc.es)
+        /// </summary>
+        protected int maxLines = int.MaxValue;
+
+        /// <summary>
+        /// get/set showTruncation value
+        /// </summary>
+        public string ShowTruncation {
+            get {
+                return showTruncation;
+            }
+
+            set {
+                showTruncation = value;
+            }
+        }
+
+        /// <summary>
+        /// If a truncation happens due to the {@link #maxLines} property, then this text will 
+        /// be added to indicate a truncation has happened.
+        /// Default value is null, and means avoiding marking the truncation.  
+        /// A useful value of this property could be e.g. "..."
+        /// (contributed by dperezcar@fcc.es)
+        /// </summary>
+        private string showTruncation;
+
+        /// <summary>
+        /// get/set useAscender value
+        /// </summary>
+        public bool UseAscender {
+            get {
+                return useAscender;
+            }
+
+            set {
+                useAscender = value;
+            }
+        }
+
+        /// <summary>
+        /// get/set useDescender value
+        /// </summary>
+        public bool UseDescender {
+            get {
+                return useDescender;
+            }
+
+            set {
+                useDescender = value;
+            }
+        }
+
+        /// <summary>
+        /// get/set useBorderPadding value
+        /// </summary>
+        public bool UseBorderPadding {
+            get {
+                return useBorderPadding;
+            }
+
+            set {
+                useBorderPadding = value;
+            }
+        }
+        /**
+        * Creates a PdfPCell based on this Cell object.
+        * @return a PdfPCell
+        * @throws BadElementException
+        */
+        public PdfPCell CreatePdfPCell() {
+            if (rowspan > 1) throw new BadElementException("PdfPCells can't have a rowspan > 1");
+            if (IsTable()) return new PdfPCell(((Table)arrayList[0]).CreatePdfPTable());
+            PdfPCell cell = new PdfPCell();
+            cell.VerticalAlignment = verticalAlignment;
+            cell.HorizontalAlignment = horizontalAlignment;
+            cell.Colspan = colspan;
+            cell.UseBorderPadding = useBorderPadding;
+            cell.UseDescender = useDescender;
+            cell.SetLeading(Leading, 0);
+            cell.CloneNonPositionParameters(this);
+            cell.NoWrap = noWrap;
+            foreach (IElement i in Elements) {
+                if (i.Type == Element.PHRASE || i.Type == Element.PARAGRAPH) {
+                    Paragraph p = new Paragraph((Phrase)i);
+                    p.Alignment = horizontalAlignment;
+                    cell.AddElement(p);
+                }
+                else
+                    cell.AddElement(i);
+            }
+            return cell;
+        }
+    }
+}

src/core/iTextSharp/text/Chapter.cs

@@ -0,0 +1,142 @@
+using System;
+using System.Collections;
+using System.util;
+using iTextSharp.text.factories;
+
+/*
+ * $Id: Chapter.cs,v 1.10 2008/05/13 11:25:08 psoares33 Exp $
+ * 
+ *
+ * Copyright 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ *
+ */
+
+namespace iTextSharp.text 
+{
+    /// <summary>
+    /// A Chapter is a special Section.
+    /// </summary>
+    /// <remarks>
+    /// A chapter number has to be created using a Paragraph as title
+    /// and an int as chapter number. The chapter number is shown be
+    /// default. If you don't want to see the chapter number, you have to set the
+    /// numberdepth to 0.
+    /// </remarks>
+    /// <example>
+    /// <code>
+    /// Paragraph title2 = new Paragraph("This is Chapter 2", FontFactory.GetFont(FontFactory.HELVETICA, 18, Font.BOLDITALIC, new Color(0, 0, 255)));
+    /// <strong>Chapter chapter2 = new Chapter(title2, 2);
+    /// chapter2.SetNumberDepth(0);</strong>
+    /// Paragraph someText = new Paragraph("This is some text");
+    /// <strong>chapter2.Add(someText);</strong>
+    /// Paragraph title21 = new Paragraph("This is Section 1 in Chapter 2", FontFactory.GetFont(FontFactory.HELVETICA, 16, Font.BOLD, new Color(255, 0, 0)));
+    /// Section section1 = <strong>chapter2.AddSection(title21);</strong>
+    /// Paragraph someSectionText = new Paragraph("This is some silly paragraph in a chapter and/or section. It contains some text to test the functionality of Chapters and Section.");
+    /// section1.Add(someSectionText);
+    /// </code>
+    /// </example>
+    public class Chapter : Section 
+    {
+    
+        // constructors
+    
+        /**
+        * Constructs a new <CODE>Chapter</CODE>.
+        * @param   number      the Chapter number
+        */
+        
+        public Chapter(int number) : base (null, 1) {
+            numbers = new ArrayList();
+            numbers.Add(number);
+            triggerNewPage = true;
+        }
+
+        /// <summary>
+        /// Constructs a new Chapter.
+        /// </summary>
+        /// <param name="title">the Chapter title (as a Paragraph)</param>
+        /// <param name="number">the Chapter number</param>
+        /// <overoads>
+        /// Has three overloads.
+        /// </overoads>
+        public Chapter(Paragraph title, int number) : base(title, 1) 
+        {
+            numbers = new ArrayList();
+            numbers.Add(number);
+            triggerNewPage = true;
+        }
+    
+        /// <summary>
+        /// Constructs a new Chapter.
+        /// </summary>
+        /// <param name="title">the Chapter title (as a string)</param>
+        /// <param name="number">the Chapter number</param>
+        /// <overoads>
+        /// Has three overloads.
+        /// </overoads>
+        public Chapter(string title, int number) : this(new Paragraph(title), number) {}
+    
+        // implementation of the Element-methods
+    
+        /// <summary>
+        /// Gets the type of the text element.
+        /// </summary>
+        /// <value>a type</value>
+        public override int Type {
+            get {
+                return Element.CHAPTER;
+            }
+        }
+    
+        /**
+        * @see com.lowagie.text.Element#isNestable()
+        * @since   iText 2.0.8
+        */
+        public override bool IsNestable() {
+            return false;
+        }
+    }
+}

src/core/iTextSharp/text/ChapterAutoNumber.cs

@@ -0,0 +1,101 @@
+using System;
+
+/*
+ * Copyright 2005 by Michael Niedermair.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+
+namespace iTextSharp.text {
+
+    /**
+    * Chapter with auto numbering.
+    *
+    * @author Michael Niedermair
+    */
+    public class ChapterAutoNumber : Chapter {
+
+        /**
+        * Create a new object.
+        *
+        * @param para     the Chapter title (as a <CODE>Paragraph</CODE>)
+        */
+        public ChapterAutoNumber(Paragraph para) : base(para, 0) {
+        }
+
+        /**
+        * Create a new objet.
+        * 
+        * @param title     the Chapter title (as a <CODE>String</CODE>)
+        */
+        public ChapterAutoNumber(String title) : base(title, 0) {
+        }
+
+        /**
+        * Create a new section for this chapter and ad it.
+        *
+        * @param title  the Section title (as a <CODE>String</CODE>)
+        * @return Returns the new section.
+        */
+        public override Section AddSection(String title) {
+    	    if (AddedCompletely) {
+    		    throw new InvalidOperationException("This LargeElement has already been added to the Document.");
+    	    }
+            return AddSection(title, 2);
+        }
+
+        /**
+        * Create a new section for this chapter and add it.
+        *
+        * @param title  the Section title (as a <CODE>Paragraph</CODE>)
+        * @return Returns the new section.
+        */
+        public override Section AddSection(Paragraph title) {
+    	    if (AddedCompletely) {
+    		    throw new InvalidOperationException("This LargeElement has already been added to the Document.");
+    	    }
+            return AddSection(title, 2);
+        }
+    }
+}

src/core/iTextSharp/text/Chunk.cs

@@ -0,0 +1,733 @@
+using System;
+using System.Text;
+using System.Collections;
+using System.util;
+
+using iTextSharp.text.pdf;
+using iTextSharp.text.html;
+using iTextSharp.text.factories;
+using iTextSharp.text.pdf.draw;
+
+/*
+ * $Id: Chunk.cs,v 1.20 2008/05/13 11:25:09 psoares33 Exp $
+ * 
+ *
+ * Copyright 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+
+namespace iTextSharp.text {
+    /// <summary>
+    /// This is the smallest significant part of text that can be added to a document.
+    /// </summary>
+    /// <remarks>
+    /// Most elements can be divided in one or more Chunks.
+    /// A chunk is a string with a certain Font.
+    /// all other layoutparameters should be defined in the object to which
+    /// this chunk of text is added.
+    /// </remarks>
+    /// <example>
+    /// <code>
+    /// <strong>Chunk chunk = new Chunk("Hello world", FontFactory.GetFont(FontFactory.COURIER, 20, Font.ITALIC, new Color(255, 0, 0)));</strong>
+    /// document.Add(chunk);
+    /// </code>
+    /// </example>
+    public class Chunk : IElement {
+
+        // public static membervariables
+
+        /** The character stand in for an image or a separator. */
+        public const string OBJECT_REPLACEMENT_CHARACTER = "\ufffc";
+
+        ///<summary> This is a Chunk containing a newline. </summary>
+        public static readonly Chunk NEWLINE = new Chunk("\n");
+
+    /** This is a Chunk containing a newpage. */
+        public static readonly Chunk NEXTPAGE = new Chunk("");
+        static Chunk() {
+            NEXTPAGE.SetNewPage();
+        }
+
+
+        // member variables
+
+        ///<summary> This is the content of this chunk of text. </summary>
+        protected StringBuilder content = null;
+
+        ///<summary> This is the Font of this chunk of text. </summary>
+        protected Font font = null;
+
+        ///<summary> Contains some of the attributes for this Chunk. </summary>
+        protected Hashtable attributes = null;
+
+        // constructors
+
+        /// <summary>
+        /// Empty constructor.
+        /// </summary>
+        /// <overloads>
+        /// Has six overloads.
+        /// </overloads>
+	    public Chunk() {
+		    this.content = new StringBuilder();
+		    this.font = new Font();
+	    }
+
+        /**
+        * A <CODE>Chunk</CODE> copy constructor.
+        * @param ck the <CODE>Chunk</CODE> to be copied
+        */    
+        public Chunk(Chunk ck) {
+            if (ck.content != null) {
+                content = new StringBuilder(ck.content.ToString());
+            }
+            if (ck.font != null) {
+                font = new Font(ck.font);
+            }
+        }
+        
+        /// <summary>
+        /// Constructs a chunk of text with a certain content and a certain Font.
+        /// </summary>
+        /// <param name="content">the content</param>
+        /// <param name="font">the font</param>
+        public Chunk(string content, Font font) {
+            this.content = new StringBuilder(content);
+            this.font = font;
+        }
+
+        /// <summary>
+        /// Constructs a chunk of text with a certain content, without specifying a Font.
+        /// </summary>
+        /// <param name="content">the content</param>
+        public Chunk(string content) : this(content, new Font()) {}
+
+        /**
+        * Constructs a chunk of text with a char and a certain <CODE>Font</CODE>.
+        *
+        * @param    c        the content
+        * @param    font        the font
+        */
+        public Chunk(char c, Font font) {
+            this.content = new StringBuilder();
+            this.content.Append(c);
+            this.font = font;
+        }
+            
+        /**
+        * Constructs a chunk of text with a char, without specifying a <CODE>Font</CODE>.
+        *
+        * @param    c        the content
+        */
+        public Chunk(char c) : this(c, new Font()) {
+        }
+
+        /// <summary>
+        /// Constructs a chunk containing an Image.
+        /// </summary>
+        /// <param name="image">the image</param>
+        /// <param name="offsetX">the image offset in the x direction</param>
+        /// <param name="offsetY">the image offset in the y direction</param>
+        public Chunk(Image image, float offsetX, float offsetY) : this(OBJECT_REPLACEMENT_CHARACTER, new Font()) {
+            Image copyImage = Image.GetInstance(image);
+            copyImage.SetAbsolutePosition(float.NaN, float.NaN);
+            SetAttribute(IMAGE, new Object[]{copyImage, offsetX, offsetY, false});
+        }
+
+        /**
+        * Key for drawInterface of the Separator.
+        * @since   2.1.2
+        */
+        public const String SEPARATOR = "SEPARATOR";
+        
+        /**
+        * Creates a separator Chunk.
+        * Note that separator chunks can't be used in combination with tab chunks!
+        * @param   separator   the drawInterface to use to draw the separator.
+        * @since   2.1.2
+        */
+        public Chunk(IDrawInterface separator) : this(separator, false) {
+        }   
+        
+        /**
+        * Creates a separator Chunk.
+        * Note that separator chunks can't be used in combination with tab chunks!
+        * @param   separator   the drawInterface to use to draw the separator.
+        * @param   vertical    true if this is a vertical separator
+        * @since   2.1.2
+        */
+        public Chunk(IDrawInterface separator, bool vertical) : this(OBJECT_REPLACEMENT_CHARACTER, new Font()) {
+            SetAttribute(SEPARATOR, new Object[] {separator, vertical});
+        }
+
+        /**
+        * Key for drawInterface of the tab.
+        * @since   2.1.2
+        */
+        public const String TAB = "TAB";
+        
+        /**
+        * Creates a tab Chunk.
+        * Note that separator chunks can't be used in combination with tab chunks!
+        * @param   separator   the drawInterface to use to draw the tab.
+        * @param   tabPosition an X coordinate that will be used as start position for the next Chunk.
+        * @since   2.1.2
+        */
+        public Chunk(IDrawInterface separator, float tabPosition) : this(separator, tabPosition, false) {
+        }
+        
+        /**
+        * Creates a tab Chunk.
+        * Note that separator chunks can't be used in combination with tab chunks!
+        * @param   separator   the drawInterface to use to draw the tab.
+        * @param   tabPosition an X coordinate that will be used as start position for the next Chunk.
+        * @param   newline     if true, a newline will be added if the tabPosition has already been reached.
+        * @since   2.1.2
+        */
+        public Chunk(IDrawInterface separator, float tabPosition, bool newline) : this(OBJECT_REPLACEMENT_CHARACTER, new Font()) {
+            if (tabPosition < 0) {
+                throw new ArgumentException("A tab position may not be lower than 0; yours is " + tabPosition);
+            }
+            SetAttribute(TAB, new Object[] {separator, tabPosition, newline, 0});
+        }
+
+        /// <summary>
+        /// Constructs a chunk containing an Image.
+        /// </summary>
+        /// <param name="image">the image</param>
+        /// <param name="offsetX">the image offset in the x direction</param>
+        /// <param name="offsetY">the image offset in the y direction</param>
+        /// <param name="changeLeading">true if the leading has to be adapted to the image</param>
+        public Chunk(Image image, float offsetX, float offsetY, bool changeLeading) : this(OBJECT_REPLACEMENT_CHARACTER, new Font()) {
+            SetAttribute(IMAGE, new Object[]{image, offsetX, offsetY, changeLeading});
+        }
+
+        // implementation of the Element-methods
+
+        /// <summary>
+        /// Processes the element by adding it (or the different parts) to an
+        /// IElementListener.
+        /// </summary>
+        /// <param name="listener">an IElementListener</param>
+        /// <returns>true if the element was processed successfully</returns>
+        public bool Process(IElementListener listener) {
+            try {
+                return listener.Add(this);
+            }
+            catch (DocumentException) {
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Gets the type of the text element.
+        /// </summary>
+        /// <value>a type</value>
+        public int Type {
+            get {
+                return Element.CHUNK;
+            }
+        }
+
+        /// <summary>
+        /// Gets all the chunks in this element.
+        /// </summary>
+        /// <value>an ArrayList</value>
+        public ArrayList Chunks {
+            get {
+                ArrayList tmp = new ArrayList();
+                tmp.Add(this);
+                return tmp;
+            }
+        }
+
+        // methods
+
+        /// <summary>
+        /// appends some text to this Chunk.
+        /// </summary>
+        /// <param name="str">a string</param>
+        /// <returns>a StringBuilder</returns>
+        public StringBuilder Append(string str) {
+            return content.Append(str);
+        }
+
+        // methods to retrieve information
+
+        /// <summary>
+        /// Get/set the font of this Chunk.
+        /// </summary>
+        /// <value>a Font</value>
+        public virtual Font Font {
+            get {
+                return font;
+            }
+
+            set {
+                this.font = value;
+            }
+        }
+
+
+        /// <summary>
+        /// Returns the content of this Chunk.
+        /// </summary>
+        /// <value>a string</value>
+        public virtual string Content {
+            get {
+                return content.ToString();
+            }
+        }
+
+        public override string ToString() {
+            return content.ToString();
+        }
+
+
+        /// <summary>
+        /// Checks is this Chunk is empty.
+        /// </summary>
+        /// <returns>false if the Chunk contains other characters than space.</returns>
+        public virtual bool IsEmpty() {
+            return (content.ToString().Trim().Length == 0) && (content.ToString().IndexOf("\n") == -1) && (attributes == null);
+        }
+
+        /**
+        * Gets the width of the Chunk in points.
+        * @return a width in points
+        */
+        public float GetWidthPoint() {
+            if (GetImage() != null) {
+                return GetImage().ScaledWidth;
+            }
+            return font.GetCalculatedBaseFont(true).GetWidthPoint(Content, font.CalculatedSize) * HorizontalScaling;
+        }
+    
+        /// <summary>
+        /// Checks the attributes of this Chunk.
+        /// </summary>
+        /// <returns>false if there aren't any.</returns>
+        public bool HasAttributes() {
+            return attributes != null;
+        }
+
+        /// <summary>
+        /// Gets the attributes for this Chunk.
+        /// </summary>
+        /// <remarks>
+        /// It may be null.
+        /// </remarks>
+        /// <value>a Hashtable</value>
+        public Hashtable Attributes {
+            get {
+                return attributes;
+            }
+            set {
+                attributes = value;
+            }
+        }
+
+        /// <summary>
+        /// Sets an arbitrary attribute.
+        /// </summary>
+        /// <param name="name">the key for the attribute</param>
+        /// <param name="obj">the value of the attribute</param>
+        /// <returns>this Chunk</returns>
+        private Chunk SetAttribute(string name, Object obj) {
+            if (attributes == null)
+                attributes = new Hashtable();
+            attributes[name] = obj;
+            return this;
+        }
+
+        /** Key for text horizontal scaling. */
+        public const string HSCALE = "HSCALE";
+
+        /**
+        * Sets the text horizontal scaling. A value of 1 is normal and a value of 0.5f
+        * shrinks the text to half it's width.
+        * @param scale the horizontal scaling factor
+        * @return this <CODE>Chunk</CODE>
+        */    
+        public Chunk SetHorizontalScaling(float scale) {
+            return SetAttribute(HSCALE, scale);
+        }
+        
+        /**
+        * Gets the horizontal scaling.
+        * @return a percentage in float
+        */
+        public float HorizontalScaling {
+            get {
+                if (attributes == null) return 1f;
+                Object f = attributes[HSCALE];
+                if (f == null) return 1f;
+                return (float)f;
+            }
+        }
+        
+        ///<summary> Key for underline. </summary>
+        public const string UNDERLINE = "UNDERLINE";
+
+        /**
+        * Sets an horizontal line that can be an underline or a strikethrough.
+        * Actually, the line can be anywhere vertically and has always the
+        * <CODE>Chunk</CODE> width. Multiple call to this method will
+        * produce multiple lines.
+        * @param thickness the absolute thickness of the line
+        * @param yPosition the absolute y position relative to the baseline
+        * @return this <CODE>Chunk</CODE>
+        */    
+        public Chunk SetUnderline(float thickness, float yPosition) {
+            return SetUnderline(null, thickness, 0f, yPosition, 0f, PdfContentByte.LINE_CAP_BUTT);
+        }
+
+        /**
+        * Sets an horizontal line that can be an underline or a strikethrough.
+        * Actually, the line can be anywhere vertically and has always the
+        * <CODE>Chunk</CODE> width. Multiple call to this method will
+        * produce multiple lines.
+        * @param color the color of the line or <CODE>null</CODE> to follow
+        * the text color
+        * @param thickness the absolute thickness of the line
+        * @param thicknessMul the thickness multiplication factor with the font size
+        * @param yPosition the absolute y position relative to the baseline
+        * @param yPositionMul the position multiplication factor with the font size
+        * @param cap the end line cap. Allowed values are
+        * PdfContentByte.LINE_CAP_BUTT, PdfContentByte.LINE_CAP_ROUND and
+        * PdfContentByte.LINE_CAP_PROJECTING_SQUARE
+        * @return this <CODE>Chunk</CODE>
+        */    
+        public Chunk SetUnderline(Color color, float thickness, float thicknessMul, float yPosition, float yPositionMul, int cap) {
+            if (attributes == null)
+                attributes = new Hashtable();
+            Object[] obj = {color, new float[]{thickness, thicknessMul, yPosition, yPositionMul, (float)cap}};
+            Object[][] unders = Utilities.AddToArray((Object[][])attributes[UNDERLINE], obj);
+            return SetAttribute(UNDERLINE, unders);
+        }
+        
+        ///<summary> Key for sub/basescript. </summary>
+        public const string SUBSUPSCRIPT = "SUBSUPSCRIPT";
+
+        /// <summary>
+        /// Sets the text displacement relative to the baseline. Positive values rise the text,
+        /// negative values lower the text.
+        /// </summary>
+        /// <remarks>
+        /// It can be used to implement sub/basescript.
+        /// </remarks>
+        /// <param name="rise">the displacement in points</param>
+        /// <returns>this Chunk</returns>
+        public Chunk SetTextRise(float rise) {
+            return SetAttribute(SUBSUPSCRIPT, rise);
+        }
+
+        public float GetTextRise() {
+            if (attributes != null && attributes.ContainsKey(SUBSUPSCRIPT)) {
+                return (float)attributes[SUBSUPSCRIPT];
+            }
+            return 0.0f;
+        }
+
+        ///<summary> Key for text skewing. </summary>
+        public const string SKEW = "SKEW";
+
+        /**
+        * Skews the text to simulate italic and other effects.
+        * Try <CODE>alpha=0</CODE> and <CODE>beta=12</CODE>.
+        * @param alpha the first angle in degrees
+        * @param beta the second angle in degrees
+        * @return this <CODE>Chunk</CODE>
+        */    
+        public Chunk SetSkew(float alpha, float beta) {
+            alpha = (float)Math.Tan(alpha * Math.PI / 180);
+            beta = (float)Math.Tan(beta * Math.PI / 180);
+            return SetAttribute(SKEW, new float[]{alpha, beta});
+        }
+
+        ///<summary> Key for background. </summary>
+        public const string BACKGROUND = "BACKGROUND";
+
+        /// <summary>
+        /// Sets the color of the background Chunk.
+        /// </summary>
+        /// <param name="color">the color of the background</param>
+        /// <returns>this Chunk</returns>
+        public Chunk SetBackground(Color color) {
+            return SetBackground(color, 0, 0, 0, 0);
+        }
+
+        /** Sets the color and the size of the background <CODE>Chunk</CODE>.
+        * @param color the color of the background
+        * @param extraLeft increase the size of the rectangle in the left
+        * @param extraBottom increase the size of the rectangle in the bottom
+        * @param extraRight increase the size of the rectangle in the right
+        * @param extraTop increase the size of the rectangle in the top
+        * @return this <CODE>Chunk</CODE>
+        */
+        public Chunk SetBackground(Color color, float extraLeft, float extraBottom, float extraRight, float extraTop) {
+            return SetAttribute(BACKGROUND, new Object[]{color, new float[]{extraLeft, extraBottom, extraRight, extraTop}});
+        }
+
+        ///<summary> Key for text rendering mode.</summary>
+        public const string TEXTRENDERMODE = "TEXTRENDERMODE";
+
+        /** Sets the text rendering mode. It can outline text, simulate bold and make
+        * text invisible.
+        * @param mode the text rendering mode. It can be <CODE>PdfContentByte.TEXT_RENDER_MODE_FILL</CODE>,
+        * <CODE>PdfContentByte.TEXT_RENDER_MODE_STROKE</CODE>, <CODE>PdfContentByte.TEXT_RENDER_MODE_FILL_STROKE</CODE>
+        * and <CODE>PdfContentByte.TEXT_RENDER_MODE_INVISIBLE</CODE>.
+        * @param strokeWidth the stroke line width for the modes <CODE>PdfContentByte.TEXT_RENDER_MODE_STROKE</CODE> and
+        * <CODE>PdfContentByte.TEXT_RENDER_MODE_FILL_STROKE</CODE>.
+        * @param strokeColor the stroke color or <CODE>null</CODE> to follow the text color
+        * @return this <CODE>Chunk</CODE>
+        */    
+        public Chunk SetTextRenderMode(int mode, float strokeWidth, Color strokeColor) {
+            return SetAttribute(TEXTRENDERMODE, new Object[]{mode, strokeWidth, strokeColor});
+        }
+
+        ///<summary> Key for split character. </summary>
+        public const string SPLITCHARACTER = "SPLITCHARACTER";
+
+        /// <summary>
+        /// Sets the split characters.
+        /// </summary>
+        /// <param name="splitCharacter">the SplitCharacter interface</param>
+        /// <returns>this Chunk</returns>
+        public Chunk SetSplitCharacter(ISplitCharacter splitCharacter) {
+            return SetAttribute(SPLITCHARACTER, splitCharacter);
+        }
+
+        ///<summary> Key for hyphenation. </summary>
+        public const string HYPHENATION = "HYPHENATION";
+
+        /// <summary>
+        /// sets the hyphenation engine to this Chunk.
+        /// </summary>
+        /// <param name="hyphenation">the hyphenation engine</param>
+        /// <returns>this Chunk</returns>
+        public Chunk SetHyphenation(IHyphenationEvent hyphenation) {
+            return SetAttribute(HYPHENATION, hyphenation);
+        }
+
+        ///<summary> Key for remote goto. </summary>
+        public const string REMOTEGOTO = "REMOTEGOTO";
+
+        /// <summary>
+        /// Sets a goto for a remote destination for this Chunk.
+        /// </summary>
+        /// <param name="filename">the file name of the destination document</param>
+        /// <param name="name">the name of the destination to go to</param>
+        /// <returns>this Chunk</returns>
+        public Chunk SetRemoteGoto(string filename, string name) {
+            return SetAttribute(REMOTEGOTO, new Object[]{filename, name});
+        }
+
+        /// <summary>
+        /// Sets a goto for a remote destination for this Chunk.
+        /// </summary>
+        /// <param name="filename">the file name of the destination document</param>
+        /// <param name="page">the page of the destination to go to. First page is 1</param>
+        /// <returns>this Chunk</returns>
+        public Chunk SetRemoteGoto(string filename, int page) {
+            return SetAttribute(REMOTEGOTO, new Object[]{filename, page});
+        }
+
+        ///<summary> Key for local goto. </summary>
+        public const string LOCALGOTO = "LOCALGOTO";
+
+        /// <summary>
+        /// Sets a local goto for this Chunk.
+        /// </summary>
+        /// <remarks>
+        /// There must be a local destination matching the name.
+        /// </remarks>
+        /// <param name="name">the name of the destination to go to</param>
+        /// <returns>this Chunk</returns>
+        public Chunk SetLocalGoto(string name) {
+            return SetAttribute(LOCALGOTO, name);
+        }
+
+        ///<summary> Key for local destination. </summary>
+        public const string LOCALDESTINATION = "LOCALDESTINATION";
+
+        /// <summary>
+        /// Sets a local destination for this Chunk.
+        /// </summary>
+        /// <param name="name">the name for this destination</param>
+        /// <returns>this Chunk</returns>
+        public Chunk SetLocalDestination(string name) {
+            return SetAttribute(LOCALDESTINATION, name);
+        }
+
+        ///<summary> Key for generic tag. </summary>
+        public const string GENERICTAG = "GENERICTAG";
+
+        /// <summary>
+        /// Sets the generic tag Chunk.
+        /// </summary>
+        /// <remarks>
+        /// The text for this tag can be retrieved with PdfPageEvent.
+        /// </remarks>
+        /// <param name="text">the text for the tag</param>
+        /// <returns>this Chunk</returns>
+        public Chunk SetGenericTag(string text) {
+            return SetAttribute(GENERICTAG, text);
+        }
+
+        ///<summary> Key for image. </summary>
+        public const string IMAGE = "IMAGE";
+
+        /// <summary>
+        /// Returns the image.
+        /// </summary>
+        /// <value>an Image</value>
+        public Image GetImage() {
+            if (attributes == null) return null;
+            Object[] obj = (Object[])attributes[Chunk.IMAGE];
+            if (obj == null)
+                return null;
+            else {
+                return (Image)obj[0];
+            }
+        }
+
+        /// <summary>
+        /// Checks if a given tag corresponds with this object.
+        /// </summary>
+        /// <param name="tag">the given tag</param>
+        /// <returns>true if the tag corresponds</returns>
+        public static bool IsTag(string tag) {
+            return ElementTags.CHUNK.Equals(tag);
+        }
+
+        ///<summary> Key for Action. </summary>
+        public const string ACTION = "ACTION";
+
+        /// <summary>
+        /// Sets an action for this Chunk.
+        /// </summary>
+        /// <param name="action">the action</param>
+        /// <returns>this Chunk</returns>
+        public Chunk SetAction(PdfAction action) {
+            return SetAttribute(ACTION, action);
+        }
+
+        /// <summary>
+        /// Sets an anchor for this Chunk.
+        /// </summary>
+        /// <param name="url">the Uri to link to</param>
+        /// <returns>this Chunk</returns>
+        public Chunk SetAnchor(Uri url) {
+            return SetAttribute(ACTION, new PdfAction(url));
+        }
+
+        /// <summary>
+        /// Sets an anchor for this Chunk.
+        /// </summary>
+        /// <param name="url">the url to link to</param>
+        /// <returns>this Chunk</returns>
+        public Chunk SetAnchor(string url) {
+            return SetAttribute(ACTION, new PdfAction(url));
+        }
+
+        ///<summary> Key for newpage. </summary>
+        public const string NEWPAGE = "NEWPAGE";
+
+        /// <summary>
+        /// Sets a new page tag.
+        /// </summary>
+        /// <returns>this Chunk</returns>
+        public Chunk SetNewPage() {
+            return SetAttribute(NEWPAGE, null);
+        }
+
+        ///<summary> Key for annotation. </summary>
+        public const string PDFANNOTATION = "PDFANNOTATION";
+
+        /// <summary>
+        /// Sets a generic annotation to this Chunk.
+        /// </summary>
+        /// <param name="annotation">the annotation</param>
+        /// <returns>this Chunk</returns>
+        public Chunk SetAnnotation(PdfAnnotation annotation) {
+            return SetAttribute(PDFANNOTATION, annotation);
+        }
+
+        /**
+        * @see com.lowagie.text.Element#isContent()
+        * @since   iText 2.0.8
+        */
+        public bool IsContent() {
+            return true;
+        }
+
+        /**
+        * @see com.lowagie.text.Element#isNestable()
+        * @since   iText 2.0.8
+        */
+        public bool IsNestable() {
+            return true;
+        }
+
+        /**
+        * Returns the hyphenation (if present).
+        * @param    hyphenation a HyphenationEvent instance
+        * @since    2.1.2
+        */
+        public IHyphenationEvent GetHyphenation() {
+            if (attributes == null) return null;
+            return (IHyphenationEvent) attributes[Chunk.HYPHENATION];
+        }
+
+        // keys used in PdfChunk
+
+        ///<summary> Key for color. </summary>
+        public const string COLOR = "COLOR";
+
+        ///<summary> Key for encoding. </summary>
+        public const string ENCODING = "ENCODING";
+    }
+}

src/core/iTextSharp/text/Color.cs

@@ -0,0 +1,150 @@
+using System;
+
+namespace iTextSharp.text {
+    /// <summary>
+    /// Base class for Color, serves as wrapper class for <see cref="T:System.Drawing.Color"/>
+    /// to allow extension.
+    /// </summary>
+    public class Color {
+        public static readonly Color WHITE = new Color(255, 255, 255);
+        public static readonly Color LIGHT_GRAY = new Color(192, 192, 192);
+        public static readonly Color GRAY      = new Color(128, 128, 128);
+        public static readonly Color DARK_GRAY  = new Color(64, 64, 64);
+        public static readonly Color BLACK     = new Color(0, 0, 0);
+        public static readonly Color RED       = new Color(255, 0, 0);
+        public static readonly Color PINK      = new Color(255, 175, 175);
+        public static readonly Color ORANGE     = new Color(255, 200, 0);
+        public static readonly Color YELLOW     = new Color(255, 255, 0);
+        public static readonly Color GREEN     = new Color(0, 255, 0);
+        public static readonly Color MAGENTA    = new Color(255, 0, 255);
+        public static readonly Color CYAN     = new Color(0, 255, 255);
+        public static readonly Color BLUE     = new Color(0, 0, 255);
+        private const double FACTOR = 0.7;
+        System.Drawing.Color color;
+
+        /// <summary>
+        /// Constuctor for Color object.
+        /// </summary>
+        /// <param name="red">The red component value for the new Color structure. Valid values are 0 through 255.</param>
+        /// <param name="green">The green component value for the new Color structure. Valid values are 0 through 255.</param>
+        /// <param name="blue">The blue component value for the new Color structure. Valid values are 0 through 255.</param>
+        public Color(int red, int green, int blue) {
+            color = System.Drawing.Color.FromArgb(red, green, blue);
+        }
+
+        /// <summary>
+        /// Constuctor for Color object.
+        /// </summary>
+        /// <param name="red">The red component value for the new Color structure. Valid values are 0 through 255.</param>
+        /// <param name="green">The green component value for the new Color structure. Valid values are 0 through 255.</param>
+        /// <param name="blue">The blue component value for the new Color structure. Valid values are 0 through 255.</param>
+        /// <param name="alpha">The transparency component value for the new Color structure. Valid values are 0 through 255.</param>
+        public Color(int red, int green, int blue, int alpha) {
+            color = System.Drawing.Color.FromArgb(alpha, red, green, blue);
+        }
+
+        /// <summary>
+        /// Constructor for Color object
+        /// </summary>
+        /// <param name="red">The red component value for the new Color structure. Valid values are 0 through 1.</param>
+        /// <param name="green">The green component value for the new Color structure. Valid values are 0 through 1.</param>
+        /// <param name="blue">The blue component value for the new Color structure. Valid values are 0 through 1.</param>
+        public Color(float red, float green, float blue) {
+            color = System.Drawing.Color.FromArgb((int)(red * 255 + .5), (int)(green * 255 + .5), (int)(blue * 255 + .5));
+        }
+
+        /// <summary>
+        /// Constructor for Color object
+        /// </summary>
+        /// <param name="red">The red component value for the new Color structure. Valid values are 0 through 1.</param>
+        /// <param name="green">The green component value for the new Color structure. Valid values are 0 through 1.</param>
+        /// <param name="blue">The blue component value for the new Color structure. Valid values are 0 through 1.</param>
+        /// <param name="alpha">The transparency component value for the new Color structure. Valid values are 0 through 1.</param>
+        public Color(float red, float green, float blue, float alpha) {
+            color = System.Drawing.Color.FromArgb((int)(alpha * 255 + .5), (int)(red * 255 + .5), (int)(green * 255 + .5), (int)(blue * 255 + .5));
+        }
+
+        public Color(int argb) {
+            color = System.Drawing.Color.FromArgb(argb);
+        }
+
+        /// <summary>
+        /// Constructor for Color object
+        /// </summary>
+        /// <param name="color">a Color object</param>
+        /// <overloads>
+        /// Has three overloads.
+        /// </overloads>
+        public Color(System.Drawing.Color color) {
+            this.color = color;
+        }
+
+        /// <summary>
+        /// Gets the red component value of this <see cref="T:System.Drawing.Color"/> structure.
+        /// </summary>
+        /// <value>The red component value of this <see cref="T:System.Drawing.Color"/> structure.</value>
+        public int R {
+            get {
+                return color.R;
+            }
+        }
+
+        /// <summary>
+        /// Gets the green component value of this <see cref="T:System.Drawing.Color"/> structure.
+        /// </summary>
+        /// <value>The green component value of this <see cref="T:System.Drawing.Color"/> structure.</value>
+        public int G {
+            get {
+                return color.G;
+            }
+        }
+
+        /// <summary>
+        /// Gets the blue component value of this <see cref="T:System.Drawing.Color"/> structure.
+        /// </summary>
+        /// <value>The blue component value of this <see cref="T:System.Drawing.Color"/> structure.</value>
+        public int B {
+            get {
+                return color.B;
+            }
+        }
+
+        public Color Brighter() {
+            int r = color.R;
+            int g = color.G;
+            int b = color.B;
+
+            int i = (int)(1.0/(1.0-FACTOR));
+            if ( r == 0 && g == 0 && b == 0) {
+            return new Color(i, i, i);
+                }
+            if ( r > 0 && r < i ) r = i;
+            if ( g > 0 && g < i ) g = i;
+            if ( b > 0 && b < i ) b = i;
+
+            return new Color(Math.Min((int)(r/FACTOR), 255), 
+                    Math.Min((int)(g/FACTOR), 255),
+                    Math.Min((int)(b/FACTOR), 255));
+        }
+
+        public Color Darker() {
+            return new Color(Math.Max((int)(color.R * FACTOR), 0), 
+                    Math.Max((int)(color.G * FACTOR), 0),
+                    Math.Max((int)(color.B * FACTOR), 0));
+        }
+    
+        public override bool Equals(object obj) {
+            if (!(obj is Color))
+                return false;
+            return color.Equals(((Color)obj).color);
+        }
+    
+        public override int GetHashCode() {
+            return color.GetHashCode();
+        }
+
+        public int ToArgb() {
+            return color.ToArgb();
+        }
+    }
+}

src/core/iTextSharp/text/DocWriter.cs

@@ -0,0 +1,416 @@
+using System;
+using System.IO;
+using System.Collections;
+using System.util;
+using iTextSharp.text.pdf;
+/*
+ * $Id: DocWriter.cs,v 1.7 2008/05/13 11:25:09 psoares33 Exp $
+ * 
+ *
+ * Copyright 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+
+namespace iTextSharp.text {
+    /// <summary>
+    /// An abstract Writer class for documents.
+    /// </summary>
+    /// <remarks>
+    /// DocWriter is the abstract class of several writers such
+    /// as PdfWriter and HtmlWriter.
+    /// A DocWriter can be added as a DocListener
+    /// to a certain Document by getting an instance (see method
+    /// GetInstance() in the specific writer-classes).
+    /// Every Element added to the original Document
+    /// will be written to the stream of the listening
+    /// DocWriter.
+    /// </remarks>
+    /// <seealso cref="T:iTextSharp.text.Document"/>
+    /// <seealso cref="T:iTextSharp.text.IDocListener"/>
+    public abstract class DocWriter : IDocListener {
+
+        /// <summary> This is some byte that is often used. </summary>
+        public const byte NEWLINE = (byte)'\n';
+
+        /// <summary> This is some byte that is often used. </summary>
+        public const byte TAB = (byte)'\t';
+
+        /// <summary> This is some byte that is often used. </summary>
+        public const byte LT = (byte)'<';
+
+        /// <summary> This is some byte that is often used. </summary>
+        public const byte SPACE = (byte)' ';
+
+        /// <summary> This is some byte that is often used. </summary>
+        public const byte EQUALS = (byte)'=';
+
+        /// <summary> This is some byte that is often used. </summary>
+        public const byte QUOTE = (byte)'\"';
+
+        /// <summary> This is some byte that is often used. </summary>
+        public const byte GT = (byte)'>';
+
+        /// <summary> This is some byte that is often used. </summary>
+        public const byte FORWARD = (byte)'/';
+
+        // membervariables
+
+        /// <summary> The pageSize. </summary>
+        protected Rectangle pageSize;
+
+        /// <summary> This is the document that has to be written. </summary>
+        protected Document document;
+
+        /// <summary> The stream of this writer. </summary>
+        protected OutputStreamCounter os;
+
+        /// <summary> Is the writer open for writing? </summary>
+        protected bool open = false;
+
+        /// <summary> Do we have to pause all writing actions? </summary>
+        protected bool pause = false;
+
+        /** Closes the stream on document close */
+        protected bool closeStream = true;
+
+        // constructor
+    
+        protected DocWriter() {
+        }
+        /// <summary>
+        /// Constructs a DocWriter.
+        /// </summary>
+        /// <param name="document">The Document that has to be written</param>
+        /// <param name="os">The Stream the writer has to write to.</param>
+        protected DocWriter(Document document, Stream os)  
+        {
+            this.document = document;
+            this.os = new OutputStreamCounter(os);
+        }
+
+        // implementation of the DocListener methods
+
+        /// <summary>
+        /// Signals that an Element was added to the Document.
+        /// </summary>
+        /// <remarks>
+        /// This method should be overriden in the specific DocWriter classes
+        /// derived from this abstract class.
+        /// </remarks>
+        /// <param name="element"></param>
+        /// <returns>false</returns>
+        public virtual bool Add(IElement element) {
+            return false;
+        }
+
+        /// <summary>
+        /// Signals that the Document was opened.
+        /// </summary>
+        public virtual void Open() {
+            open = true;
+        }
+
+        /// <summary>
+        /// Sets the pagesize.
+        /// </summary>
+        /// <param name="pageSize">the new pagesize</param>
+        /// <returns>a boolean</returns>
+        public virtual bool SetPageSize(Rectangle pageSize) {
+            this.pageSize = pageSize;
+            return true;
+        }
+
+        /// <summary>
+        /// Sets the margins.
+        /// </summary>
+        /// <remarks>
+        /// This does nothing. Has to be overridden if needed.
+        /// </remarks>
+        /// <param name="marginLeft">the margin on the left</param>
+        /// <param name="marginRight">the margin on the right</param>
+        /// <param name="marginTop">the margin on the top</param>
+        /// <param name="marginBottom">the margin on the bottom</param>
+        /// <returns></returns>
+        public virtual bool SetMargins(float marginLeft, float marginRight, float marginTop, float marginBottom) {
+            return false;
+        }
+
+        /// <summary>
+        /// Signals that an new page has to be started.
+        /// </summary>
+        /// <remarks>
+        /// This does nothing. Has to be overridden if needed.
+        /// </remarks>
+        /// <returns>true if the page was added, false if not.</returns>
+        public virtual bool NewPage() {
+            if (!open) {
+                return false;
+            }
+            return true;
+        }
+
+        /// <summary>
+        /// Changes the header of this document.
+        /// </summary>
+        /// <remarks>
+        /// This method should be overriden in the specific DocWriter classes
+        /// derived from this abstract class if they actually support the use of
+        /// headers.
+        /// </remarks>
+        /// <value>the new header</value>
+        public virtual HeaderFooter Header {
+            set {}
+        }
+
+        /// <summary>
+        /// Resets the header of this document.
+        /// </summary>
+        /// <remarks>
+        /// This method should be overriden in the specific DocWriter classes
+        /// derived from this abstract class if they actually support the use of
+        /// headers.
+        /// </remarks>
+        public virtual void ResetHeader() {
+        }
+
+        /// <summary>
+        /// Changes the footer of this document.
+        /// </summary>
+        /// <remarks>
+        /// This method should be overriden in the specific DocWriter classes
+        /// derived from this abstract class if they actually support the use of
+        /// footers.
+        /// </remarks>
+        /// <value>the new footer</value>
+        public virtual HeaderFooter Footer {
+            set {}
+        }
+
+        /// <summary>
+        /// Resets the footer of this document.
+        /// </summary>
+        /// <remarks>
+        /// This method should be overriden in the specific DocWriter classes
+        /// derived from this abstract class if they actually support the use of
+        /// footers.
+        /// </remarks>
+        public virtual void ResetFooter() {
+        }
+
+        /// <summary>
+        /// Sets the page number to 0.
+        /// </summary>
+        /// <remarks>
+        /// This method should be overriden in the specific DocWriter classes
+        /// derived from this abstract class if they actually support the use of
+        /// pagenumbers.
+        /// </remarks>
+        public virtual void ResetPageCount() {
+        }
+
+        /// <summary>
+        /// Sets the page number.
+        /// </summary>
+        /// <remarks>
+        /// This method should be overriden in the specific DocWriter classes
+        /// derived from this abstract class if they actually support the use of
+        /// pagenumbers.
+        /// </remarks>
+        public virtual int PageCount {
+            set {}
+        }
+
+        /// <summary>
+        /// Signals that the Document was closed and that no other
+        /// Elements will be added.
+        /// </summary>
+        public virtual void Close() {
+            open = false;
+            os.Flush();
+            if (closeStream)
+                os.Close();
+        }
+
+        // methods
+
+        /// <summary>
+        /// Converts a string into a Byte array
+        /// according to the ISO-8859-1 codepage.
+        /// </summary>
+        /// <param name="text">the text to be converted</param>
+        /// <returns>the conversion result</returns>
+        public static byte[] GetISOBytes(string text) {
+            if (text == null)
+                return null;
+            int len = text.Length;
+            byte[] b = new byte[len];
+            for (int k = 0; k < len; ++k)
+                b[k] = (byte)text[k];
+            return b;
+        }
+
+        /// <summary>
+        /// Let the writer know that all writing has to be paused.
+        /// </summary>
+        public virtual void Pause() {
+            pause = true;
+        }
+
+        /**
+        * Checks if writing is paused.
+        *
+        * @return       <CODE>true</CODE> if writing temporarely has to be paused, <CODE>false</CODE> otherwise.
+        */
+        
+        public bool IsPaused() {
+            return pause;
+        }
+
+        /// <summary>
+        /// Let the writer know that writing may be resumed.
+        /// </summary>
+        public virtual void Resume() {
+            pause = false;
+        }
+
+        /// <summary>
+        /// Flushes the Stream.
+        /// </summary>
+        public virtual void Flush() {
+            os.Flush();
+        }
+
+        /// <summary>
+        /// Writes a string to the stream.
+        /// </summary>
+        /// <param name="str">the string to write</param>
+        protected void Write(string str) {
+            byte[] tmp = GetISOBytes(str);
+            os.Write(tmp, 0, tmp.Length);
+        }
+
+        /// <summary>
+        /// Writes a number of tabs.
+        /// </summary>
+        /// <param name="indent">the number of tabs to add</param>
+        protected void AddTabs(int indent) {
+            os.WriteByte(NEWLINE);
+            for (int i = 0; i < indent; i++) {
+                os.WriteByte(TAB);
+            }
+        }
+
+        /// <summary>
+        /// Writes a key-value pair to the stream.
+        /// </summary>
+        /// <param name="key">the name of an attribute</param>
+        /// <param name="value">the value of an attribute</param>
+        protected void Write(string key, string value) {
+            os.WriteByte(SPACE);
+            Write(key);
+            os.WriteByte(EQUALS);
+            os.WriteByte(QUOTE);
+            Write(value);
+            os.WriteByte(QUOTE);
+        }
+
+        /// <summary>
+        /// Writes a starttag to the stream.
+        /// </summary>
+        /// <param name="tag">the name of the tag</param>
+        protected void WriteStart(string tag) {
+            os.WriteByte(LT);
+            Write(tag);
+        }
+
+        /// <summary>
+        /// Writes an endtag to the stream.
+        /// </summary>
+        /// <param name="tag">the name of the tag</param>
+        protected void WriteEnd(string tag) {
+            os.WriteByte(LT);
+            os.WriteByte(FORWARD);
+            Write(tag);
+            os.WriteByte(GT);
+        }
+
+        /// <summary>
+        /// Writes an endtag to the stream.
+        /// </summary>
+        protected void WriteEnd() {
+            os.WriteByte(SPACE);
+            os.WriteByte(FORWARD);
+            os.WriteByte(GT);
+        }
+
+        /// <summary>
+        /// Writes the markup attributes of the specified MarkupAttributes
+        /// object to the stream.
+        /// </summary>
+        /// <param name="mAtt">the MarkupAttributes to write.</param>
+        /// <returns></returns>
+        protected bool WriteMarkupAttributes(Properties markup) {
+            if (markup == null) return false;
+            foreach (String name in markup.Keys) {
+                Write(name, markup[name]);
+            }
+            markup.Clear();
+            return true;
+        }
+
+        public virtual bool CloseStream {
+            get {
+                return closeStream;
+            }
+            set {
+                closeStream = value;
+            }
+        }
+
+        public virtual bool SetMarginMirroring(bool marginMirroring) {
+            return false;
+        }
+    }
+}

src/core/iTextSharp/text/Document.cs

@@ -0,0 +1,684 @@
+using System;
+using System.Collections;
+
+/*
+ * $Id: Document.cs,v 1.45 2008/05/25 13:08:44 psoares33 Exp $
+ * 
+ *
+ * Copyright 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+
+namespace iTextSharp.text {
+
+    /// <summary>
+    /// A generic Document class.
+    /// </summary>
+    /// <remarks>
+    /// All kinds of Text-elements can be added to a HTMLDocument.
+    /// The Document signals all the listeners when an element
+    /// has been added.<p/>
+    /// <OL>
+    ///     <LI/>Once a document is created you can add some meta information.
+    ///     <LI/>You can also set the headers/footers.
+    ///     <LI/>You have to open the document before you can write content.
+    ///     <LI/>You can only write content (no more meta-formation!) once a document is opened.
+    ///     <LI/>When you change the header/footer on a certain page, this will be effective starting on the next page.
+    ///     <LI/>Ater closing the document, every listener (as well as its OutputStream) is closed too.
+    /// </OL>
+    /// </remarks>
+    /// <example>
+    /// <code>
+    /// // creation of the document with a certain size and certain margins
+    /// <strong>Document document = new Document(PageSize.A4, 50, 50, 50, 50);</strong>
+    /// try {
+    ///     // creation of the different writers
+    ///     HtmlWriter.GetInstance(<strong>document</strong>, System.out);
+    ///     PdfWriter.GetInstance(<strong>document</strong>, new FileOutputStream("text.pdf"));
+    ///     // we add some meta information to the document
+    ///     <strong>document.AddAuthor("Bruno Lowagie");
+    ///     document.AddSubject("This is the result of a Test.");</strong>
+    ///     
+    ///     // we define a header and a footer
+    ///     HeaderFooter header = new HeaderFooter(new Phrase("This is a header."), false);
+    ///     HeaderFooter footer = new HeaderFooter(new Phrase("This is page "), new Phrase("."));
+    ///     footer.SetAlignment(Element.ALIGN_CENTER);
+    ///     <strong>document.SetHeader(header);
+    ///     document.SetFooter(footer);</strong>
+    ///     // we open the document for writing
+    ///     <strong>document.Open();
+    ///     document.Add(new Paragraph("Hello world"));</strong>
+    /// }
+    /// catch (DocumentException de) {
+    ///     Console.Error.WriteLine(de.Message);
+    /// }
+    /// <strong>document.Close();</strong>
+    /// </code>
+    /// </example>
+    public class Document : IDocListener {
+
+        // membervariables
+
+        ///<summary> This constant may only be changed by Paulo Soares and/or Bruno Lowagie. </summary>
+        private const string ITEXT_VERSION = "iTextSharp 4.1.2 (based on iText 2.1.2u)";
+
+        ///<summary> Allows the pdf documents to be produced without compression for debugging purposes. </summary>
+        public static bool Compress = true;
+
+        ///<summary> Scales the WMF font size. The default value is 0.86.  </summary>
+        public static float WmfFontCorrection = 0.86f;
+
+        ///<summary> The IDocListener. </summary>
+        private ArrayList listeners = new ArrayList();
+
+        ///<summary> Is the document open or not? </summary>
+        protected bool open;
+
+        ///<summary> Has the document allready been closed? </summary>
+        protected bool close;
+
+        // membervariables concerning the layout
+
+        ///<summary> The size of the page. </summary>
+        protected Rectangle pageSize;
+
+        ///<summary> margin in x direction starting from the left </summary>
+        protected float marginLeft = 0;
+
+        ///<summary> margin in x direction starting from the right </summary>
+        protected float marginRight = 0;
+
+        ///<summary> margin in y direction starting from the top </summary>
+        protected float marginTop = 0;
+
+        ///<summary> margin in y direction starting from the bottom </summary>
+        protected float marginBottom = 0;
+
+        protected bool marginMirroring = false;
+        ///<summary> Content of JavaScript onLoad function </summary>
+        protected string javaScript_onLoad = null;
+
+        ///<summary> Content of JavaScript onUnLoad function  </summary>
+        protected string javaScript_onUnLoad = null;
+
+        ///<summary> Style class in HTML body tag </summary>
+        protected string htmlStyleClass = null;
+
+        // headers, footers
+
+        ///<summary> Current pagenumber </summary>
+        protected int pageN = 0;
+
+        ///<summary> This is the textual part of a Page; it can contain a header </summary>
+        protected HeaderFooter header = null;
+
+        ///<summary> This is the textual part of the footer </summary>
+        protected HeaderFooter footer = null;
+
+        // constructor
+
+        /// <summary>
+        /// Constructs a new Document-object.
+        /// </summary>
+        /// <overloads>
+        /// Has three overloads.
+        /// </overloads>
+        public Document() : this(iTextSharp.text.PageSize.A4) {}
+
+        /// <summary>
+        /// Constructs a new Document-object.
+        /// </summary>
+        /// <param name="pageSize">the pageSize</param>
+        public Document(Rectangle pageSize) : this(pageSize, 36, 36, 36, 36) {}
+
+        /// <summary>
+        /// Constructs a new Document-object.
+        /// </summary>
+        /// <param name="pageSize">the pageSize</param>
+        /// <param name="marginLeft">the margin on the left</param>
+        /// <param name="marginRight">the margin on the right</param>
+        /// <param name="marginTop">the margin on the top</param>
+        /// <param name="marginBottom">the margin on the bottom</param>
+        public Document(Rectangle pageSize, float marginLeft, float marginRight, float marginTop, float marginBottom) {
+            this.pageSize = pageSize;
+            this.marginLeft = marginLeft;
+            this.marginRight = marginRight;
+            this.marginTop = marginTop;
+            this.marginBottom = marginBottom;
+        }
+
+        // listener methods
+
+        /// <summary>
+        /// Adds a IDocListener to the Document.
+        /// </summary>
+        /// <param name="listener">the new IDocListener</param>
+        public void AddDocListener(IDocListener listener) {
+            listeners.Add(listener);
+        }
+
+        /// <summary>
+        /// Removes a IDocListener from the Document.
+        /// </summary>
+        /// <param name="listener">the IDocListener that has to be removed.</param>
+        public void RemoveIDocListener(IDocListener listener) {
+            listeners.Remove(listener);
+        }
+
+        // methods implementing the IDocListener interface
+
+        /// <summary>
+        /// Adds an Element to the Document.
+        /// </summary>
+        /// <param name="element">the Element to add</param>
+        /// <returns>true if the element was added, false if not</returns>
+        public virtual bool Add(IElement element) {
+            if (close) {
+                throw new DocumentException("The document has been closed. You can't add any Elements.");
+            }
+            if (!open && element.IsContent()) {
+                throw new DocumentException("The document is not open yet; you can only add Meta information.");
+            }
+            bool success = false;
+            foreach (IDocListener listener in listeners) {
+                success |= listener.Add(element);
+            }
+		    if (element is ILargeElement) {
+			    ILargeElement e = (ILargeElement)element;
+			    if (!e.ElementComplete)
+				    e.FlushContent();
+		    }
+            return success;
+        }
+
+        /// <summary>
+        /// Opens the document.
+        /// </summary>
+        /// <remarks>
+        /// Once the document is opened, you can't write any Header- or Meta-information
+        /// anymore. You have to open the document before you can begin to add content
+        /// to the body of the document.
+        /// </remarks>
+        public virtual void Open() {
+            if (! close) {
+                open = true;
+            }
+            foreach (IDocListener listener in listeners) {
+                listener.SetPageSize(pageSize);
+                listener.SetMargins(marginLeft, marginRight, marginTop, marginBottom);
+                listener.Open();
+            }
+        }
+
+        /// <summary>
+        /// Sets the pagesize.
+        /// </summary>
+        /// <param name="pageSize">the new pagesize</param>
+        /// <returns>a bool</returns>
+        public virtual bool SetPageSize(Rectangle pageSize) {
+            this.pageSize = pageSize;
+            foreach (IDocListener listener in listeners) {
+                listener.SetPageSize(pageSize);
+            }
+            return true;
+        }
+
+        /// <summary>
+        /// Sets the margins.
+        /// </summary>
+        /// <param name="marginLeft">the margin on the left</param>
+        /// <param name="marginRight">the margin on the right</param>
+        /// <param name="marginTop">the margin on the top</param>
+        /// <param name="marginBottom">the margin on the bottom</param>
+        /// <returns></returns>
+        public virtual bool SetMargins(float marginLeft,float marginRight,float marginTop,float marginBottom) {
+            this.marginLeft = marginLeft;
+            this.marginRight = marginRight;
+            this.marginTop = marginTop;
+            this.marginBottom = marginBottom;
+            foreach (IDocListener listener in listeners) {
+                listener.SetMargins(marginLeft, marginRight, marginTop, marginBottom);
+            }
+            return true;
+        }
+
+        /// <summary>
+        /// Signals that an new page has to be started.
+        /// </summary>
+        /// <returns>true if the page was added, false if not.</returns>
+        public virtual bool NewPage() {
+            if (!open || close) {
+                return false;
+            }
+            foreach (IDocListener listener in listeners) {
+                listener.NewPage();
+            }
+            return true;
+        }
+
+        /// <summary>
+        /// Changes the header of this document.
+        /// </summary>
+        /// <value>a HeaderFooter</value>
+        public virtual HeaderFooter Header {
+            set {
+                this.header = value;
+                foreach (IDocListener listener in listeners) {
+                    listener.Header = value;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Resets the header of this document.
+        /// </summary>
+        public virtual void ResetHeader() {
+            this.header = null;
+            foreach (IDocListener listener in listeners) {
+                listener.ResetHeader();
+            }
+        }
+
+        /// <summary>
+        /// Changes the footer of this document.
+        /// </summary>
+        /// <value>a HeaderFooter</value>
+        public virtual HeaderFooter Footer {
+            set {
+                this.footer = value;
+                foreach (IDocListener listener in listeners) {
+                    listener.Footer = value;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Resets the footer of this document.
+        /// </summary>
+        public virtual void ResetFooter() {
+            this.footer = null;
+            foreach (IDocListener listener in listeners) {
+                listener.ResetFooter();
+            }
+        }
+
+        /// <summary>
+        /// Sets the page number to 0.
+        /// </summary>
+        public virtual void ResetPageCount() {
+            pageN = 0;
+            foreach (IDocListener listener in listeners) {
+                listener.ResetPageCount();
+            }
+        }
+
+        /// <summary>
+        /// Sets the page number.
+        /// </summary>
+        /// <value>an int</value>
+        public virtual int PageCount {
+            set {
+                this.pageN = value;
+                foreach (IDocListener listener in listeners) {
+                    listener.PageCount = value;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Returns the current page number.
+        /// </summary>
+        /// <value>an int</value>
+        public int PageNumber {
+            get {
+                return this.pageN;
+            }
+        }
+
+        /// <summary>
+        /// Closes the document.
+        /// </summary>
+        /// <remarks>
+        /// Once all the content has been written in the body, you have to close
+        /// the body. After that nothing can be written to the body anymore.
+        /// </remarks>
+        public virtual void Close() {
+            if (!close) {
+                open = false;
+                close = true;
+            }
+            foreach (IDocListener listener in listeners) {
+                listener.Close();
+            }
+        }
+
+        // methods concerning the header or some meta information
+
+        /// <summary>
+        /// Adds a user defined header to the document.
+        /// </summary>
+        /// <param name="name">the name of the header</param>
+        /// <param name="content">the content of the header</param>
+        /// <returns>true if successful, false otherwise</returns>
+        public bool AddHeader(string name, string content) {
+            return Add(new Header(name, content));
+        }
+
+        /// <summary>
+        /// Adds the title to a Document.
+        /// </summary>
+        /// <param name="title">the title</param>
+        /// <returns>true if successful, false otherwise</returns>
+        public bool AddTitle(string title) {
+            return Add(new Meta(Element.TITLE, title));
+        }
+
+        /// <summary>
+        /// Adds the subject to a Document.
+        /// </summary>
+        /// <param name="subject">the subject</param>
+        /// <returns>true if successful, false otherwise</returns>
+        public bool AddSubject(string subject) {
+            return Add(new Meta(Element.SUBJECT, subject));
+        }
+
+        /// <summary>
+        /// Adds the keywords to a Document.
+        /// </summary>
+        /// <param name="keywords">keywords to add</param>
+        /// <returns>true if successful, false otherwise</returns>
+        public bool AddKeywords(string keywords) {
+            return Add(new Meta(Element.KEYWORDS, keywords));
+        }
+
+        /// <summary>
+        /// Adds the author to a Document.
+        /// </summary>
+        /// <param name="author">the name of the author</param>
+        /// <returns>true if successful, false otherwise</returns>
+        public bool AddAuthor(string author) {
+            return Add(new Meta(Element.AUTHOR, author));
+        }
+
+        /// <summary>
+        /// Adds the creator to a Document.
+        /// </summary>
+        /// <param name="creator">the name of the creator</param>
+        /// <returns>true if successful, false otherwise</returns>
+        public bool AddCreator(string creator) {
+            return Add(new Meta(Element.CREATOR, creator));
+        }
+
+        /// <summary>
+        /// Adds the producer to a Document.
+        /// </summary>
+        /// <returns>true if successful, false otherwise</returns>
+        public bool AddProducer() {
+            return Add(new Meta(Element.PRODUCER, "iText# by lowagie.com"));
+        }
+
+        /// <summary>
+        /// Adds the current date and time to a Document.
+        /// </summary>
+        /// <returns>true if successful, false otherwise</returns>
+        public bool AddCreationDate() {
+            return Add(new Meta(Element.CREATIONDATE, DateTime.Now.ToString("ddd MMM dd HH:mm:ss zzz yyyy")));
+        }
+
+        // methods to get the layout of the document.
+
+        /// <summary>
+        /// Returns the left margin.
+        /// </summary>
+        /// <value>the left margin</value>
+        public float LeftMargin {
+            get {
+                return marginLeft;
+            }
+        }
+
+        /// <summary>
+        /// Return the right margin.
+        /// </summary>
+        /// <value>the right margin</value>
+        public float RightMargin {
+            get {
+                return marginRight;
+            }
+        }
+
+        /// <summary>
+        /// Returns the top margin.
+        /// </summary>
+        /// <value>the top margin</value>
+        public float TopMargin {
+            get {
+                return marginTop;
+            }
+        }
+
+        /// <summary>
+        /// Returns the bottom margin.
+        /// </summary>
+        /// <value>the bottom margin</value>
+        public float BottomMargin {
+            get {
+                return marginBottom;
+            }
+        }
+
+        /// <summary>
+        /// Returns the lower left x-coordinate.
+        /// </summary>
+        /// <value>the lower left x-coordinate</value>
+        public float Left {
+            get {
+                return pageSize.GetLeft(marginLeft);
+            }
+        }
+
+        /// <summary>
+        /// Returns the upper right x-coordinate.
+        /// </summary>
+        /// <value>the upper right x-coordinate.</value>
+        public float Right {
+            get {
+                return pageSize.GetRight(marginRight);
+            }
+        }
+
+        /// <summary>
+        /// Returns the upper right y-coordinate.
+        /// </summary>
+        /// <value>the upper right y-coordinate.</value>
+        public float Top {
+            get {
+                return pageSize.GetTop(marginTop);
+            }
+        }
+
+        /// <summary>
+        /// Returns the lower left y-coordinate.
+        /// </summary>
+        /// <value>the lower left y-coordinate.</value>
+        public float Bottom {
+            get {
+                return pageSize.GetBottom(marginBottom);
+            }
+        }
+
+        /// <summary>
+        /// Returns the lower left x-coordinate considering a given margin.
+        /// </summary>
+        /// <param name="margin">a margin</param>
+        /// <returns>the lower left x-coordinate</returns>
+        public float GetLeft(float margin) {
+            return pageSize.GetLeft(marginLeft + margin);
+        }
+
+        /// <summary>
+        /// Returns the upper right x-coordinate, considering a given margin.
+        /// </summary>
+        /// <param name="margin">a margin</param>
+        /// <returns>the upper right x-coordinate</returns>
+        public float GetRight(float margin) {
+            return pageSize.GetRight(marginRight + margin);
+        }
+
+        /// <summary>
+        /// Returns the upper right y-coordinate, considering a given margin.
+        /// </summary>
+        /// <param name="margin">a margin</param>
+        /// <returns>the upper right y-coordinate</returns>
+        public float GetTop(float margin) {
+            return pageSize.GetTop(marginTop + margin);
+        }
+
+        /// <summary>
+        /// Returns the lower left y-coordinate, considering a given margin.
+        /// </summary>
+        /// <param name="margin">a margin</param>
+        /// <returns>the lower left y-coordinate</returns>
+        public float GetBottom(float margin) {
+            return pageSize.GetBottom(marginBottom + margin);
+        }
+
+        /// <summary>
+        /// Gets the pagesize.
+        /// </summary>
+        /// <value>the page size</value>
+        public Rectangle PageSize {
+            get {
+                return this.pageSize;
+            }
+        }
+
+        /// <summary>
+        /// Checks if the document is open.
+        /// </summary>
+        /// <returns>true if the document is open</returns>
+        public bool IsOpen() {
+            return open;
+        }
+
+        /// <summary>
+        /// Gets the iText version.
+        /// </summary>
+        /// <value>iText version</value>
+        public static string Version {
+            get {
+                return ITEXT_VERSION;
+            }
+        }
+
+        /// <summary>
+        /// Gets the JavaScript onLoad command.
+        /// </summary>
+        /// <value>the JavaScript onLoad command.</value>
+        public string JavaScript_onLoad {
+            get {
+                return this.javaScript_onLoad;
+            }
+
+            set {
+                this.javaScript_onLoad = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets the JavaScript onUnLoad command.
+        /// </summary>
+        /// <value>the JavaScript onUnLoad command</value>
+        public string JavaScript_onUnLoad {
+            get {
+                return this.javaScript_onUnLoad;
+            }
+
+            set {
+                this.javaScript_onUnLoad = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets the style class of the HTML body tag
+        /// </summary>
+        /// <value>the style class of the HTML body tag</value>
+        public string HtmlStyleClass {
+            get {
+                return this.htmlStyleClass;
+            }
+
+            set {
+                this.htmlStyleClass = value;
+            }
+        }
+
+        /**
+        * Set the margin mirroring. It will mirror margins for odd/even pages.
+        * <p>
+        * Note: it will not work with {@link Table}.
+        * 
+        * @param marginMirroring
+        *            <CODE>true</CODE> to mirror the margins
+        * @return always <CODE>true</CODE>
+        */    
+        public virtual bool SetMarginMirroring(bool marginMirroring) {
+            this.marginMirroring = marginMirroring;
+            foreach (IDocListener listener in listeners) {
+                listener.SetMarginMirroring(marginMirroring);
+            }
+            return true;
+        }
+        
+        /**
+        * Gets the margin mirroring flag.
+        * 
+        * @return the margin mirroring flag
+        */    
+        public bool IsMarginMirroring() {
+            return marginMirroring;
+        }
+    }
+}

src/core/iTextSharp/text/DocumentException.cs

@@ -0,0 +1,77 @@
+using System;
+
+/*
+ * $Id: DocumentException.cs,v 1.3 2008/05/13 11:25:09 psoares33 Exp $
+ * 
+ *
+ * Copyright 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ *
+ */
+
+namespace iTextSharp.text {
+    /// <summary>
+    /// Signals that an error has occurred in a Document.
+    /// </summary>
+    /// <seealso cref="T:iTextSharp.text.BadElementException"/>
+    /// <seealso cref="T:iTextSharp.text.Document"/>
+    /// <seealso cref="T:iTextSharp.text.DocWriter"/>
+    /// <seealso cref="T:iTextSharp.text.IDocListener"/>
+    public class DocumentException : Exception {
+        /// <summary>
+        /// Constructs a new DocumentException
+        /// </summary>
+        /// <overloads>
+        /// Has two overloads.
+        /// </overloads>
+        public DocumentException() : base() {}
+
+        /// <summary>
+        /// Construct a new DocumentException
+        /// </summary>
+        /// <param name="message">error message</param>
+        public DocumentException(string message) : base(message) {}
+    }
+}

src/core/iTextSharp/text/Element.cs

@@ -0,0 +1,285 @@
+using System;
+
+/*
+ * $Id: Element.cs,v 1.7 2008/05/13 11:25:09 psoares33 Exp $
+ * 
+ *
+ * Copyright 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+
+namespace iTextSharp.text 
+{
+
+    /// <summary>
+    /// Interface for a text element.
+    /// </summary>
+    /// <seealso cref="T:iTextSharp.text.Anchor"/>
+    /// <seealso cref="T:iTextSharp.text.Cell"/>
+    /// <seealso cref="T:iTextSharp.text.Chapter"/>
+    /// <seealso cref="T:iTextSharp.text.Chunk"/>
+    /// <seealso cref="T:iTextSharp.text.Gif"/>
+    /// <seealso cref="T:iTextSharp.text.Graphic"/>
+    /// <seealso cref="T:iTextSharp.text.Header"/>
+    /// <seealso cref="T:iTextSharp.text.Image"/>
+    /// <seealso cref="T:iTextSharp.text.Jpeg"/>
+    /// <seealso cref="T:iTextSharp.text.List"/>
+    /// <seealso cref="T:iTextSharp.text.ListItem"/>
+    /// <seealso cref="T:iTextSharp.text.Meta"/>
+    /// <seealso cref="T:iTextSharp.text.Paragraph"/>
+    /// <seealso cref="T:iTextSharp.text.Phrase"/>
+    /// <seealso cref="T:iTextSharp.text.Rectangle"/>
+    /// <seealso cref="T:iTextSharp.text.Row"/>
+    /// <seealso cref="T:iTextSharp.text.Section"/>
+    /// <seealso cref="T:iTextSharp.text.Table"/>
+    public class Element 
+    {
+    
+        // static membervariables (meta information)
+    
+        /// <summary> This is a possible type of Element. </summary>
+        public const int HEADER = 0;
+    
+        /// <summary> This is a possible type of Element. </summary>
+        public const int TITLE = 1;
+    
+        /// <summary> This is a possible type of Element. </summary>
+        public const int SUBJECT = 2;
+    
+        /// <summary> This is a possible type of Element. </summary>
+        public const int KEYWORDS = 3;
+    
+        /// <summary> This is a possible type of Element. </summary>
+        public const int AUTHOR = 4;
+    
+        /// <summary> This is a possible type of Element. </summary>
+        public const int PRODUCER = 5;
+    
+        /// <summary> This is a possible type of Element. </summary>
+        public const int CREATIONDATE = 6;
+    
+        /// <summary> This is a possible type of Element. </summary>
+        public const int CREATOR = 7;
+    
+        // static membervariables (content)
+    
+        /// <summary> This is a possible type of Element. </summary>
+        public const int CHUNK = 10;
+    
+        /// <summary> This is a possible type of Element. </summary>
+        public const int PHRASE = 11;
+    
+        /// <summary> This is a possible type of Element. </summary>
+        public const int PARAGRAPH = 12;
+    
+        /// <summary> This is a possible type of Element </summary>
+        public const int SECTION = 13;
+    
+        /// <summary> This is a possible type of Element </summary>
+        public const int LIST = 14;
+    
+        /// <summary> This is a possible type of Element </summary>
+        public const int LISTITEM = 15;
+    
+        /// <summary> This is a possible type of Element </summary>
+        public const int CHAPTER = 16;
+    
+        /// <summary> This is a possible type of Element </summary>
+        public const int ANCHOR = 17;
+    
+        // static membervariables (tables)
+    
+        /// <summary> This is a possible type of Element. </summary>
+        public const int CELL = 20;
+    
+        /// <summary> This is a possible type of Element. </summary>
+        public const int ROW = 21;
+    
+        /// <summary> This is a possible type of Element. </summary>
+        public const int TABLE = 22;
+    
+        /// <summary> This is a possible type of Element. </summary>
+        public const int PTABLE = 23;
+    
+        // static membervariables (annotations)
+    
+        /// <summary> This is a possible type of Element. </summary>
+        public const int ANNOTATION = 29;
+    
+        // static membervariables (geometric figures)
+    
+        /// <summary> This is a possible type of Element. </summary>
+        public const int RECTANGLE = 30;
+    
+        /// <summary> This is a possible type of Element. </summary>
+        public const int JPEG = 32;
+    
+	    /** This is a possible type of <CODE>Element</CODE>. */
+	    public const int JPEG2000 = 33;
+
+        /// <summary> This is a possible type of Element. </summary>
+        public const int IMGRAW = 34;
+    
+        /// <summary> This is a possible type of Element. </summary>
+        public const int IMGTEMPLATE = 35;
+    
+        /// <summary> This is a possible type of <CODE>Element</CODE>. </summary>
+        public const int MULTI_COLUMN_TEXT = 40;
+	
+        /** This is a possible type of <CODE>Element</CODE>. */
+        public const int MARKED = 50;
+    
+        /** This is a possible type of <CODE>Element</CODE>.
+        * @since 2.1.2
+        */
+        public const int YMARK = 55;
+
+        // static membervariables (alignment)
+       
+        /// <summary>
+        /// A possible value for paragraph Element.  This
+        /// specifies that the text is aligned to the left
+        /// indent and extra whitespace should be placed on
+        /// the right.
+        /// </summary>
+        public const int ALIGN_UNDEFINED = -1;
+    
+        /// <summary>
+        /// A possible value for paragraph Element.  This
+        /// specifies that the text is aligned to the left
+        /// indent and extra whitespace should be placed on
+        /// the right.
+        /// </summary>
+        public const int ALIGN_LEFT = 0;
+    
+        /// <summary>
+        /// A possible value for paragraph Element.  This
+        /// specifies that the text is aligned to the center
+        /// and extra whitespace should be placed equally on
+        /// the left and right.
+        /// </summary>
+        public const int ALIGN_CENTER = 1;
+    
+        /// <summary>
+        /// A possible value for paragraph Element.  This
+        /// specifies that the text is aligned to the right
+        /// indent and extra whitespace should be placed on
+        /// the left.
+        /// </summary>
+        public const int ALIGN_RIGHT = 2;
+    
+        /// <summary>
+        /// A possible value for paragraph Element.  This
+        /// specifies that extra whitespace should be spread
+        /// out through the rows of the paragraph with the
+        /// text lined up with the left and right indent
+        /// except on the last line which should be aligned
+        /// to the left.
+        /// </summary>
+        public const int ALIGN_JUSTIFIED = 3;
+    
+        /// <summary>
+        /// A possible value for vertical Element.
+        /// </summary>
+        public const int ALIGN_TOP = 4;
+    
+        /// <summary>
+        /// A possible value for vertical Element.
+        /// </summary>
+        public const int ALIGN_MIDDLE = 5;
+    
+        /// <summary>
+        /// A possible value for vertical Element.
+        /// </summary>
+        public const int ALIGN_BOTTOM = 6;
+    
+        /// <summary>
+        /// A possible value for vertical Element.
+        /// </summary>
+        public const int ALIGN_BASELINE = 7;
+
+        /// <summary>
+        /// Does the same as ALIGN_JUSTIFIED but the last line is also spread out.
+        /// </summary>
+        public const int ALIGN_JUSTIFIED_ALL = 8;
+
+        // static member variables for CCITT compression
+    
+        /// <summary>
+        /// Pure two-dimensional encoding (Group 4)
+        /// </summary>
+        public const int CCITTG4 = 0x100;
+        /// <summary>
+        /// Pure one-dimensional encoding (Group 3, 1-D)
+        /// </summary>
+        public const int CCITTG3_1D = 0x101;
+        /// <summary>
+        /// Mixed one- and two-dimensional encoding (Group 3, 2-D)
+        /// </summary>
+        public const int CCITTG3_2D = 0x102;    
+        /// <summary>
+        /// A flag indicating whether 1-bits are to be interpreted as black pixels
+        /// and 0-bits as white pixels,
+        /// </summary>
+        public const int CCITT_BLACKIS1 = 1;
+        /// <summary>
+        /// A flag indicating whether the filter expects extra 0-bits before each
+        /// encoded line so that the line begins on a byte boundary.
+        /// </summary>
+        public const int CCITT_ENCODEDBYTEALIGN = 2;
+        /// <summary>
+        /// A flag indicating whether end-of-line bit patterns are required to be
+        ///  present in the encoding.
+        /// </summary>
+        public const int CCITT_ENDOFLINE = 4;
+        /// <summary>
+        /// A flag indicating whether the filter expects the encoded data to be
+        /// terminated by an end-of-block pattern, overriding the Rows
+        /// parameter. The use of this flag will set the key /EndOfBlock to false.
+        /// </summary>
+        public const int CCITT_ENDOFBLOCK = 8;
+    
+    }
+}

src/core/iTextSharp/text/ElementTags.cs

@@ -0,0 +1,521 @@
+using System;
+using System.util;
+
+/*
+ * $Id: ElementTags.cs,v 1.8 2008/05/13 11:25:10 psoares33 Exp $
+ * 
+ *
+ * Copyright (c) 2001, 2002 Bruno Lowagie.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+
+namespace iTextSharp.text 
+{
+    /// <summary>
+    /// A class that contains all the possible tagnames and their attributes.
+    /// </summary>
+    public class ElementTags 
+    {
+    
+        /// <summary> the root tag. </summary>
+        public const string ITEXT = "itext";
+    
+        /// <summary> attribute of the root and annotation tag (also a special tag within a chapter or section) </summary>
+        public const string TITLE = "title";
+    
+        /// <summary> attribute of the root tag </summary>
+        public const string SUBJECT = "subject";
+    
+        /// <summary> attribute of the root tag </summary>
+        public const string KEYWORDS = "keywords";
+    
+        /// <summary> attribute of the root tag </summary>
+        public const string AUTHOR = "author";
+    
+        /// <summary> attribute of the root tag </summary>
+        public const string CREATIONDATE = "creationdate";
+    
+        /// <summary> attribute of the root tag </summary>
+        public const string PRODUCER = "producer";
+    
+        // Chapters and Sections
+    
+        /// <summary> the chapter tag </summary>
+        public const string CHAPTER = "chapter";
+    
+        /// <summary> the section tag </summary>
+        public const string SECTION = "section";
+    
+        /// <summary> attribute of section/chapter tag </summary>
+        public const string NUMBERDEPTH = "numberdepth";
+    
+        /// <summary> attribute of section/chapter tag </summary>
+        public const string DEPTH = "depth";
+    
+        /// <summary> attribute of section/chapter tag </summary>
+        public const string NUMBER = "number";
+    
+        /// <summary> attribute of section/chapter tag </summary>
+        public const string INDENT = "indent";
+    
+        /// <summary> attribute of chapter/section/paragraph/table/cell tag </summary>
+        public const string LEFT = "left";
+    
+        /// <summary> attribute of chapter/section/paragraph/table/cell tag </summary>
+        public const string RIGHT = "right";
+    
+        // Phrases, Anchors, Lists and Paragraphs
+    
+        /// <summary> the phrase tag </summary>
+        public const string PHRASE = "phrase";
+    
+        /// <summary> the anchor tag </summary>
+        public const string ANCHOR = "anchor";
+    
+        /// <summary> the list tag </summary>
+        public const string LIST = "list";
+    
+        /// <summary> the listitem tag </summary>
+        public const string LISTITEM = "listitem";
+    
+        /// <summary> the paragraph tag </summary>
+        public const string PARAGRAPH = "paragraph";
+    
+        /// <summary> attribute of phrase/paragraph/cell tag </summary>
+        public const string LEADING = "leading";
+    
+        /// <summary> attribute of paragraph/image/table tag </summary>
+        public const string ALIGN = "align";
+    
+        /// <summary> attribute of paragraph </summary>
+        public const string KEEPTOGETHER = "keeptogether";
+    
+        /// <summary> attribute of anchor tag </summary>
+        public const string NAME = "name";
+    
+        /// <summary> attribute of anchor tag </summary>
+        public const string REFERENCE = "reference";
+    
+        /// <summary> attribute of list tag </summary>
+        public const string LISTSYMBOL = "listsymbol";
+    
+        /// <summary> attribute of list tag </summary>
+        public const string NUMBERED = "numbered";
+    
+        /// <summary> attribute of the list tag </summary>
+        public const string LETTERED = "lettered";
+
+        /// <summary> attribute of list tag </summary>
+        public const string FIRST = "first";
+    
+        /// <summary> attribute of list tag </summary>
+        public const string SYMBOLINDENT = "symbolindent";
+    
+        /// <summary> attribute of list tag </summary>
+        public const string INDENTATIONLEFT = "indentationleft";
+    
+        /// <summary> attribute of list tag </summary>
+        public const string INDENTATIONRIGHT = "indentationright";
+    
+        // Chunks
+    
+        /// <summary> the chunk tag </summary>
+        public const string IGNORE = "ignore";
+    
+        /// <summary> the chunk tag </summary>
+        public const string ENTITY = "entity";
+    
+        /// <summary> the chunk tag </summary>
+        public const string ID = "id";
+    
+        /// <summary> the chunk tag </summary>
+        public const string CHUNK = "chunk";
+    
+        /// <summary> attribute of the chunk tag </summary>
+        public const string ENCODING = "encoding";
+    
+        /// <summary> attribute of the chunk tag </summary>
+        public const string EMBEDDED = "embedded";
+    
+        /// <summary> attribute of the chunk/table/cell tag </summary>
+        public const string COLOR = "color";
+    
+        /// <summary> attribute of the chunk/table/cell tag </summary>
+        public const string RED = "red";
+    
+        /// <summary> attribute of the chunk/table/cell tag </summary>
+        public const string GREEN = "green";
+    
+        /// <summary> attribute of the chunk/table/cell tag </summary>
+        public const string BLUE = "blue";
+    
+        /// <summary> attribute of the chunk tag </summary>
+        public static readonly string SUBSUPSCRIPT = Chunk.SUBSUPSCRIPT.ToLower(System.Globalization.CultureInfo.InvariantCulture);
+    
+        /// <summary> attribute of the chunk tag </summary>
+        public static readonly string LOCALGOTO = Chunk.LOCALGOTO.ToLower(System.Globalization.CultureInfo.InvariantCulture);
+    
+        /// <summary> attribute of the chunk tag </summary>
+        public static readonly string REMOTEGOTO = Chunk.REMOTEGOTO.ToLower(System.Globalization.CultureInfo.InvariantCulture);
+    
+        /// <summary> attribute of the chunk tag </summary>
+        public static readonly string LOCALDESTINATION = Chunk.LOCALDESTINATION.ToLower(System.Globalization.CultureInfo.InvariantCulture);
+    
+        /// <summary> attribute of the chunk tag </summary>
+        public static readonly string GENERICTAG = Chunk.GENERICTAG.ToLower(System.Globalization.CultureInfo.InvariantCulture);
+    
+        // tables/cells
+    
+        /// <summary> the table tag </summary>
+        public const string TABLE = "table";
+    
+        /// <summary> the cell tag </summary>
+        public const string ROW = "row";
+    
+        /// <summary> the cell tag </summary>
+        public const string CELL = "cell";
+    
+        /// <summary> attribute of the table tag </summary>
+        public const string COLUMNS = "columns";
+    
+        /// <summary> attribute of the table tag </summary>
+        public const string LASTHEADERROW = "lastHeaderRow";
+    
+        /// <summary> attribute of the table tag </summary>
+        public const string CELLPADDING = "cellpadding";
+    
+        /// <summary> attribute of the table tag </summary>
+        public const string CELLSPACING = "cellspacing";
+    
+        /// <summary> attribute of the table tag </summary>
+        public const string OFFSET = "offset";
+    
+        /// <summary> attribute of the table tag </summary>
+        public const string WIDTHS = "widths";
+    
+        /// <summary> attribute of the table tag </summary>
+        public const string TABLEFITSPAGE = "tablefitspage";
+    
+        /// <summary> attribute of the table tag </summary>
+        public const string CELLSFITPAGE = "cellsfitpage";
+    
+        /// <summary> attribute of the table tag </summary>
+        public const string CONVERT2PDFP = "convert2pdfp";
+                
+        /// <summary> attribute of the cell tag </summary>
+        public const string HORIZONTALALIGN = "horizontalalign";
+    
+        /// <summary> attribute of the cell tag </summary>
+        public const string VERTICALALIGN = "verticalalign";
+    
+        /// <summary> attribute of the cell tag </summary>
+        public const string COLSPAN = "colspan";
+    
+        /// <summary> attribute of the cell tag </summary>
+        public const string ROWSPAN = "rowspan";
+    
+        /// <summary> attribute of the cell tag </summary>
+        public const string HEADER = "header";
+    
+        /// <summary> attribute of the cell tag </summary>
+        public const string FOOTER = "footer";
+
+        /// <summary> attribute of the cell tag </summary>
+        public const string NOWRAP = "nowrap";
+    
+        /// <summary> attribute of the table/cell tag </summary>
+        public const string BORDERWIDTH = "borderwidth";
+    
+        /// <summary> attribute of the table/cell tag </summary>
+        public const string TOP = "top";
+    
+        /// <summary> attribute of the table/cell tag </summary>
+        public const string BOTTOM = "bottom";
+    
+        /// <summary> attribute of the table/cell tag </summary>
+        public const string WIDTH = "width";
+    
+        /// <summary> attribute of the table/cell tag </summary>
+        public const string BORDERCOLOR = "bordercolor";
+    
+        /// <summary> attribute of the table/cell tag </summary>
+        public const string BACKGROUNDCOLOR = "backgroundcolor";
+    
+        /// <summary> attribute of the table/cell tag </summary>
+        public const string BGRED = "bgred";
+    
+        /// <summary> attribute of the table/cell tag </summary>
+        public const string BGGREEN = "bggreen";
+    
+        /// <summary> attribute of the table/cell tag </summary>
+        public const string BGBLUE = "bgblue";
+    
+        /// <summary> attribute of the table/cell tag </summary>
+        public const string GRAYFILL = "grayfill";
+    
+        // Misc
+    
+        /// <summary> the image tag </summary>
+        public const string IMAGE = "image";
+    
+        /// <summary> the image tag </summary>
+        public const string BOOKMARKOPEN = "bookmarkopen";
+    
+        /// <summary> attribute of the image and annotation tag </summary>
+        public const string URL = "url";
+    
+        /// <summary> attribute of the image tag </summary>
+        public const string UNDERLYING = "underlying";
+    
+        /// <summary> attribute of the image tag </summary>
+        public const string TEXTWRAP = "textwrap";
+    
+        /// <summary> attribute of the image tag </summary>
+        public const string ALT = "alt";
+    
+        /// <summary> attribute of the image tag </summary>
+        public const string ABSOLUTEX = "absolutex";
+    
+        /// <summary> attribute of the image tag </summary>
+        public const string ABSOLUTEY = "absolutey";
+    
+        /// <summary> attribute of the image tag </summary>
+        public const string PLAINWIDTH = "plainwidth";
+    
+        /// <summary> attribute of the image tag </summary>
+        public const string PLAINHEIGHT = "plainheight";
+    
+        /// <summary> attribute of the image tag </summary>
+        public const string SCALEDWIDTH = "scaledwidth";
+    
+        /// <summary> attribute of the image tag </summary>
+        public const string SCALEDHEIGHT = "scaledheight";
+    
+        /// <summary> attribute of the image tag </summary>
+        public const string  ROTATION = "rotation";
+    
+        /// <summary> the newpage tag </summary>
+        public const string NEWPAGE = "newpage";
+    
+        /// <summary> the newpage tag </summary>
+        public const string NEWLINE = "newline";
+    
+        /// <summary> the annotation tag </summary>
+        public const string ANNOTATION = "annotation";
+    
+        /// <summary> attribute of the annotation tag </summary>
+        public const string FILE = "file";
+    
+        /// <summary> attribute of the annotation tag </summary>
+        public const string DESTINATION = "destination";
+    
+        /// <summary> attribute of the annotation tag </summary>
+        public const string PAGE = "page";
+    
+        /// <summary> attribute of the annotation tag </summary>
+        public const string NAMED = "named";
+    
+        /// <summary> attribute of the annotation tag </summary>
+        public const string APPLICATION = "application";
+    
+        /// <summary> attribute of the annotation tag </summary>
+        public const string PARAMETERS = "parameters";
+    
+        /// <summary> attribute of the annotation tag </summary>
+        public const string OPERATION = "operation";
+    
+        /// <summary> attribute of the annotation tag </summary>
+        public const string DEFAULTDIR = "defaultdir";
+    
+        /// <summary> attribute of the annotation tag </summary>
+        public const string LLX = "llx";
+    
+        /// <summary> attribute of the annotation tag </summary>
+        public const string LLY = "lly";
+    
+        /// <summary> attribute of the annotation tag </summary>
+        public const string URX = "urx";
+    
+        /// <summary> attribute of the annotation tag </summary>
+        public const string URY = "ury";
+    
+        /// <summary> attribute of the annotation tag </summary>
+        public const string CONTENT = "content";
+    
+        // alignment attribute values
+    
+        /// <summary> the possible value of an alignment attribute </summary>
+        public const string ALIGN_LEFT = "Left";
+    
+        /// <summary> the possible value of an alignment attribute </summary>
+        public const string ALIGN_CENTER = "Center";
+    
+        /// <summary> the possible value of an alignment attribute </summary>
+        public const string ALIGN_RIGHT = "Right";
+    
+        /// <summary> the possible value of an alignment attribute </summary>
+        public const string ALIGN_JUSTIFIED = "Justify";
+    
+        /// <summary> the possible value of an alignment attribute </summary>
+        public const string ALIGN_JUSTIFIED_ALL = "JustifyAll";
+    
+        /// <summary> the possible value of an alignment attribute </summary>
+        public const string ALIGN_TOP = "Top";
+    
+        /// <summary> the possible value of an alignment attribute </summary>
+        public const string ALIGN_MIDDLE = "Middle";
+    
+        /// <summary> the possible value of an alignment attribute </summary>
+        public const string ALIGN_BOTTOM = "Bottom";
+    
+        /// <summary> the possible value of an alignment attribute </summary>
+        public const string ALIGN_BASELINE = "Baseline";
+    
+        /// <summary> the possible value of an alignment attribute </summary>
+        public const string DEFAULT = "Default";
+    
+        /// <summary> the possible value of an alignment attribute </summary>
+        public const string UNKNOWN = "unknown";
+    
+        /// <summary> the possible value of an alignment attribute </summary>
+        public const string FONT = "font";
+    
+        /// <summary> the possible value of an alignment attribute </summary>
+        public const string SIZE = "size";
+    
+        /// <summary> the possible value of an alignment attribute </summary>
+        public const string STYLE = "fontstyle";
+    
+        /// <summary> the possible value of a tag </summary>
+        public const string HORIZONTALRULE = "horizontalrule";
+        /** the possible value of a tag */
+        public const string PAGE_SIZE  = "pagesize";
+
+        /** the possible value of a tag */
+        public const string ORIENTATION  = "orientation";
+    
+        /** a possible list attribute */
+	    public const String ALIGN_INDENTATION_ITEMS = "alignindent";
+    	
+	    /** a possible list attribute */
+	    public const String AUTO_INDENT_ITEMS = "autoindent";
+    	
+	    /** a possible list attribute */
+	    public const String LOWERCASE = "lowercase";
+
+        // methods
+    
+        /// <summary>
+        /// Translates the alignment value to a String value.
+        /// </summary>
+        /// <param name="alignment">the alignment value</param>
+        /// <returns>the translated value</returns>
+        public static string GetAlignment(int alignment) 
+        {
+            switch (alignment) 
+            {
+                case Element.ALIGN_LEFT:
+                    return ALIGN_LEFT;
+                case Element.ALIGN_CENTER:
+                    return ALIGN_CENTER;
+                case Element.ALIGN_RIGHT:
+                    return ALIGN_RIGHT;
+                case Element.ALIGN_JUSTIFIED:
+                case Element.ALIGN_JUSTIFIED_ALL:
+                    return ALIGN_JUSTIFIED;
+                case Element.ALIGN_TOP:
+                    return ALIGN_TOP;
+                case Element.ALIGN_MIDDLE:
+                    return ALIGN_MIDDLE;
+                case Element.ALIGN_BOTTOM:
+                    return ALIGN_BOTTOM;
+                case Element.ALIGN_BASELINE:
+                    return ALIGN_BASELINE;
+                default:
+                    return DEFAULT;
+            }
+        }
+
+    /**
+    * Translates a String value to an alignment value.
+    * (written by Norman Richards, integrated into iText by Bruno)
+    * @param	a String (one of the ALIGN_ constants of this class)
+    * @param	an alignment value (one of the ALIGN_ constants of the Element interface) 
+    */
+        public static int AlignmentValue(String alignment) {
+            if (alignment == null) return Element.ALIGN_UNDEFINED;
+            if (Util.EqualsIgnoreCase(ALIGN_CENTER, alignment)) {
+                return Element.ALIGN_CENTER;
+            }
+            if (Util.EqualsIgnoreCase(ALIGN_LEFT, alignment)) {
+                return Element.ALIGN_LEFT;
+            }
+            if (Util.EqualsIgnoreCase(ALIGN_RIGHT, alignment)) {
+                return Element.ALIGN_RIGHT;
+            }
+            if (Util.EqualsIgnoreCase(ALIGN_JUSTIFIED, alignment)) {
+                return Element.ALIGN_JUSTIFIED;
+            }
+            if (Util.EqualsIgnoreCase(ALIGN_JUSTIFIED_ALL, alignment)) {
+                return Element.ALIGN_JUSTIFIED_ALL;
+            }
+            if (Util.EqualsIgnoreCase(ALIGN_TOP, alignment)) {
+                return Element.ALIGN_TOP;
+            }
+            if (Util.EqualsIgnoreCase(ALIGN_MIDDLE, alignment)) {
+                return Element.ALIGN_MIDDLE;
+            }
+            if (Util.EqualsIgnoreCase(ALIGN_BOTTOM, alignment)) {
+                return Element.ALIGN_BOTTOM;
+            }
+            if (Util.EqualsIgnoreCase(ALIGN_BASELINE, alignment)) {
+                return Element.ALIGN_BASELINE;
+            }
+
+            return Element.ALIGN_UNDEFINED;
+        }
+    
+    }
+}

src/core/iTextSharp/text/Font.cs

@@ -0,0 +1,698 @@
+using System;
+using System.util;
+
+using iTextSharp.text.pdf;
+using iTextSharp.text.html;
+
+/*
+ * $Id: Font.cs,v 1.11 2008/05/13 11:25:10 psoares33 Exp $
+ * 
+ *
+ * Copyright 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+
+namespace iTextSharp.text {
+    /// <summary>
+    /// Contains all the specifications of a font: fontfamily, size, style and color.
+    /// </summary>
+    /// <example>
+    /// <code>
+    /// Paragraph p = new Paragraph("This is a paragraph",
+    ///               <strong>new Font(Font.HELVETICA, 18, Font.BOLDITALIC, new Color(0, 0, 255))</strong>);
+    /// </code>
+    /// </example>
+    public class Font : IComparable {
+    
+        // static membervariables for the different families
+    
+        /// <summary> a possible value of a font family. </summary>
+        public const int COURIER = 0;
+    
+        /// <summary> a possible value of a font family. </summary>
+        public const int HELVETICA = 1;
+    
+        /// <summary> a possible value of a font family. </summary>
+        public const int TIMES_ROMAN = 2;
+    
+        /// <summary> a possible value of a font family. </summary>
+        public const int SYMBOL = 3;
+    
+        /// <summary> a possible value of a font family. </summary>
+        public const int ZAPFDINGBATS = 4;
+    
+        // static membervariables for the different styles
+    
+        /// <summary> this is a possible style. </summary>
+        public const int NORMAL        = 0;
+    
+        /// <summary> this is a possible style. </summary>
+        public const int BOLD        = 1;
+    
+        /// <summary> this is a possible style. </summary>
+        public const int ITALIC        = 2;
+    
+        /// <summary> this is a possible style. </summary>
+        public const int UNDERLINE    = 4;
+    
+        /// <summary> this is a possible style. </summary>
+        public const int STRIKETHRU    = 8;
+    
+        /// <summary> this is a possible style. </summary>
+        public const int BOLDITALIC    = BOLD | ITALIC;
+    
+        // static membervariables
+    
+        /// <summary> the value of an undefined attribute. </summary>
+        public const int UNDEFINED = -1;
+    
+        /// <summary> the value of the default size. </summary>
+        public const int DEFAULTSIZE = 12;
+    
+        // membervariables
+    
+        /// <summary> the value of the fontfamily. </summary>
+        private int family = UNDEFINED;
+    
+        /// <summary> the value of the fontsize. </summary>
+        private float size = UNDEFINED;
+    
+        /// <summary> the value of the style. </summary>
+        private int style = UNDEFINED;
+    
+        /// <summary> the value of the color. </summary>
+        private Color color;
+    
+        /// <summary> the external font </summary>
+        private BaseFont baseFont = null;
+    
+        // constructors
+    
+        /**
+        * Copy constructor of a Font
+        * @param other the font that has to be copied
+        */
+        public Font(Font other) {
+            this.color = other.color;
+            this.family = other.family;
+            this.size = other.size;
+            this.style = other.style;
+            this.baseFont = other.baseFont;
+        }
+        
+        /// <summary>
+        /// Constructs a Font.
+        /// </summary>
+        /// <param name="family">the family to which this font belongs</param>
+        /// <param name="size">the size of this font</param>
+        /// <param name="style">the style of this font</param>
+        /// <param name="color">the Color of this font.</param>
+        public Font(int family, float size, int style, Color color) {
+            this.family = family;
+            this.size = size;
+            this.style = style;
+            this.color = color;
+        }
+    
+        /// <summary>
+        /// Constructs a Font.
+        /// </summary>
+        /// <param name="bf">the external font</param>
+        /// <param name="size">the size of this font</param>
+        /// <param name="style">the style of this font</param>
+        /// <param name="color">the Color of this font.</param>
+        public Font(BaseFont bf, float size, int style, Color color) {
+            this.baseFont = bf;
+            this.size = size;
+            this.style = style;
+            this.color = color;
+        }
+    
+        /// <summary>
+        /// Constructs a Font.
+        /// </summary>
+        /// <param name="bf">the external font</param>
+        /// <param name="size">the size of this font</param>
+        /// <param name="style">the style of this font</param>
+        public Font(BaseFont bf, float size, int style) : this(bf, size, style, null) {}
+    
+        /// <summary>
+        /// Constructs a Font.
+        /// </summary>
+        /// <param name="bf">the external font</param>
+        /// <param name="size">the size of this font</param>
+        public Font(BaseFont bf, float size) : this(bf, size, UNDEFINED, null) {}
+    
+        /// <summary>
+        /// Constructs a Font.
+        /// </summary>
+        /// <param name="bf">the external font</param>
+        public Font(BaseFont bf) : this(bf, UNDEFINED, UNDEFINED, null) {}
+    
+        /// <summary>
+        /// Constructs a Font.
+        /// </summary>
+        /// <param name="family">the family to which this font belongs</param>
+        /// <param name="size">the size of this font</param>
+        /// <param name="style">the style of this font</param>
+        public Font(int family, float size, int style) : this(family, size, style, null) {}
+    
+        /// <summary>
+        /// Constructs a Font.
+        /// </summary>
+        /// <param name="family">the family to which this font belongs</param>
+        /// <param name="size">the size of this font</param>
+        public Font(int family, float size) : this(family, size, UNDEFINED, null) {}
+    
+        /// <summary>
+        /// Constructs a Font.
+        /// </summary>
+        /// <param name="family">the family to which this font belongs</param>
+        public Font(int family) : this(family, UNDEFINED, UNDEFINED, null) {}
+    
+        /// <summary>
+        /// Constructs a Font.
+        /// </summary>
+        /// <overloads>
+        /// Has nine overloads.
+        /// </overloads>
+        public Font() : this(UNDEFINED, UNDEFINED, UNDEFINED, null) {}
+    
+        // implementation of the Comparable interface
+    
+        /// <summary>
+        /// Compares this Font with another
+        /// </summary>
+        /// <param name="obj">the other Font</param>
+        /// <returns>a value</returns>
+        public virtual int CompareTo(Object obj) {
+            if (obj == null) {
+                return -1;
+            }
+            Font font;
+            try {
+                font = (Font) obj;
+                if (baseFont != null && !baseFont.Equals(font.BaseFont)) {
+                    return -2;
+                }
+                if (this.family != font.Family) {
+                    return 1;
+                }
+                if (this.size != font.Size) {
+                    return 2;
+                }
+                if (this.style != font.Style) {
+                    return 3;
+                }
+                if (this.color == null) {
+                    if (font.Color == null) {
+                        return 0;
+                    }
+                    return 4;
+                }
+                if (font.Color == null) {
+                    return 4;
+                }
+                if (((Color)this.color).Equals(font.Color)) {
+                    return 0;
+                }
+                return 4;
+            }
+            catch {
+                return -3;
+            }
+        }
+    
+        // FAMILY
+
+        /// <summary>
+        /// Gets the family of this font.
+        /// </summary>
+        /// <value>the value of the family</value>
+        public int Family {
+            get {
+                return family;
+            }
+        }
+    
+        /// <summary>
+        /// Gets the familyname as a string.
+        /// </summary>
+        /// <value>the familyname</value>
+        public virtual string Familyname {
+            get {
+                string tmp = "unknown";
+                switch (this.Family) {
+                    case Font.COURIER:
+                        return FontFactory.COURIER;
+                    case Font.HELVETICA:
+                        return FontFactory.HELVETICA;
+                    case Font.TIMES_ROMAN:
+                        return FontFactory.TIMES_ROMAN;
+                    case Font.SYMBOL:
+                        return FontFactory.SYMBOL;
+                    case Font.ZAPFDINGBATS:
+                        return FontFactory.ZAPFDINGBATS;
+                    default:
+                        if (baseFont != null) {
+                            string[][] names = baseFont.FamilyFontName;
+                            for (int i = 0; i < names.Length; i++) {
+                                if ("0".Equals(names[i][2])) {
+                                    return names[i][3];
+                                }
+                                if ("1033".Equals(names[i][2])) {
+                                    tmp = names[i][3];
+                                }
+                                if ("".Equals(names[i][2])) {
+                                    tmp = names[i][3];
+                                }
+                            }
+                        }
+                        break;
+                }
+                return tmp;
+            }
+        }
+    
+        /// <summary>
+        /// Sets the family using a String ("Courier",
+        /// "Helvetica", "Times New Roman", "Symbol" or "ZapfDingbats").
+        /// </summary>
+        /// <param name="family">A String representing a certain font-family.</param>
+        public virtual void SetFamily(String family) {
+            this.family = GetFamilyIndex(family);
+        }
+
+        /// <summary>
+        /// Translates a string-value of a certain family
+        /// into the index that is used for this family in this class.
+        /// </summary>
+        /// <param name="family">A string representing a certain font-family</param>
+        /// <returns>the corresponding index</returns>
+        public static int GetFamilyIndex(string family) {
+            if (Util.EqualsIgnoreCase(family, FontFactory.COURIER)) {
+                return COURIER;
+            }
+            if (Util.EqualsIgnoreCase(family, FontFactory.HELVETICA)) {
+                return HELVETICA;
+            }
+            if (Util.EqualsIgnoreCase(family, FontFactory.TIMES_ROMAN)) {
+                return TIMES_ROMAN;
+            }
+            if (Util.EqualsIgnoreCase(family, FontFactory.SYMBOL)) {
+                return SYMBOL;
+            }
+            if (Util.EqualsIgnoreCase(family, FontFactory.ZAPFDINGBATS)) {
+                return ZAPFDINGBATS;
+            }
+            return UNDEFINED;
+        }
+    
+    	// SIZE
+	
+        /// <summary>
+        /// Get/set the size of this font.
+        /// </summary>
+        /// <value>the size of this font</value>
+        public virtual float Size {
+            get {
+                return size;
+            }
+            set {
+                this.size = value;
+            }
+        }
+    
+        /** Gets the size that can be used with the calculated <CODE>BaseFont</CODE>.
+        * @return the size that can be used with the calculated <CODE>BaseFont</CODE>
+        */    
+        public float CalculatedSize {
+            get {
+                float s = this.size;
+                if (s == UNDEFINED) {
+                    s = DEFAULTSIZE;
+                }
+                return s;
+            }
+        }
+
+        /**
+        * Gets the leading that can be used with this font.
+        * 
+        * @param linespacing
+        *            a certain linespacing
+        * @return the height of a line
+        */
+        public float GetCalculatedLeading(float linespacing) {
+            return linespacing * CalculatedSize;
+        }
+
+        // STYLE
+
+        /// <summary>
+        /// Gets the style of this font.
+        /// </summary>
+        /// <value>the style of this font</value>
+        public int Style {
+            get {
+                return style;
+            }
+        }
+    
+        /** Gets the style that can be used with the calculated <CODE>BaseFont</CODE>.
+        * @return the style that can be used with the calculated <CODE>BaseFont</CODE>
+        */    
+        public int CalculatedStyle {
+            get {
+                int style = this.style;
+                if (style == UNDEFINED) {
+                    style = NORMAL;
+                }
+                if (baseFont != null)
+                    return style;
+                if (family == SYMBOL || family == ZAPFDINGBATS)
+                    return style;
+                else
+                    return style & (~BOLDITALIC);
+            }
+        }
+        
+        /// <summary>
+        /// checks if this font is Bold.
+        /// </summary>
+        /// <returns>a boolean</returns>
+        public bool IsBold() {
+            if (style == UNDEFINED) {
+                return false;
+            }
+            return (style &    BOLD) == BOLD;
+        }
+    
+        /// <summary>
+        /// checks if this font is Bold.
+        /// </summary>
+        /// <returns>a boolean</returns>
+        public bool IsItalic() {
+            if (style == UNDEFINED) {
+                return false;
+            }
+            return (style &    ITALIC) == ITALIC;
+        }
+    
+        /// <summary>
+        /// checks if this font is underlined.
+        /// </summary>
+        /// <returns>a boolean</returns>
+        public bool IsUnderlined() {
+            if (style == UNDEFINED) {
+                return false;
+            }
+            return (style &    UNDERLINE) == UNDERLINE;
+        }
+    
+        /// <summary>
+        /// checks if the style of this font is STRIKETHRU.
+        /// </summary>
+        /// <returns>a boolean</returns>
+        public bool IsStrikethru() {
+            if (style == UNDEFINED) {
+                return false;
+            }
+            return (style &    STRIKETHRU) == STRIKETHRU;
+        }
+    
+        /// <summary>
+        /// Sets the style using a String containing one of
+        /// more of the following values: normal, bold, italic, underline, strike.
+        /// </summary>
+        /// <param name="style">A String representing a certain style.</param>
+        public virtual void SetStyle(String style) {
+            if (this.style == UNDEFINED) this.style = NORMAL;
+            this.style |= GetStyleValue(style);
+        }
+
+        /**
+        * Sets the style.
+        * @param    style    the style.
+        */
+            
+        public virtual void SetStyle(int style) {
+            if (this.style == UNDEFINED) this.style = NORMAL;
+            this.style |= style;
+        }
+            
+        /// <summary>
+        /// Translates a string-value of a certain style
+        /// into the index value is used for this style in this class.
+        /// </summary>
+        /// <param name="style">a string</param>
+        /// <returns>the corresponding value</returns>
+        public static int GetStyleValue(string style) {
+            int s = 0;
+            if (style.IndexOf(Markup.CSS_VALUE_NORMAL) != -1) {
+                s |= NORMAL;
+            }
+            if (style.IndexOf(Markup.CSS_VALUE_BOLD) != -1) {
+                s |= BOLD;
+            }
+            if (style.IndexOf(Markup.CSS_VALUE_ITALIC) != -1) {
+                s |= ITALIC;
+            }
+            if (style.IndexOf(Markup.CSS_VALUE_OBLIQUE) != -1) {
+                s |= ITALIC;
+            }
+            if (style.IndexOf(Markup.CSS_VALUE_UNDERLINE) != -1) {
+                s |= UNDERLINE;
+            }
+            if (style.IndexOf(Markup.CSS_VALUE_LINETHROUGH) != -1) {
+                s |= STRIKETHRU;
+            }
+            return s;
+        }
+    
+    
+        // COLOR
+
+        /// <summary>
+        /// Get/set the color of this font.
+        /// </summary>
+        /// <value>the color of this font</value>
+        public virtual Color Color {
+            get {
+                return color;
+            }
+            set {
+                this.color = value;
+            }
+        }
+    
+        /// <summary>
+        /// Sets the color.
+        /// </summary>
+        /// <param name="red">the red-value of the new color</param>
+        /// <param name="green">the green-value of the new color</param>
+        /// <param name="blue">the blue-value of the new color</param>
+        public virtual void SetColor(int red, int green, int blue) {
+            this.color = new Color(red, green, blue);
+        }
+    
+        // BASEFONT
+
+        /// <summary>
+        /// Gets the BaseFont inside this object.
+        /// </summary>
+        /// <value>the BaseFont</value>
+        public BaseFont BaseFont {
+            get {
+                return baseFont;
+            }
+        }
+
+        /** Gets the <CODE>BaseFont</CODE> this class represents.
+        * For the built-in fonts a <CODE>BaseFont</CODE> is calculated.
+        * @param specialEncoding <CODE>true</CODE> to use the special encoding for Symbol and ZapfDingbats,
+        * <CODE>false</CODE> to always use <CODE>Cp1252</CODE>
+        * @return the <CODE>BaseFont</CODE> this class represents
+        */    
+        public BaseFont GetCalculatedBaseFont(bool specialEncoding) {
+            if (baseFont != null)
+                return baseFont;
+            int style = this.style;
+            if (style == UNDEFINED) {
+                style = NORMAL;
+            }
+            String fontName = BaseFont.HELVETICA;
+            String encoding = BaseFont.WINANSI;
+            BaseFont cfont = null;
+            switch (family) {
+                case COURIER:
+                    switch (style & BOLDITALIC) {
+                        case BOLD:
+                            fontName = BaseFont.COURIER_BOLD;
+                            break;
+                        case ITALIC:
+                            fontName = BaseFont.COURIER_OBLIQUE;
+                            break;
+                        case BOLDITALIC:
+                            fontName = BaseFont.COURIER_BOLDOBLIQUE;
+                            break;
+                        default:
+                        //case NORMAL:
+                            fontName = BaseFont.COURIER;
+                            break;
+                    }
+                    break;
+                case TIMES_ROMAN:
+                    switch (style & BOLDITALIC) {
+                        case BOLD:
+                            fontName = BaseFont.TIMES_BOLD;
+                            break;
+                        case ITALIC:
+                            fontName = BaseFont.TIMES_ITALIC;
+                            break;
+                        case BOLDITALIC:
+                            fontName = BaseFont.TIMES_BOLDITALIC;
+                            break;
+                        default:
+                        //case NORMAL:
+                            fontName = BaseFont.TIMES_ROMAN;
+                            break;
+                    }
+                    break;
+                case SYMBOL:
+                    fontName = BaseFont.SYMBOL;
+                    if (specialEncoding)
+                        encoding = BaseFont.SYMBOL;
+                    break;
+                case ZAPFDINGBATS:
+                    fontName = BaseFont.ZAPFDINGBATS;
+                    if (specialEncoding)
+                        encoding = BaseFont.ZAPFDINGBATS;
+                    break;
+                default:
+                //case Font.HELVETICA:
+                    switch (style & BOLDITALIC) {
+                        case BOLD:
+                            fontName = BaseFont.HELVETICA_BOLD;
+                            break;
+                        case ITALIC:
+                            fontName = BaseFont.HELVETICA_OBLIQUE;
+                            break;
+                        case BOLDITALIC:
+                            fontName = BaseFont.HELVETICA_BOLDOBLIQUE;
+                            break;
+                        default:
+                        //case NORMAL:
+                            fontName = BaseFont.HELVETICA;
+                            break;
+                    }
+                    break;
+            }
+            cfont = BaseFont.CreateFont(fontName, encoding, false);
+            return cfont;
+        }
+
+        // Helper methods
+
+        /// <summary>
+        /// Checks if the properties of this font are undefined or null.
+        /// <p/>
+        /// If so, the standard should be used.
+        /// </summary>
+        /// <returns>a boolean</returns>
+        public virtual bool IsStandardFont() {
+            return (family == UNDEFINED
+                && size == UNDEFINED
+                && style == UNDEFINED
+                && color == null
+                && baseFont == null);
+        }
+    
+        /// <summary>
+        /// Replaces the attributes that are equal to null with
+        /// the attributes of a given font.
+        /// </summary>
+        /// <param name="font">the font of a bigger element class</param>
+        /// <returns>a Font</returns>
+        public virtual Font Difference(Font font) {
+            if (font == null) return this;
+            // size
+            float dSize = font.size;
+            if (dSize == UNDEFINED) {
+                dSize = this.size;
+            }
+            // style
+            int dStyle = UNDEFINED;
+            int style1 = this.Style;
+            int style2 = font.Style;
+            if (style1 != UNDEFINED || style2 != UNDEFINED) {
+                if (style1 == UNDEFINED) style1 = 0;
+                if (style2 == UNDEFINED) style2 = 0;
+                dStyle = style1 | style2;
+            }
+            // color
+            object dColor = (Color)font.Color;
+            if (dColor == null) {
+                dColor = this.Color;
+            }
+            // family
+            if (font.baseFont != null) {
+                return new Font(font.BaseFont, dSize, dStyle, (Color)dColor);
+            }
+            if (font.Family != UNDEFINED) {
+                return new Font(font.Family, dSize, dStyle, (Color)dColor);
+            }
+            if (this.baseFont != null) {
+                if (dStyle == style1) {
+                    return new Font(this.BaseFont, dSize, dStyle, (Color)dColor);
+                }
+                else {
+                    return FontFactory.GetFont(this.Familyname, dSize, dStyle, (Color)dColor);
+                }
+            }
+            return new Font(this.Family, dSize, dStyle, (Color)dColor);
+        }
+    }
+}

src/core/iTextSharp/text/FontFactory.cs

@@ -0,0 +1,426 @@
+using System;
+using System.IO;
+using System.Collections;
+using System.util;
+using System.Globalization;
+
+using iTextSharp.text.html;
+using iTextSharp.text.pdf;
+using iTextSharp.text;
+
+/*
+ * $Id: FontFactory.cs,v 1.16 2008/05/13 11:25:10 psoares33 Exp $
+ * 
+ *
+ * Copyright 2002 by Bruno Lowagie.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+namespace iTextSharp.text {
+    /// <summary>
+    /// If you are using True Type fonts, you can declare the paths of the different ttf- and ttc-files
+    /// to this static class first and then create fonts in your code using one of the static getFont-method
+    /// without having to enter a path as parameter.
+    /// </summary>
+    public sealed class FontFactory {
+    
+        /// <summary> This is a possible value of a base 14 type 1 font </summary>
+        public const string COURIER = BaseFont.COURIER;
+    
+        /// <summary> This is a possible value of a base 14 type 1 font </summary>
+        public const string COURIER_BOLD = BaseFont.COURIER_BOLD;
+    
+        /// <summary> This is a possible value of a base 14 type 1 font </summary>
+        public const string COURIER_OBLIQUE = BaseFont.COURIER_OBLIQUE;
+    
+        /// <summary> This is a possible value of a base 14 type 1 font </summary>
+        public const string COURIER_BOLDOBLIQUE = BaseFont.COURIER_BOLDOBLIQUE;
+    
+        /// <summary> This is a possible value of a base 14 type 1 font </summary>
+        public const string HELVETICA = BaseFont.HELVETICA;
+    
+        /// <summary> This is a possible value of a base 14 type 1 font </summary>
+        public const string HELVETICA_BOLD = BaseFont.HELVETICA_BOLD;
+    
+        /// <summary> This is a possible value of a base 14 type 1 font </summary>
+        public const string HELVETICA_OBLIQUE = BaseFont.HELVETICA_OBLIQUE;
+    
+        /// <summary> This is a possible value of a base 14 type 1 font </summary>
+        public const string HELVETICA_BOLDOBLIQUE = BaseFont.HELVETICA_BOLDOBLIQUE;
+    
+        /// <summary> This is a possible value of a base 14 type 1 font </summary>
+        public const string SYMBOL = BaseFont.SYMBOL;
+    
+        /// <summary> This is a possible value of a base 14 type 1 font </summary>
+        public const string TIMES = "Times";
+    
+        /// <summary> This is a possible value of a base 14 type 1 font </summary>
+        public const string TIMES_ROMAN = BaseFont.TIMES_ROMAN;
+    
+        /// <summary> This is a possible value of a base 14 type 1 font </summary>
+        public const string TIMES_BOLD = BaseFont.TIMES_BOLD;
+    
+        /// <summary> This is a possible value of a base 14 type 1 font </summary>
+        public const string TIMES_ITALIC = BaseFont.TIMES_ITALIC;
+    
+        /// <summary> This is a possible value of a base 14 type 1 font </summary>
+        public const string TIMES_BOLDITALIC = BaseFont.TIMES_BOLDITALIC;
+    
+        /// <summary> This is a possible value of a base 14 type 1 font </summary>
+        public const string ZAPFDINGBATS = BaseFont.ZAPFDINGBATS;
+        
+        private static FontFactoryImp fontImp = new FontFactoryImp();
+
+        /// <summary> This is the default encoding to use. </summary>
+        private static string defaultEncoding = BaseFont.WINANSI;
+    
+        /// <summary> This is the default value of the <VAR>embedded</VAR> variable. </summary>
+        private static bool defaultEmbedding = BaseFont.NOT_EMBEDDED;
+    
+        /// <summary> Creates new FontFactory </summary>
+        private FontFactory() {
+        }
+    
+        /// <summary>
+        /// Constructs a Font-object.
+        /// </summary>
+        /// <param name="fontname">the name of the font</param>
+        /// <param name="encoding">the encoding of the font</param>
+        /// <param name="embedded">true if the font is to be embedded in the PDF</param>
+        /// <param name="size">the size of this font</param>
+        /// <param name="style">the style of this font</param>
+        /// <param name="color">the Color of this font</param>
+        /// <returns>a Font object</returns>
+        public static Font GetFont(string fontname, string encoding, bool embedded, float size, int style, Color color) {
+            return fontImp.GetFont(fontname, encoding, embedded, size, style, color);
+        }
+    
+        /// <summary>
+        /// Constructs a Font-object.
+        /// </summary>
+        /// <param name="fontname">the name of the font</param>
+        /// <param name="encoding">the encoding of the font</param>
+        /// <param name="embedded">true if the font is to be embedded in the PDF</param>
+        /// <param name="size">the size of this font</param>
+        /// <param name="style">the style of this font</param>
+        /// <param name="color">the Color of this font</param>
+        /// <param name="cached">true if the font comes from the cache or is added to the cache if new, false if the font is always created new</param>
+        /// <returns>a Font object</returns>
+        public static Font GetFont(string fontname, string encoding, bool embedded, float size, int style, Color color, bool cached) {
+            return fontImp.GetFont(fontname, encoding, embedded, size, style, color, cached);
+        }
+    
+        /// <summary>
+        /// Constructs a Font-object.
+        /// </summary>
+        /// <param name="attributes">the attributes of a Font object</param>
+        /// <returns>a Font object</returns>
+        public static Font GetFont(Properties attributes) {
+            fontImp.DefaultEmbedding = defaultEmbedding;
+            fontImp.DefaultEncoding = defaultEncoding;
+            return fontImp.GetFont(attributes);
+        }
+    
+        /// <summary>
+        /// Constructs a Font-object.
+        /// </summary>
+        /// <param name="fontname">the name of the font</param>
+        /// <param name="encoding">the encoding of the font</param>
+        /// <param name="embedded">true if the font is to be embedded in the PDF</param>
+        /// <param name="size">the size of this font</param>
+        /// <param name="style">the style of this font</param>
+        /// <returns>a Font object</returns>
+        public static Font GetFont(string fontname, string encoding, bool embedded, float size, int style) {
+            return GetFont(fontname, encoding, embedded, size, style, null);
+        }
+    
+        /// <summary>
+        /// Constructs a Font-object.
+        /// </summary>
+        /// <param name="fontname">the name of the font</param>
+        /// <param name="encoding">the encoding of the font</param>
+        /// <param name="embedded">true if the font is to be embedded in the PDF</param>
+        /// <param name="size">the size of this font</param>
+        /// <returns></returns>
+        public static Font GetFont(string fontname, string encoding, bool embedded, float size) {
+            return GetFont(fontname, encoding, embedded, size, Font.UNDEFINED, null);
+        }
+    
+        /// <summary>
+        /// Constructs a Font-object.
+        /// </summary>
+        /// <param name="fontname">the name of the font</param>
+        /// <param name="encoding">the encoding of the font</param>
+        /// <param name="embedded">true if the font is to be embedded in the PDF</param>
+        /// <returns>a Font object</returns>
+        public static Font GetFont(string fontname, string encoding, bool embedded) {
+            return GetFont(fontname, encoding, embedded, Font.UNDEFINED, Font.UNDEFINED, null);
+        }
+    
+        /// <summary>
+        /// Constructs a Font-object.
+        /// </summary>
+        /// <param name="fontname">the name of the font</param>
+        /// <param name="encoding">the encoding of the font</param>
+        /// <param name="size">the size of this font</param>
+        /// <param name="style">the style of this font</param>
+        /// <param name="color">the Color of this font</param>
+        /// <returns>a Font object</returns>
+        public static Font GetFont(string fontname, string encoding, float size, int style, Color color) {
+            return GetFont(fontname, encoding, defaultEmbedding, size, style, color);
+        }
+    
+        /// <summary>
+        /// Constructs a Font-object.
+        /// </summary>
+        /// <param name="fontname">the name of the font</param>
+        /// <param name="encoding">the encoding of the font</param>
+        /// <param name="size">the size of this font</param>
+        /// <param name="style">the style of this font</param>
+        /// <returns>a Font object</returns>
+        public static Font GetFont(string fontname, string encoding, float size, int style) {
+            return GetFont(fontname, encoding, defaultEmbedding, size, style, null);
+        }
+    
+        /// <summary>
+        /// Constructs a Font-object.
+        /// </summary>
+        /// <param name="fontname">the name of the font</param>
+        /// <param name="encoding">the encoding of the font</param>
+        /// <param name="size">the size of this font</param>
+        /// <returns>a Font object</returns>
+        public static Font GetFont(string fontname, string encoding, float size) {
+            return GetFont(fontname, encoding, defaultEmbedding, size, Font.UNDEFINED, null);
+        }
+    
+        /// <summary>
+        /// Constructs a Font-object.
+        /// </summary>
+        /// <param name="fontname">the name of the font</param>
+        /// <param name="encoding">the encoding of the font</param>
+        /// <returns>a Font object</returns>
+        public static Font GetFont(string fontname, string encoding) {
+            return GetFont(fontname, encoding, defaultEmbedding, Font.UNDEFINED, Font.UNDEFINED, null);
+        }
+    
+        /// <summary>
+        /// Constructs a Font-object.
+        /// </summary>
+        /// <param name="fontname">the name of the font</param>
+        /// <param name="size">the size of this font</param>
+        /// <param name="style">the style of this font</param>
+        /// <param name="color">the Color of this font</param>
+        /// <returns>a Font object</returns>
+        public static Font GetFont(string fontname, float size, int style, Color color) {
+            return GetFont(fontname, defaultEncoding, defaultEmbedding, size, style, color);
+        }
+    
+        /// <summary>
+        /// Constructs a Font-object.
+        /// </summary>
+        /// <param name="fontname">the name of the font</param>
+        /// <param name="size">the size of this font</param>
+        /// <param name="color">the Color of this font</param>
+        /// <returns>a Font object</returns>
+        public static Font GetFont(string fontname, float size, Color color) {
+            return GetFont(fontname, defaultEncoding, defaultEmbedding, size, Font.UNDEFINED, color);
+        }
+        
+        /// <summary>
+        /// Constructs a Font-object.
+        /// </summary>
+        /// <param name="fontname">the name of the font</param>
+        /// <param name="size">the size of this font</param>
+        /// <param name="style">the style of this font</param>
+        /// <returns>a Font object</returns>
+        public static Font GetFont(string fontname, float size, int style) {
+            return GetFont(fontname, defaultEncoding, defaultEmbedding, size, style, null);
+        }
+    
+        /// <summary>
+        /// Constructs a Font-object.
+        /// </summary>
+        /// <param name="fontname">the name of the font</param>
+        /// <param name="size">the size of this font</param>
+        /// <returns>a Font object</returns>
+        public static Font GetFont(string fontname, float size) {
+            return GetFont(fontname, defaultEncoding, defaultEmbedding, size, Font.UNDEFINED, null);
+        }
+    
+        /// <summary>
+        /// Constructs a Font-object.
+        /// </summary>
+        /// <param name="fontname">the name of the font</param>
+        /// <returns>a Font object</returns>
+        public static Font GetFont(string fontname) {
+            return GetFont(fontname, defaultEncoding, defaultEmbedding, Font.UNDEFINED, Font.UNDEFINED, null);
+        }
+
+        /**
+        * Register a font by giving explicitly the font family and name.
+        * @param familyName the font family
+        * @param fullName the font name
+        * @param path the font path
+        */
+        public void RegisterFamily(String familyName, String fullName, String path) {
+            fontImp.RegisterFamily(familyName, fullName, path);
+        }
+        
+        public static void Register(Properties attributes) {
+            string path;
+            string alias = null;
+
+            path = attributes.Remove("path");
+            alias = attributes.Remove("alias");
+
+            fontImp.Register(path, alias);
+        }
+    
+        /// <summary>
+        /// Register a ttf- or a ttc-file.
+        /// </summary>
+        /// <param name="path">the path to a ttf- or ttc-file</param>
+        public static void Register(string path) {
+            Register(path, null);
+        }
+    
+        /// <summary>
+        /// Register a ttf- or a ttc-file and use an alias for the font contained in the ttf-file.
+        /// </summary>
+        /// <param name="path">the path to a ttf- or ttc-file</param>
+        /// <param name="alias">the alias you want to use for the font</param>
+        public static void Register(string path, string alias) {
+            fontImp.Register(path, alias);
+        }
+    
+        /** Register all the fonts in a directory.
+        * @param dir the directory
+        * @return the number of fonts registered
+        */    
+        public static int RegisterDirectory(String dir) {
+            return fontImp.RegisterDirectory(dir);
+        }
+
+        /**
+        * Register all the fonts in a directory and possibly its subdirectories.
+        * @param dir the directory
+        * @param scanSubdirectories recursively scan subdirectories if <code>true</true>
+        * @return the number of fonts registered
+        * @since 2.1.2
+        */
+        public static int RegisterDirectory(String dir, bool scanSubdirectories) {
+            return fontImp.RegisterDirectory(dir, scanSubdirectories);
+        }
+            
+        /** Register fonts in some probable directories. It usually works in Windows,
+        * Linux and Solaris.
+        * @return the number of fonts registered
+        */    
+        public static int RegisterDirectories() {
+            return fontImp.RegisterDirectories();
+        }
+
+        /// <summary>
+        /// Gets a set of registered fontnames.
+        /// </summary>
+        /// <value>a set of registered fontnames</value>
+        public static ICollection RegisteredFonts {
+            get {
+                return fontImp.RegisteredFonts;
+            }
+        }
+    
+        /// <summary>
+        /// Gets a set of registered font families.
+        /// </summary>
+        /// <value>a set of registered font families</value>
+        public static ICollection RegisteredFamilies {
+            get {
+                return fontImp.RegisteredFamilies;
+            }
+        }
+    
+        /// <summary>
+        /// Checks whether the given font is contained within the object
+        /// </summary>
+        /// <param name="fontname">the name of the font</param>
+        /// <returns>true if font is contained within the object</returns>
+        public static bool Contains(string fontname) {
+            return fontImp.IsRegistered(fontname);
+        }
+    
+        /// <summary>
+        /// Checks if a certain font is registered.
+        /// </summary>
+        /// <param name="fontname">the name of the font that has to be checked</param>
+        /// <returns>true if the font is found</returns>
+        public static bool IsRegistered(string fontname) {
+            return fontImp.IsRegistered(fontname);
+        }
+
+        public static string DefaultEncoding {
+            get {
+                return defaultEncoding;
+            }
+        }
+
+        public static bool DefaultEmbedding {
+            get {
+                return defaultEmbedding;
+            }
+        }
+
+
+        public static FontFactoryImp FontImp {
+            get {
+                return fontImp;
+            }
+            set {
+                if (value == null)
+                    throw new ArgumentNullException("FontFactoryImp cannot be null.");
+                fontImp = value;
+            }
+        }
+    }
+}

src/core/iTextSharp/text/FontFactoryImp.cs

@@ -0,0 +1,677 @@
+using System;
+using System.IO;
+using System.Collections;
+using System.util;
+using System.Globalization;
+
+using iTextSharp.text.html;
+using iTextSharp.text.pdf;
+using iTextSharp.text;
+
+/*
+ * $Id: FontFactoryImp.cs,v 1.13 2008/05/13 11:25:10 psoares33 Exp $
+ * 
+ *
+ * Copyright 2002 by Bruno Lowagie.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+namespace iTextSharp.text {
+    /// <summary>
+    /// If you are using True Type fonts, you can declare the paths of the different ttf- and ttc-files
+    /// to this class first and then create fonts in your code using one of the getFont method
+    /// without having to enter a path as parameter.
+    /// </summary>
+    public class FontFactoryImp {
+        
+        /// <summary> This is a map of postscriptfontnames of True Type fonts and the path of their ttf- or ttc-file. </summary>
+        private Properties trueTypeFonts = new Properties();
+
+        private static String[] TTFamilyOrder = {
+            "3", "1", "1033",
+            "3", "0", "1033",
+            "1", "0", "0",
+            "0", "3", "0"
+        };
+        
+        /// <summary> This is a map of fontfamilies. </summary>
+        private Hashtable fontFamilies = new Hashtable();
+    
+        /// <summary> This is the default encoding to use. </summary>
+        private string defaultEncoding = BaseFont.WINANSI;
+    
+        /// <summary> This is the default value of the <VAR>embedded</VAR> variable. </summary>
+        private bool defaultEmbedding = BaseFont.NOT_EMBEDDED;
+    
+        /// <summary> Creates new FontFactory </summary>
+        public FontFactoryImp() {
+            trueTypeFonts.Add(FontFactory.COURIER.ToLower(CultureInfo.InvariantCulture), FontFactory.COURIER);
+            trueTypeFonts.Add(FontFactory.COURIER_BOLD.ToLower(CultureInfo.InvariantCulture), FontFactory.COURIER_BOLD);
+            trueTypeFonts.Add(FontFactory.COURIER_OBLIQUE.ToLower(CultureInfo.InvariantCulture), FontFactory.COURIER_OBLIQUE);
+            trueTypeFonts.Add(FontFactory.COURIER_BOLDOBLIQUE.ToLower(CultureInfo.InvariantCulture), FontFactory.COURIER_BOLDOBLIQUE);
+            trueTypeFonts.Add(FontFactory.HELVETICA.ToLower(CultureInfo.InvariantCulture), FontFactory.HELVETICA);
+            trueTypeFonts.Add(FontFactory.HELVETICA_BOLD.ToLower(CultureInfo.InvariantCulture), FontFactory.HELVETICA_BOLD);
+            trueTypeFonts.Add(FontFactory.HELVETICA_OBLIQUE.ToLower(CultureInfo.InvariantCulture), FontFactory.HELVETICA_OBLIQUE);
+            trueTypeFonts.Add(FontFactory.HELVETICA_BOLDOBLIQUE.ToLower(CultureInfo.InvariantCulture), FontFactory.HELVETICA_BOLDOBLIQUE);
+            trueTypeFonts.Add(FontFactory.SYMBOL.ToLower(CultureInfo.InvariantCulture), FontFactory.SYMBOL);
+            trueTypeFonts.Add(FontFactory.TIMES_ROMAN.ToLower(CultureInfo.InvariantCulture), FontFactory.TIMES_ROMAN);
+            trueTypeFonts.Add(FontFactory.TIMES_BOLD.ToLower(CultureInfo.InvariantCulture), FontFactory.TIMES_BOLD);
+            trueTypeFonts.Add(FontFactory.TIMES_ITALIC.ToLower(CultureInfo.InvariantCulture), FontFactory.TIMES_ITALIC);
+            trueTypeFonts.Add(FontFactory.TIMES_BOLDITALIC.ToLower(CultureInfo.InvariantCulture), FontFactory.TIMES_BOLDITALIC);
+            trueTypeFonts.Add(FontFactory.ZAPFDINGBATS.ToLower(CultureInfo.InvariantCulture), FontFactory.ZAPFDINGBATS);
+
+            ArrayList tmp;
+            tmp = new ArrayList();
+            tmp.Add(FontFactory.COURIER);
+            tmp.Add(FontFactory.COURIER_BOLD);
+            tmp.Add(FontFactory.COURIER_OBLIQUE);
+            tmp.Add(FontFactory.COURIER_BOLDOBLIQUE);
+            fontFamilies[FontFactory.COURIER.ToLower(CultureInfo.InvariantCulture)] = tmp;
+            tmp = new ArrayList();
+            tmp.Add(FontFactory.HELVETICA);
+            tmp.Add(FontFactory.HELVETICA_BOLD);
+            tmp.Add(FontFactory.HELVETICA_OBLIQUE);
+            tmp.Add(FontFactory.HELVETICA_BOLDOBLIQUE);
+            fontFamilies[FontFactory.HELVETICA.ToLower(CultureInfo.InvariantCulture)] = tmp;
+            tmp = new ArrayList();
+            tmp.Add(FontFactory.SYMBOL);
+            fontFamilies[FontFactory.SYMBOL.ToLower(CultureInfo.InvariantCulture)] = tmp;
+            tmp = new ArrayList();
+            tmp.Add(FontFactory.TIMES_ROMAN);
+            tmp.Add(FontFactory.TIMES_BOLD);
+            tmp.Add(FontFactory.TIMES_ITALIC);
+            tmp.Add(FontFactory.TIMES_BOLDITALIC);
+            fontFamilies[FontFactory.TIMES.ToLower(CultureInfo.InvariantCulture)] = tmp;
+            fontFamilies[FontFactory.TIMES_ROMAN.ToLower(CultureInfo.InvariantCulture)] = tmp;
+            tmp = new ArrayList();
+            tmp.Add(FontFactory.ZAPFDINGBATS);
+            fontFamilies[FontFactory.ZAPFDINGBATS.ToLower(CultureInfo.InvariantCulture)] = tmp;
+        }
+    
+        /// <summary>
+        /// Constructs a Font-object.
+        /// </summary>
+        /// <param name="fontname">the name of the font</param>
+        /// <param name="encoding">the encoding of the font</param>
+        /// <param name="embedded">true if the font is to be embedded in the PDF</param>
+        /// <param name="size">the size of this font</param>
+        /// <param name="style">the style of this font</param>
+        /// <param name="color">the Color of this font</param>
+        /// <returns>a Font object</returns>
+        public virtual Font GetFont(string fontname, string encoding, bool embedded, float size, int style, Color color) {
+            return GetFont(fontname, encoding, embedded, size, style, color, true);
+        }
+
+        /// <summary>
+        /// Constructs a Font-object.
+        /// </summary>
+        /// <param name="fontname">the name of the font</param>
+        /// <param name="encoding">the encoding of the font</param>
+        /// <param name="embedded">true if the font is to be embedded in the PDF</param>
+        /// <param name="size">the size of this font</param>
+        /// <param name="style">the style of this font</param>
+        /// <param name="color">the Color of this font</param>
+        /// <param name="cached">true if the font comes from the cache or is added to the cache if new, false if the font is always created new</param>
+        /// <returns>a Font object</returns>
+        public virtual Font GetFont(string fontname, string encoding, bool embedded, float size, int style, Color color, bool cached) {
+            if (fontname == null) return new Font(Font.UNDEFINED, size, style, color);
+            string lowercasefontname = fontname.ToLower(CultureInfo.InvariantCulture);
+            ArrayList tmp = (ArrayList) fontFamilies[lowercasefontname];
+            if (tmp != null) {
+                // some bugs were fixed here by Daniel Marczisovszky
+                int fs = Font.NORMAL;
+                bool found = false;
+                int s = style == Font.UNDEFINED ? Font.NORMAL : style;
+                foreach (string f in tmp) {
+                    string lcf = f.ToLower(CultureInfo.InvariantCulture);
+                    fs = Font.NORMAL;
+                    if (lcf.ToLower(CultureInfo.InvariantCulture).IndexOf("bold") != -1) fs |= Font.BOLD;
+                    if (lcf.ToLower(CultureInfo.InvariantCulture).IndexOf("italic") != -1 || lcf.ToLower(CultureInfo.InvariantCulture).IndexOf("oblique") != -1) fs |= Font.ITALIC;
+                    if ((s & Font.BOLDITALIC) == fs) {
+                        fontname = f;
+                        found = true;
+                        break;
+                    }
+                }
+                if (style != Font.UNDEFINED && found) {
+                    style &= ~fs;
+                }
+            }
+            BaseFont basefont = null;
+            try {
+                try {
+                    // the font is a type 1 font or CJK font
+                    basefont = BaseFont.CreateFont(fontname, encoding, embedded, cached, null, null, true);
+                }
+                catch (DocumentException) {
+                }
+                if (basefont == null) {
+                    // the font is a true type font or an unknown font
+                    fontname = trueTypeFonts[fontname.ToLower(CultureInfo.InvariantCulture)];
+                    // the font is not registered as truetype font
+                    if (fontname == null) return new Font(Font.UNDEFINED, size, style, color);
+                    // the font is registered as truetype font
+                    basefont = BaseFont.CreateFont(fontname, encoding, embedded, cached, null, null);
+                }
+            }
+            catch (DocumentException de) {
+                // this shouldn't happen
+                throw de;
+            }
+            catch (System.IO.IOException) {
+                // the font is registered as a true type font, but the path was wrong
+                return new Font(Font.UNDEFINED, size, style, color);
+            }
+            catch {
+                // null was entered as fontname and/or encoding
+                return new Font(Font.UNDEFINED, size, style, color);
+            }
+            return new Font(basefont, size, style, color);
+        }
+    
+        /// <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;
+            Color 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 Color(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>
+        /// Constructs a Font-object.
+        /// </summary>
+        /// <param name="fontname">the name of the font</param>
+        /// <param name="encoding">the encoding of the font</param>
+        /// <param name="embedded">true if the font is to be embedded in the PDF</param>
+        /// <param name="size">the size of this font</param>
+        /// <param name="style">the style of this font</param>
+        /// <returns>a Font object</returns>
+        public Font GetFont(string fontname, string encoding, bool embedded, float size, int style) {
+            return GetFont(fontname, encoding, embedded, size, style, null);
+        }
+    
+        /// <summary>
+        /// Constructs a Font-object.
+        /// </summary>
+        /// <param name="fontname">the name of the font</param>
+        /// <param name="encoding">the encoding of the font</param>
+        /// <param name="embedded">true if the font is to be embedded in the PDF</param>
+        /// <param name="size">the size of this font</param>
+        /// <returns></returns>
+        public virtual Font GetFont(string fontname, string encoding, bool embedded, float size) {
+            return GetFont(fontname, encoding, embedded, size, Font.UNDEFINED, null);
+        }
+    
+        /// <summary>
+        /// Constructs a Font-object.
+        /// </summary>
+        /// <param name="fontname">the name of the font</param>
+        /// <param name="encoding">the encoding of the font</param>
+        /// <param name="embedded">true if the font is to be embedded in the PDF</param>
+        /// <returns>a Font object</returns>
+        public virtual Font GetFont(string fontname, string encoding, bool embedded) {
+            return GetFont(fontname, encoding, embedded, Font.UNDEFINED, Font.UNDEFINED, null);
+        }
+    
+        /// <summary>
+        /// Constructs a Font-object.
+        /// </summary>
+        /// <param name="fontname">the name of the font</param>
+        /// <param name="encoding">the encoding of the font</param>
+        /// <param name="size">the size of this font</param>
+        /// <param name="style">the style of this font</param>
+        /// <param name="color">the Color of this font</param>
+        /// <returns>a Font object</returns>
+        public virtual Font GetFont(string fontname, string encoding, float size, int style, Color color) {
+            return GetFont(fontname, encoding, defaultEmbedding, size, style, color);
+        }
+    
+        /// <summary>
+        /// Constructs a Font-object.
+        /// </summary>
+        /// <param name="fontname">the name of the font</param>
+        /// <param name="encoding">the encoding of the font</param>
+        /// <param name="size">the size of this font</param>
+        /// <param name="style">the style of this font</param>
+        /// <returns>a Font object</returns>
+        public virtual Font GetFont(string fontname, string encoding, float size, int style) {
+            return GetFont(fontname, encoding, defaultEmbedding, size, style, null);
+        }
+    
+        /// <summary>
+        /// Constructs a Font-object.
+        /// </summary>
+        /// <param name="fontname">the name of the font</param>
+        /// <param name="encoding">the encoding of the font</param>
+        /// <param name="size">the size of this font</param>
+        /// <returns>a Font object</returns>
+        public virtual Font GetFont(string fontname, string encoding, float size) {
+            return GetFont(fontname, encoding, defaultEmbedding, size, Font.UNDEFINED, null);
+        }
+    
+        /// <summary>
+        /// Constructs a Font-object.
+        /// </summary>
+        /// <param name="fontname">the name of the font</param>
+        /// <param name="encoding">the encoding of the font</param>
+        /// <returns>a Font object</returns>
+        public virtual Font GetFont(string fontname, string encoding) {
+            return GetFont(fontname, encoding, defaultEmbedding, Font.UNDEFINED, Font.UNDEFINED, null);
+        }
+    
+        /// <summary>
+        /// Constructs a Font-object.
+        /// </summary>
+        /// <param name="fontname">the name of the font</param>
+        /// <param name="size">the size of this font</param>
+        /// <param name="style">the style of this font</param>
+        /// <param name="color">the Color of this font</param>
+        /// <returns>a Font object</returns>
+        public virtual Font GetFont(string fontname, float size, int style, Color color) {
+            return GetFont(fontname, defaultEncoding, defaultEmbedding, size, style, color);
+        }
+    
+        /// <summary>
+        /// Constructs a Font-object.
+        /// </summary>
+        /// <param name="fontname">the name of the font</param>
+        /// <param name="size">the size of this font</param>
+        /// <param name="color">the Color of this font</param>
+        /// <returns>a Font object</returns>
+        public virtual Font GetFont(string fontname, float size, Color color) {
+            return GetFont(fontname, defaultEncoding, defaultEmbedding, size, Font.UNDEFINED, color);
+        }
+        
+        /// <summary>
+        /// Constructs a Font-object.
+        /// </summary>
+        /// <param name="fontname">the name of the font</param>
+        /// <param name="size">the size of this font</param>
+        /// <param name="style">the style of this font</param>
+        /// <returns>a Font object</returns>
+        public virtual Font GetFont(string fontname, float size, int style) {
+            return GetFont(fontname, defaultEncoding, defaultEmbedding, size, style, null);
+        }
+    
+        /// <summary>
+        /// Constructs a Font-object.
+        /// </summary>
+        /// <param name="fontname">the name of the font</param>
+        /// <param name="size">the size of this font</param>
+        /// <returns>a Font object</returns>
+        public virtual Font GetFont(string fontname, float size) {
+            return GetFont(fontname, defaultEncoding, defaultEmbedding, size, Font.UNDEFINED, null);
+        }
+    
+        /// <summary>
+        /// Constructs a Font-object.
+        /// </summary>
+        /// <param name="fontname">the name of the font</param>
+        /// <returns>a Font object</returns>
+        public virtual Font GetFont(string fontname) {
+            return GetFont(fontname, defaultEncoding, defaultEmbedding, Font.UNDEFINED, Font.UNDEFINED, null);
+        }
+
+        public virtual void Register(Properties attributes) {
+            string path;
+            string alias = null;
+
+            path = attributes.Remove("path");
+            alias = attributes.Remove("alias");
+
+            Register(path, alias);
+        }
+    
+        /**
+        * Register a font by giving explicitly the font family and name.
+        * @param familyName the font family
+        * @param fullName the font name
+        * @param path the font path
+        */
+        public void RegisterFamily(String familyName, String fullName, String path) {
+            if (path != null)
+                trueTypeFonts.Add(fullName, path);
+            ArrayList tmp = (ArrayList) fontFamilies[familyName];
+            if (tmp == null) {
+                tmp = new ArrayList();
+                tmp.Add(fullName);
+                fontFamilies[familyName] = tmp;
+            }
+            else {
+                int fullNameLength = fullName.Length;
+                bool inserted = false;
+                for (int j = 0; j < tmp.Count; ++j) {
+                    if (((String)tmp[j]).Length >= fullNameLength) {
+                        tmp.Insert(j, fullName);
+                        inserted = true;
+                        break;
+                    }
+                }
+                if (!inserted)
+                    tmp.Add(fullName);
+            }
+        }
+
+        /// <summary>
+        /// Register a ttf- or a ttc-file.
+        /// </summary>
+        /// <param name="path">the path to a ttf- or ttc-file</param>
+        public virtual void Register(string path) {
+            Register(path, null);
+        }
+    
+        /// <summary>
+        /// Register a ttf- or a ttc-file and use an alias for the font contained in the ttf-file.
+        /// </summary>
+        /// <param name="path">the path to a ttf- or ttc-file</param>
+        /// <param name="alias">the alias you want to use for the font</param>
+        public virtual void Register(string path, string alias) {
+            try {
+                if (path.ToLower(CultureInfo.InvariantCulture).EndsWith(".ttf") || path.ToLower(CultureInfo.InvariantCulture).EndsWith(".otf") || path.ToLower(CultureInfo.InvariantCulture).IndexOf(".ttc,") > 0) {
+                    Object[] allNames = BaseFont.GetAllFontNames(path, BaseFont.WINANSI, null);
+                    trueTypeFonts.Add(((string)allNames[0]).ToLower(CultureInfo.InvariantCulture), path);
+                    if (alias != null) {
+                        trueTypeFonts.Add(alias.ToLower(CultureInfo.InvariantCulture), path);
+                    }
+                    // register all the font names with all the locales
+                    string[][] names = (string[][])allNames[2]; //full name
+                    for (int i = 0; i < names.Length; i++) {
+                        trueTypeFonts.Add(names[i][3].ToLower(CultureInfo.InvariantCulture), path);
+                    }
+                    string fullName = null;
+                    string familyName = null;
+                    names = (string[][])allNames[1]; //family name
+                    for (int k = 0; k < TTFamilyOrder.Length; k += 3) {
+                        for (int i = 0; i < names.Length; i++) {
+                            if (TTFamilyOrder[k].Equals(names[i][0]) && TTFamilyOrder[k + 1].Equals(names[i][1]) && TTFamilyOrder[k + 2].Equals(names[i][2])) {
+                                familyName = names[i][3].ToLower(CultureInfo.InvariantCulture);
+                                k = TTFamilyOrder.Length;
+                                break;
+                            }
+                        }
+                    }
+                    if (familyName != null) {
+                        String lastName = "";
+                        names = (string[][])allNames[2]; //full name
+                        for (int i = 0; i < names.Length; i++) {
+                            for (int k = 0; k < TTFamilyOrder.Length; k += 3) {
+                                if (TTFamilyOrder[k].Equals(names[i][0]) && TTFamilyOrder[k + 1].Equals(names[i][1]) && TTFamilyOrder[k + 2].Equals(names[i][2])) {
+                                    fullName = names[i][3];
+                                    if (fullName.Equals(lastName))
+                                        continue;
+                                    lastName = fullName;
+                                    RegisterFamily(familyName, fullName, null);
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                }
+                else if (path.ToLower(CultureInfo.InvariantCulture).EndsWith(".ttc")) {
+                    string[] names = BaseFont.EnumerateTTCNames(path);
+                    for (int i = 0; i < names.Length; i++) {
+                        Register(path + "," + i);
+                    }
+                }
+                else if (path.ToLower(CultureInfo.InvariantCulture).EndsWith(".afm") || path.ToLower(CultureInfo.InvariantCulture).EndsWith(".pfm")) {
+                    BaseFont bf = BaseFont.CreateFont(path, BaseFont.CP1252, false);
+                    String fullName = (bf.FullFontName[0][3]).ToLower(CultureInfo.InvariantCulture);
+                    String familyName = (bf.FamilyFontName[0][3]).ToLower(CultureInfo.InvariantCulture);
+                    String psName = bf.PostscriptFontName.ToLower(CultureInfo.InvariantCulture);
+                    RegisterFamily(familyName, fullName, null);
+                    trueTypeFonts.Add(psName, path);
+                    trueTypeFonts.Add(fullName, path);
+                }
+            }
+            catch (DocumentException de) {
+                // this shouldn't happen
+                throw de;
+            }
+            catch (System.IO.IOException ioe) {
+                throw ioe;
+            }
+        }
+    
+        /** Register all the fonts in a directory.
+        * @param dir the directory
+        * @return the number of fonts registered
+        */    
+        public virtual int RegisterDirectory(String dir) {
+            return RegisterDirectory(dir, false);
+        }
+
+        /**
+        * Register all the fonts in a directory and possibly its subdirectories.
+        * @param dir the directory
+        * @param scanSubdirectories recursively scan subdirectories if <code>true</true>
+        * @return the number of fonts registered
+        * @since 2.1.2
+        */
+        public int RegisterDirectory(String dir, bool scanSubdirectories) {
+            int count = 0;
+            try {
+                if (!Directory.Exists(dir))
+                    return 0;
+                string[] files = Directory.GetFiles(dir);
+                if (files == null)
+                    return 0;
+                for (int k = 0; k < files.Length; ++k) {
+                    try {
+                        if (Directory.Exists(files[k])) {
+                            if (scanSubdirectories) {
+                                count += RegisterDirectory(Path.GetFullPath(files[k]), true);
+                            }
+                        } else {
+                            String name = Path.GetFullPath(files[k]);
+                            String suffix = name.Length < 4 ? null : name.Substring(name.Length - 4).ToLower(CultureInfo.InvariantCulture);
+                            if (".afm".Equals(suffix) || ".pfm".Equals(suffix)) {
+                                /* Only register Type 1 fonts with matching .pfb files */
+                                string pfb = name.Substring(0, name.Length - 4) + ".pfb";
+                                if (File.Exists(pfb)) {
+                                    Register(name, null);
+                                    ++count;
+                                }
+                            } else if (".ttf".Equals(suffix) || ".otf".Equals(suffix) || ".ttc".Equals(suffix)) {
+                                Register(name, null);
+                                ++count;
+                            }
+                        }
+                    }
+                    catch  {
+                        //empty on purpose
+                    }
+                }
+            }
+            catch  {
+                //empty on purpose
+            }
+            return count;
+        }
+
+        /** Register fonts in some probable directories. It usually works in Windows,
+        * Linux and Solaris.
+        * @return the number of fonts registered
+        */    
+        public virtual int RegisterDirectories() {
+            int count = 0;
+            count += RegisterDirectory("c:/windows/fonts");
+            count += RegisterDirectory("c:/winnt/fonts");
+            count += RegisterDirectory("d:/windows/fonts");
+            count += RegisterDirectory("d:/winnt/fonts");
+            count += RegisterDirectory("/usr/share/X11/fonts", true);
+            count += RegisterDirectory("/usr/X/lib/X11/fonts", true);
+            count += RegisterDirectory("/usr/openwin/lib/X11/fonts", true);
+            count += RegisterDirectory("/usr/share/fonts", true);
+            count += RegisterDirectory("/usr/X11R6/lib/X11/fonts", true);
+            count += RegisterDirectory("/Library/Fonts");
+            count += RegisterDirectory("/System/Library/Fonts");
+            return count;
+        }
+
+        /// <summary>
+        /// Gets a set of registered fontnames.
+        /// </summary>
+        /// <value>a set of registered fontnames</value>
+        public virtual ICollection RegisteredFonts {
+            get {
+                return trueTypeFonts.Keys;
+            }
+        }
+    
+        /// <summary>
+        /// Gets a set of registered font families.
+        /// </summary>
+        /// <value>a set of registered font families</value>
+        public virtual ICollection RegisteredFamilies {
+            get {
+                return fontFamilies.Keys;
+            }
+        }
+    
+        /// <summary>
+        /// Checks if a certain font is registered.
+        /// </summary>
+        /// <param name="fontname">the name of the font that has to be checked</param>
+        /// <returns>true if the font is found</returns>
+        public virtual bool IsRegistered(string fontname) {
+            return trueTypeFonts.ContainsKey(fontname.ToLower(CultureInfo.InvariantCulture));
+        }
+
+        public virtual string DefaultEncoding {
+            get {
+                return defaultEncoding;
+            }
+            set {
+                defaultEncoding = value;
+            }
+        }
+
+        public virtual bool DefaultEmbedding {
+            get {
+                return defaultEmbedding;
+            }
+            set {
+                defaultEmbedding = value;
+            }
+        }
+    }
+}

src/core/iTextSharp/text/GreekList.cs

@@ -0,0 +1,124 @@
+using System;
+using iTextSharp.text.factories;
+/*
+ * Copyright 2003 by Michael Niedermair.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+
+namespace iTextSharp.text
+{
+    /**
+    * 
+    * A special-version of <CODE>LIST</CODE> whitch use greek-letters.
+    * 
+    * @see com.lowagie.text.List
+    */
+    public class GreekList : List {
+        /**
+        * Initialization
+        * 
+        * @param symbolIndent   indent
+        */
+        public GreekList() : base(true) {
+            SetGreekFont();
+        }
+
+        /**
+        * Initialisierung
+        * 
+        * @param symbolIndent   indent
+        */
+        public GreekList(int symbolIndent) : base(true, symbolIndent) {
+            SetGreekFont();
+        }
+
+        /**
+        * Initialisierung 
+        * @param    greeklower      greek-char in lowercase   
+        * @param    symbolIndent    indent
+        */
+        public GreekList(bool greeklower, int symbolIndent) : base(true, symbolIndent) {
+            lowercase = greeklower;
+            SetGreekFont();
+        }
+
+        /**
+        * change the font to SYMBOL
+        */
+        protected void SetGreekFont() {
+            float fontsize = symbol.Font.Size;
+            symbol.Font = FontFactory.GetFont(FontFactory.SYMBOL, fontsize, Font.NORMAL);
+        }
+
+        /**
+        * Adds an <CODE>Object</CODE> to the <CODE>List</CODE>.
+        *
+        * @param    o   the object to add.
+        * @return true if adding the object succeeded
+        */
+        public override bool Add(Object o) {
+            if (o is ListItem) {
+                ListItem item = (ListItem) o;
+                Chunk chunk = new Chunk(preSymbol, symbol.Font);
+                chunk.Append(GreekAlphabetFactory.GetString(first + list.Count, lowercase));
+                chunk.Append(postSymbol);
+                item.ListSymbol = chunk;
+                item.SetIndentationLeft(symbolIndent, autoindent);
+                item.IndentationRight = 0;
+                list.Add(item);
+                return true;
+            } else if (o is List) {
+                List nested = (List) o;
+                nested.IndentationLeft = nested.IndentationLeft + symbolIndent;
+                first--;
+                list.Add(nested);
+                return true;
+            } else if (o is string) {
+                return this.Add(new ListItem((string)o));
+            }
+            return false;
+        }
+    }
+}

src/core/iTextSharp/text/Header.cs

@@ -0,0 +1,94 @@
+using System;
+using System.Text;
+
+/*
+ * $Id: Header.cs,v 1.4 2008/05/13 11:25:10 psoares33 Exp $
+ * 
+ *
+ * Copyright 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+
+namespace iTextSharp.text {
+    /// <summary>
+    /// This is an Element that contains
+    /// some userdefined meta information about the document.
+    /// </summary>
+    /// <example>
+    /// <code>
+    /// <strong>Header header = new Header("inspired by", "William Shakespeare");</strong>
+    /// </code>
+    /// </example>
+    public class Header : Meta {
+    
+        // membervariables
+    
+        /// <summary> This is the content of this chunk of text. </summary>
+        private StringBuilder name;
+    
+        // constructors
+    
+        /// <summary>
+        /// Constructs a Header.
+        /// </summary>
+        /// <param name="name">the name of the meta-information</param>
+        /// <param name="content">the content</param>
+        public Header(string name, string content) : base(Element.HEADER, content) {
+            this.name = new StringBuilder(name);
+        }
+    
+        // methods to retrieve information
+    
+        /// <summary>
+        /// Returns the name of the meta information.
+        /// </summary>
+        /// <value>a string</value>
+        public override string Name {
+            get {
+                return name.ToString();
+            }
+        }
+    }
+}

src/core/iTextSharp/text/HeaderFooter.cs

@@ -0,0 +1,234 @@
+using System;
+using System.util;
+using System.Collections;
+
+/*
+ * $Id: HeaderFooter.cs,v 1.6 2008/05/13 11:25:10 psoares33 Exp $
+ * 
+ *
+ * Copyright 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+
+namespace iTextSharp.text {
+    /// <summary>
+    /// A HeaderFooter-object is a Rectangle with text
+    /// that can be put above and/or below every page.
+    /// </summary>
+    /// <example>
+    /// <code>
+    /// <strong>HeaderFooter header = new HeaderFooter(new Phrase("This is a header."), false);
+    /// HeaderFooter footer = new HeaderFooter(new Phrase("This is page "), new Phrase("."));</strong>
+    /// document.SetHeader(header);
+    /// document.SetFooter(footer);
+    /// </code>
+    /// </example>
+    public class HeaderFooter : Rectangle {
+    
+        // membervariables
+    
+        /// <summary> Does the page contain a pagenumber? </summary>
+        private bool numbered;
+    
+        /// <summary> This is the Phrase that comes before the pagenumber. </summary>
+        private Phrase before = null;
+    
+        /// <summary> This is number of the page. </summary>
+        private int pageN;
+    
+        /// <summary> This is the Phrase that comes after the pagenumber. </summary>
+        private Phrase after = null;
+    
+        /// <summary> This is alignment of the header/footer. </summary>
+        private int alignment;
+    
+        // constructors
+    
+        /// <summary>
+        /// Constructs a HeaderFooter-object.
+        /// </summary>
+        /// <param name="before">the Phrase before the pagenumber</param>
+        /// <param name="after">the Phrase after the pagenumber</param>
+        public HeaderFooter(Phrase before, Phrase after) : base(0, 0, 0, 0) {
+            this.Border = TOP_BORDER + BOTTOM_BORDER;
+            this.BorderWidth = 1;
+        
+            numbered = true;
+            this.before = before;
+            this.after = after;
+        }
+    
+        /// <summary>
+        /// Constructs a Header-object with a pagenumber at the end.
+        /// </summary>
+        /// <param name="before">the Phrase before the pagenumber</param>
+        /// <param name="numbered">true if the page has to be numbered</param>
+        public HeaderFooter(Phrase before, bool numbered) : base(0, 0, 0, 0) {
+            this.Border = TOP_BORDER + BOTTOM_BORDER;
+            this.BorderWidth = 1;
+        
+            this.numbered = numbered;
+            this.before = before;
+        }
+
+        public HeaderFooter(Properties attributes) : base(0, 0, 0, 0) {
+            string value;
+            
+            if ((value = attributes.Remove(ElementTags.NUMBERED)) != null) {
+                this.numbered = bool.Parse(value);
+            }
+            if ((value = attributes.Remove(ElementTags.ALIGN)) != null) {
+                this.SetAlignment(value);
+            }
+            if ((value = attributes.Remove("border")) != null) {
+                this.Border = int.Parse(value);
+            } else {
+                this.Border = TOP_BORDER + BOTTOM_BORDER;
+            }
+        }
+    
+        // methods
+    
+        /// <summary>
+        /// Checks if the HeaderFooter contains a page number.
+        /// </summary>
+        /// <returns>true if the page has to be numbered</returns>
+        public bool IsNumbered() {
+            return numbered;
+        }
+    
+        /// <summary>
+        /// Get/set the part that comes before the pageNumber.
+        /// </summary>
+        /// <value>a Phrase</value>
+        public Phrase Before {
+            get {
+                return before;
+            }
+
+            set {
+                this.before = value;
+            }
+        }
+    
+        /// <summary>
+        /// Get/set the part that comes after the pageNumber.
+        /// </summary>
+        /// <value>a Phrase</value>
+        public Phrase After {
+            get {
+                return after;
+            }
+
+            set {
+                this.after = value;
+            }
+        }
+    
+        /// <summary>
+        /// Sets the page number.
+        /// </summary>
+        /// <value>the new page number</value>
+        public int PageNumber {
+            set {
+                this.pageN = value;
+            }
+        }
+    
+        /// <summary>
+        /// Sets the Element.
+        /// </summary>
+        /// <value>the new alignment</value>
+        public int Alignment{
+            set {
+                this.alignment = value;
+            }
+            get {
+                return this.alignment;
+            }
+        }
+
+        /// <summary>
+        /// Sets the alignment of this HeaderFooter.
+        /// </summary>
+        /// <param name="alignment">the new alignment as a string</param>
+        public void SetAlignment(string alignment) {
+            if (Util.EqualsIgnoreCase(alignment, ElementTags.ALIGN_CENTER)) {
+                this.alignment = Element.ALIGN_CENTER;
+                return;
+            }
+            if (Util.EqualsIgnoreCase(alignment, ElementTags.ALIGN_RIGHT)) {
+                this.alignment = Element.ALIGN_RIGHT;
+                return;
+            }
+            if (Util.EqualsIgnoreCase(alignment, ElementTags.ALIGN_JUSTIFIED)) {
+                this.alignment = Element.ALIGN_JUSTIFIED;
+                return;
+            }
+            this.alignment = Element.ALIGN_LEFT;
+        }
+    
+        // methods to retrieve the membervariables
+    
+        /// <summary>
+        /// Gets the Paragraph that can be used as header or footer.
+        /// </summary>
+        /// <returns>a Paragraph</returns>
+        public Paragraph Paragraph {
+            get {
+                Paragraph paragraph = new Paragraph(before.Leading);
+                paragraph.Add(before);
+                if (numbered) {
+                    paragraph.AddSpecial(new Chunk(pageN.ToString(), before.Font));
+                }
+                if (after != null) {
+                    paragraph.AddSpecial(after);
+                }
+                paragraph.Alignment = alignment;
+                return paragraph;
+            }
+        }
+    }
+}

src/core/iTextSharp/text/IDocListener.cs

@@ -0,0 +1,149 @@
+using System;
+
+/*
+ * $Id: IDocListener.cs,v 1.5 2008/05/13 11:25:10 psoares33 Exp $
+ * 
+ *
+ * Copyright (c) 1999, 2000, 2001, 2002 Bruno Lowagie.
+ *
+ * The contents of this file are subject to the Mozilla License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL LICENSE.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+
+namespace iTextSharp.text {
+    /// <summary>
+    /// A class that implements DocListener will perform some
+    /// actions when some actions are performed on a Document.
+    /// </summary>
+    /// <seealso cref="T:iTextSharp.text.IElementListener"/>
+    /// <seealso cref="T:iTextSharp.text.Document"/>
+    /// <seealso cref="T:iTextSharp.text.DocWriter"/>
+    public interface IDocListener : IElementListener {
+    
+        // methods
+    
+        /// <summary>
+        /// Signals that the Document has been opened and that
+        /// Elements can be added.
+        /// </summary>
+        void Open();
+    
+        /// <summary>
+        /// Signals that the Document was closed and that no other
+        /// Elements will be added.
+        /// </summary>
+        /// <remarks>
+        /// The output stream of every writer implementing IDocListener will be closed.
+        /// </remarks>
+        void Close();
+
+        /// <summary>
+        /// Signals that an new page has to be started.
+        /// </summary>
+        /// <returns>true if the page was added, false if not.</returns>
+        bool NewPage();
+    
+        /// <summary>
+        /// Sets the pagesize.
+        /// </summary>
+        /// <param name="pageSize">the new pagesize</param>
+        /// <returns>a boolean</returns>
+        bool SetPageSize(Rectangle pageSize);
+    
+        /// <summary>
+        /// Sets the margins.
+        /// </summary>
+        /// <param name="marginLeft">the margin on the left</param>
+        /// <param name="marginRight">the margin on the right</param>
+        /// <param name="marginTop">the margin on the top</param>
+        /// <param name="marginBottom">the margin on the bottom</param>
+        /// <returns></returns>
+        bool SetMargins(float marginLeft, float marginRight, float marginTop, float marginBottom);
+    
+        /**
+        * Parameter that allows you to do margin mirroring (odd/even pages)
+        * @param marginMirroring
+        * @return true if succesfull
+        */
+        bool SetMarginMirroring(bool marginMirroring);
+
+        /// <summary>
+        /// Sets the page number.
+        /// </summary>
+        /// <value>the new page number</value>
+        int PageCount {
+            set;
+        }
+    
+        /// <summary>
+        /// Sets the page number to 0.
+        /// </summary>
+        void ResetPageCount();
+    
+        /// <summary>
+        /// Changes the header of this document.
+        /// </summary>
+        /// <value>a Header</value>
+        HeaderFooter Header {
+            set;
+        }
+    
+        /// <summary>
+        /// Resets the header of this document.
+        /// </summary>
+        void ResetHeader();
+    
+        /// <summary>
+        /// Changes the footer of this document.
+        /// </summary>
+        /// <value>a Footer</value>
+        HeaderFooter Footer {
+            set;
+        }
+    
+        /// <summary>
+        /// Resets the footer of this document.
+        /// </summary>
+        void ResetFooter();
+    }
+}

src/core/iTextSharp/text/IElement.cs

@@ -0,0 +1,126 @@
+using System;
+using System.Collections;
+
+/*
+ * $Id: IElement.cs,v 1.4 2008/05/13 11:25:10 psoares33 Exp $
+ * 
+ *
+ * Copyright 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+namespace iTextSharp.text {
+    /// <summary>
+    /// Interface for a text element.
+    /// </summary>
+    /// <seealso cref="T:iTextSharp.text.Anchor"/>
+    /// <seealso cref="T:iTextSharp.text.Cell"/>
+    /// <seealso cref="T:iTextSharp.text.Chapter"/>
+    /// <seealso cref="T:iTextSharp.text.Chunk"/>
+    /// <seealso cref="T:iTextSharp.text.Gif"/>
+    /// <seealso cref="T:iTextSharp.text.Graphic"/>
+    /// <seealso cref="T:iTextSharp.text.Header"/>
+    /// <seealso cref="T:iTextSharp.text.Image"/>
+    /// <seealso cref="T:iTextSharp.text.Jpeg"/>
+    /// <seealso cref="T:iTextSharp.text.List"/>
+    /// <seealso cref="T:iTextSharp.text.ListItem"/>
+    /// <seealso cref="T:iTextSharp.text.Meta"/>
+    /// <seealso cref="T:iTextSharp.text.Paragraph"/>
+    /// <seealso cref="T:iTextSharp.text.Phrase"/>
+    /// <seealso cref="T:iTextSharp.text.Rectangle"/>
+    /// <seealso cref="T:iTextSharp.text.Row"/>
+    /// <seealso cref="T:iTextSharp.text.Section"/>
+    /// <seealso cref="T:iTextSharp.text.Table"/>
+    public interface IElement {
+
+        // methods
+    
+        /// <summary>
+        /// Processes the element by adding it (or the different parts) to an
+        /// IElementListener.
+        /// </summary>
+        /// <param name="listener">an IElementListener</param>
+        /// <returns>true if the element was processed successfully</returns>
+        bool Process(IElementListener listener);
+    
+        /// <summary>
+        /// Gets the type of the text element.
+        /// </summary>
+        /// <value>a type</value>
+        int Type {
+            get;
+        }
+    
+        /**
+        * Checks if this element is a content object.
+        * If not, it's a metadata object.
+        * @since    iText 2.0.8
+        * @return   true if this is a 'content' element; false if this is a 'medadata' element
+        */
+        
+        bool IsContent();
+        
+        /**
+        * Checks if this element is nestable.
+        * @since    iText 2.0.8
+        * @return   true if this element can be nested inside other elements.
+        */
+        
+        bool IsNestable();
+        
+        /// <summary>
+        /// Gets all the chunks in this element.
+        /// </summary>
+        /// <value>an ArrayList</value>
+        ArrayList Chunks {
+            get;
+        }
+    
+        /// <summary>
+        /// Gets the content of the text element.
+        /// </summary>
+        /// <returns>the content of the text element</returns>
+        string ToString();
+    }
+}

src/core/iTextSharp/text/IElementListener.cs

@@ -0,0 +1,16 @@
+using System;
+
+namespace iTextSharp.text {
+    /// <summary>
+    /// A class that implements ElementListener will perform some
+    /// actions when an Element is added.
+    /// </summary>
+    public interface IElementListener {
+        /// <summary>
+        /// Signals that an Element was added to the Document.
+        /// </summary>
+        /// <param name="element">Element added</param>
+        /// <returns>true if the element was added, false if not.</returns>
+        bool Add(IElement element);
+    }
+}

src/core/iTextSharp/text/ILargeElement.cs

@@ -0,0 +1,84 @@
+using System;
+/*
+ * $Id: ILargeElement.cs,v 1.2 2008/05/13 11:25:10 psoares33 Exp $
+ * 
+ *
+ * Copyright 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+
+namespace iTextSharp.text {
+
+    /**
+    * Interface implemented by Element objects that can potentially consume
+    * a lot of memory. Objects implementing the LargeElement interface can
+    * be added to a Document more than once. If you have invoked setCompleted(false),
+    * they will be added partially and the content that was added will be
+    * removed until you've invoked setCompleted(true);
+    * @since   iText 2.0.8
+    */
+
+    public interface ILargeElement : IElement {
+        
+        /**
+        * If you invoke setCompleted(false), you indicate that the content
+        * of the object isn't complete yet; it can be added to the document
+        * partially, but more will follow. If you invoke setCompleted(true),
+        * you indicate that you won't add any more data to the object.
+        * @since   iText 2.0.8
+        * @param   complete    false if you'll be adding more data after
+        *                      adding the object to the document.
+        */
+        bool ElementComplete {
+            get;
+            set;
+        }
+        
+        /**
+        * Flushes the content that has been added.
+        */
+        void FlushContent();
+    }
+}

src/core/iTextSharp/text/IRtfElementInterface.cs

@@ -0,0 +1,60 @@
+/*
+ * $Id: IRtfElementInterface.cs,v 1.2 2008/05/13 11:25:11 psoares33 Exp $
+ * 
+ *
+ * Copyright 2008 by Bruno Lowagie
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the ?GNU LIBRARY GENERAL PUBLIC LICENSE?), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+
+namespace iTextSharp.text {
+
+    /**
+    * The RTF jar depends on the iText jar, but the iText jar may not
+    * depend on the RTF jar. This interface offers a temporary solution
+    * until we find a more elegant way to solve this.
+    */
+    public interface IRtfElementInterface {
+    }
+}

src/core/iTextSharp/text/ISplitCharacter.cs

@@ -0,0 +1,94 @@
+using System;
+using iTextSharp.text.pdf;
+/*
+ * $Id: ISplitCharacter.cs,v 1.3 2008/05/13 11:25:11 psoares33 Exp $
+ * 
+ *
+ * Copyright 2001, 2002 by Paulo Soares
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+namespace iTextSharp.text {
+    /// <summary>
+    /// Interface for customizing the split character.
+    /// </summary>
+    public interface ISplitCharacter {
+        /**
+        * Returns <CODE>true</CODE> if the character can split a line. The splitting implementation
+        * is free to look ahead or look behind characters to make a decision.
+        * <p>
+        * The default implementation is:
+        * <p>
+        * <pre>
+        * public boolean IsSplitCharacter(int start, int current, int end, char[] cc, PdfChunk[] ck) {
+        *    char c;
+        *    if (ck == null)
+        *        c = cc[current];
+        *    else
+        *        c = ck[Math.Min(current, ck.length - 1)].GetUnicodeEquivalent(cc[current]);
+        *    if (c <= ' ' || c == '-') {
+        *        return true;
+        *    }
+        *    if (c < 0x2e80)
+        *        return false;
+        *    return ((c >= 0x2e80 && c < 0xd7a0)
+        *    || (c >= 0xf900 && c < 0xfb00)
+        *    || (c >= 0xfe30 && c < 0xfe50)
+        *    || (c >= 0xff61 && c < 0xffa0));
+        * }
+        * </pre>
+        * @param start the lower limit of <CODE>cc</CODE> inclusive
+        * @param current the pointer to the character in <CODE>cc</CODE>
+        * @param end the upper limit of <CODE>cc</CODE> exclusive
+        * @param cc an array of characters at least <CODE>end</CODE> sized
+        * @param ck an array of <CODE>PdfChunk</CODE>. The main use is to be able to call
+        * {@link PdfChunk#getUnicodeEquivalent(char)}. It may be <CODE>null</CODE>
+        * or shorter than <CODE>end</CODE>. If <CODE>null</CODE> no convertion takes place.
+        * If shorter than <CODE>end</CODE> the last element is used
+        * @return <CODE>true</CODE> if the Character(s) can split a line
+        */
+        
+        bool IsSplitCharacter(int start, int current, int end, char[] cc, PdfChunk[] ck);
+    }
+}

src/core/iTextSharp/text/ITextElementArray.cs

@@ -0,0 +1,22 @@
+using System;
+
+namespace iTextSharp.text {
+    /// <summary>
+    /// Interface for a text element to which other objects can be added.
+    /// </summary>
+    /// <seealso cref="T:iTextSharp.text.Phrase"/>
+    /// <seealso cref="T:iTextSharp.text.Paragraph"/>
+    /// <seealso cref="T:iTextSharp.text.Section"/>
+    /// <seealso cref="T:iTextSharp.text.ListItem"/>
+    /// <seealso cref="T:iTextSharp.text.Chapter"/>
+    /// <seealso cref="T:iTextSharp.text.Anchor"/>
+    /// <seealso cref="T:iTextSharp.text.Cell"/>
+    public interface ITextElementArray : IElement {
+        /// <summary>
+        /// Adds an object to the TextElementArray.
+        /// </summary>
+        /// <param name="o">an object that has to be added</param>
+        /// <returns>true if the addition succeeded; false otherwise</returns>
+        bool Add(Object o);
+    }
+}

src/core/iTextSharp/text/ImgCCITT.cs

@@ -0,0 +1,107 @@
+using System;
+using iTextSharp.text.pdf.codec;
+
+/*
+ * $Id: ImgCCITT.cs,v 1.6 2008/05/13 11:25:11 psoares33 Exp $
+ * 
+ *
+ * Copyright 2000, 2001, 2002 by Paulo Soares.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+
+namespace iTextSharp.text {
+    /**
+     * CCITT Image data that has to be inserted into the document
+     *
+     * @see        Element
+     * @see        Image
+     *
+     * @author  Paulo Soares
+     */
+    /// <summary>
+    /// CCITT Image data that has to be inserted into the document
+    /// </summary>
+    /// <seealso cref="T:iTextSharp.text.Element"/>
+    /// <seealso cref="T:iTextSharp.text.Image"/>
+    public class ImgCCITT : Image {
+        public ImgCCITT(Image image) : base(image) {}
+
+        /// <summary>
+        /// Creats an Image in CCITT mode.
+        /// </summary>
+        /// <param name="width">the exact width of the image</param>
+        /// <param name="height">the exact height of the image</param>
+        /// <param name="reverseBits">
+        /// reverses the bits in data.
+        /// Bit 0 is swapped with bit 7 and so on
+        /// </param>
+        /// <param name="typeCCITT">
+        /// the type of compression in data. It can be
+        /// CCITTG4, CCITTG31D, CCITTG32D
+        /// </param>
+        /// <param name="parameters">
+        /// parameters associated with this stream. Possible values are
+        /// CCITT_BLACKIS1, CCITT_ENCODEDBYTEALIGN, CCITT_ENDOFLINE and CCITT_ENDOFBLOCK or a
+        /// combination of them
+        /// </param>
+        /// <param name="data">the image data</param>
+        public ImgCCITT(int width, int height, bool reverseBits, int typeCCITT, int parameters, byte[] data) : base((Uri)null) {
+            if (typeCCITT != Element.CCITTG4 && typeCCITT != Element.CCITTG3_1D && typeCCITT != Element.CCITTG3_2D)
+                throw new BadElementException("The CCITT compression type must be CCITTG4, CCITTG3_1D or CCITTG3_2D");
+            if (reverseBits)
+                TIFFFaxDecoder.ReverseBits(data);
+            type = Element.IMGRAW;
+            scaledHeight = height;
+            this.Top = scaledHeight;
+            scaledWidth = width;
+            this.Right = scaledWidth;
+            colorspace = parameters;
+            bpc = typeCCITT;
+            rawData = data;
+            plainWidth = this.Width;
+            plainHeight = this.Height;
+        }
+    }
+}

src/core/iTextSharp/text/ImgRaw.cs

@@ -0,0 +1,88 @@
+using System;
+
+/*
+ * $Id: ImgRaw.cs,v 1.5 2008/05/13 11:25:11 psoares33 Exp $
+ * 
+ *
+ * Copyright 2000, 2001, 2002 by Paulo Soares.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+
+namespace iTextSharp.text {
+    /// <summary>
+    /// Raw Image data that has to be inserted into the document
+    /// </summary>
+    /// <seealso cref="T:iTextSharp.text.Element"/>
+    /// <seealso cref="T:iTextSharp.text.Image"/>
+    public class ImgRaw : Image {
+
+        public ImgRaw(Image image) : base(image) {}
+
+        /// <summary>
+        /// Creats an Image in raw mode.
+        /// </summary>
+        /// <param name="width">the exact width of the image</param>
+        /// <param name="height">the exact height of the image</param>
+        /// <param name="components">1,3 or 4 for GrayScale, RGB and CMYK</param>
+        /// <param name="bpc">bits per component. Must be 1,2,4 or 8</param>
+        /// <param name="data">data the image data</param>
+        public ImgRaw(int width, int height, int components, int bpc, byte[] data) : base((Uri)null) {
+            type = Element.IMGRAW;
+            scaledHeight = height;
+            this.Top = scaledHeight;
+            scaledWidth = width;
+            this.Right = scaledWidth;
+            if (components != 1 && components != 3 && components != 4)
+                throw new BadElementException("Components must be 1, 3, or 4.");
+            if (bpc != 1 && bpc != 2 && bpc != 4 && bpc != 8)
+                throw new BadElementException("Bits-per-component must be 1, 2, 4, or 8.");
+            colorspace = components;
+            this.bpc = bpc;
+            rawData = data;
+            plainWidth = this.Width;
+            plainHeight = this.Height;
+        }
+    }
+}

src/core/iTextSharp/text/ImgTemplate.cs

@@ -0,0 +1,88 @@
+using System;
+
+using iTextSharp.text.pdf;
+
+/*
+ * $Id: ImgTemplate.cs,v 1.5 2008/05/13 11:25:11 psoares33 Exp $
+ * 
+ *
+ * Copyright 2000, 2001, 2002 by Paulo Soares.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+
+namespace iTextSharp.text {
+    /// <summary>
+    /// PdfTemplate that has to be inserted into the document
+    /// </summary>
+    /// <seealso cref="T:iTextSharp.text.Element"/>
+    /// <seealso cref="T:iTextSharp.text.Image"/>
+    public class ImgTemplate : Image {
+    
+        /// <summary>
+        /// Creats an Image from a PdfTemplate.
+        /// </summary>
+        /// <param name="image">the Image</param>
+        public ImgTemplate(Image image) : base(image) {}
+    
+        /// <summary>
+        /// Creats an Image from a PdfTemplate.
+        /// </summary>
+        /// <param name="template">the PdfTemplate</param>
+        public ImgTemplate(PdfTemplate template) : base((Uri)null) {
+            if (template == null)
+                throw new BadElementException("The template can not be null.");
+            if (template.Type == PdfTemplate.TYPE_PATTERN)
+                throw new BadElementException("A pattern can not be used as a template to create an image.");
+            type = Element.IMGTEMPLATE;
+            scaledHeight = template.Height;
+            this.Top = scaledHeight;
+            scaledWidth = template.Width;
+            this.Right = scaledWidth;
+            TemplateData = template;
+            plainWidth = this.Width;
+            plainHeight = this.Height;
+        }
+    }
+}

src/core/iTextSharp/text/ImgWMF.cs

@@ -0,0 +1,176 @@
+using System;
+using System.IO;
+using System.Net;
+
+using iTextSharp.text.pdf;
+using iTextSharp.text.pdf.codec.wmf;
+
+/*
+ * $Id: ImgWMF.cs,v 1.7 2008/05/13 11:25:11 psoares33 Exp $
+ * 
+ *
+ * Copyright 1999, 2000, 2001, 2002 by Paulo Soares.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+
+namespace iTextSharp.text {
+    /**
+     * An ImgWMF is the representation of a windows metafile
+     * that has to be inserted into the document
+     *
+     * @see        Element
+     * @see        Image
+     * @see        Gif
+     * @see        Png
+     */
+    /// <summary>
+    /// An ImgWMF is the representation of a windows metafile
+    /// that has to be inserted into the document
+    /// </summary>
+    public class ImgWMF : Image {
+    
+        // Constructors
+        /// <summary>
+        /// Constructs an ImgWMF-object
+        /// </summary>
+        /// <param name="image">a Image</param>
+        public ImgWMF(Image image) : base(image) {}
+    
+        /// <summary>
+        /// Constructs an ImgWMF-object, using an url.
+        /// </summary>
+        /// <param name="url">the URL where the image can be found</param>
+        public ImgWMF(Uri url) : base(url) {
+            ProcessParameters();
+        }
+
+        /// <summary>
+        /// Constructs an ImgWMF-object, using a filename.
+        /// </summary>
+        /// <param name="filename">a string-representation of the file that contains the image.</param>
+        public ImgWMF(string filename) : this(Utilities.ToURL(filename)) {}
+    
+        /// <summary>
+        /// Constructs an ImgWMF-object from memory.
+        /// </summary>
+        /// <param name="img">the memory image</param>
+        public ImgWMF(byte[] img) : base((Uri)null) {
+            rawData = img;
+            originalData = img;
+            ProcessParameters();
+        }
+    
+        /// <summary>
+        /// This method checks if the image is a valid WMF and processes some parameters.
+        /// </summary>
+        private void ProcessParameters() {
+            type = Element.IMGTEMPLATE;
+            originalType = ORIGINAL_WMF;
+            Stream istr = null;
+            try {
+                string errorID;
+                if (rawData == null){
+                    WebRequest w = WebRequest.Create(url);
+                    istr = w.GetResponse().GetResponseStream();
+                    errorID = url.ToString();
+                }
+                else{
+                    istr = new MemoryStream(rawData);
+                    errorID = "Byte array";
+                }
+                InputMeta im = new InputMeta(istr);
+                if (im.ReadInt() != unchecked((int)0x9AC6CDD7))    {
+                    throw new BadElementException(errorID + " is not a valid placeable windows metafile.");
+                }
+                im.ReadWord();
+                int left = im.ReadShort();
+                int top = im.ReadShort();
+                int right = im.ReadShort();
+                int bottom = im.ReadShort();
+                int inch = im.ReadWord();
+                dpiX = 72;
+                dpiY = 72;
+                scaledHeight = (float)(bottom - top) / inch * 72f;
+                this.Top =scaledHeight;
+                scaledWidth = (float)(right - left) / inch * 72f;
+                this.Right = scaledWidth;
+            }
+            finally {
+                if (istr != null) {
+                    istr.Close();
+                }
+                plainWidth = this.Width;
+                plainHeight = this.Height;
+            }
+        }
+    
+        /// <summary>
+        /// Reads the WMF into a template.
+        /// </summary>
+        /// <param name="template">the template to read to</param>
+        public void ReadWMF(PdfTemplate template) {
+            TemplateData = template;
+            template.Width = this.Width;
+            template.Height = this.Height;
+            Stream istr = null;
+            try {
+                if (rawData == null){
+                    WebRequest w = WebRequest.Create(url);
+                    istr = w.GetResponse().GetResponseStream();
+                }
+                else{
+                    istr = new MemoryStream(rawData);
+                }
+                MetaDo meta = new MetaDo(istr, template);
+                meta.ReadAll();
+            }
+            finally {
+                if (istr != null) {
+                    istr.Close();
+                }
+            }
+        }
+    }
+}

src/core/iTextSharp/text/Jpeg.cs

@@ -0,0 +1,335 @@
+using System;
+using System.IO;
+using System.Net;
+using System.util;
+using iTextSharp.text.pdf;
+
+/*
+ * $Id: Jpeg.cs,v 1.11 2008/05/13 11:25:11 psoares33 Exp $
+ * 
+ *
+ * Copyright 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+
+namespace iTextSharp.text {
+    /// <summary>
+    /// An Jpeg is the representation of a graphic element (JPEG)
+    /// that has to be inserted into the document
+    /// </summary>
+    /// <seealso cref="T:iTextSharp.text.Element"/>
+    /// <seealso cref="T:iTextSharp.text.Image"/>
+    /// <seealso cref="T:iTextSharp.text.Gif"/>
+    /// <seealso cref="T:iTextSharp.text.Png"/>
+    public class Jpeg : Image {
+    
+        // public static membervariables
+    
+        /// <summary> This is a type of marker. </summary>
+        public const int NOT_A_MARKER = -1;
+    
+        /// <summary> This is a type of marker. </summary>
+        public const int VALID_MARKER = 0;
+    
+        /// <summary> Acceptable Jpeg markers. </summary>
+        public static int[] VALID_MARKERS = {0xC0, 0xC1, 0xC2};
+    
+        /// <summary> This is a type of marker. </summary>
+        public const int UNSUPPORTED_MARKER = 1;
+    
+        /// <summary> Unsupported Jpeg markers. </summary>
+        public static int[] UNSUPPORTED_MARKERS = {0xC3, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCD, 0xCE, 0xCF};
+    
+        /// <summary> This is a type of marker. </summary>
+        public const int NOPARAM_MARKER = 2;
+    
+        /// <summary> Jpeg markers without additional parameters. </summary>
+        public static int[] NOPARAM_MARKERS = {0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0x01};
+    
+        public const int M_APP0 = 0xE0;
+        public const int M_APP2 = 0xE2;
+        public const int M_APPE = 0xEE;
+    
+        public static byte[] JFIF_ID = {0x4A, 0x46, 0x49, 0x46, 0x00};
+
+        private byte[][] icc;
+
+        // Constructors
+    
+        /// <summary>
+        /// Construct a Jpeg-object, using a Image
+        /// </summary>
+        /// <param name="image">a Image</param>
+        public Jpeg(Image image) : base(image) {}
+
+        /// <summary>
+        /// Constructs a Jpeg-object, using an Uri.
+        /// </summary>
+        /// <remarks>
+        /// Deprecated, use Image.GetInstance(...) to create an Image
+        /// </remarks>
+        /// <param name="Uri">the Uri where the image can be found</param>
+        public Jpeg(Uri Uri) : base(Uri) {
+            ProcessParameters();
+        }
+    
+        /// <summary>
+        /// Constructs a Jpeg-object from memory.
+        /// </summary>
+        /// <param name="img">the memory image</param>
+        public Jpeg(byte[] img) : base((Uri)null) {
+            rawData = img;
+            originalData = img;
+            ProcessParameters();
+        }
+
+        /// <summary>
+        /// Constructs a Jpeg-object from memory.
+        /// </summary>
+        /// <param name="img">the memory image.</param>
+        /// <param name="width">the width you want the image to have</param>
+        /// <param name="height">the height you want the image to have</param>
+        public Jpeg(byte[] img, float width, float height) : this(img) {
+            scaledWidth = width;
+            scaledHeight = height;
+        }
+    
+        // private static methods
+    
+        /// <summary>
+        /// Reads a short from the Stream.
+        /// </summary>
+        /// <param name="istr">the Stream</param>
+        /// <returns>an int</returns>
+        private static int GetShort(Stream istr) {
+            return (istr.ReadByte() << 8) + istr.ReadByte();
+        }
+    
+        /// <summary>
+        /// Reads an inverted short from the Stream.
+        /// </summary>
+        /// <param name="istr">the Stream</param>
+        /// <returns>an int</returns>
+        private static int GetShortInverted(Stream istr) {
+            return (istr.ReadByte() + istr.ReadByte() << 8);
+        }
+
+        /// <summary>
+        /// Returns a type of marker.
+        /// </summary>
+        /// <param name="marker">an int</param>
+        /// <returns>a type: VALID_MARKER, UNSUPPORTED_MARKER or NOPARAM_MARKER</returns>
+        private static int MarkerType(int marker) {
+            for (int i = 0; i < VALID_MARKERS.Length; i++) {
+                if (marker == VALID_MARKERS[i]) {
+                    return VALID_MARKER;
+                }
+            }
+            for (int i = 0; i < NOPARAM_MARKERS.Length; i++) {
+                if (marker == NOPARAM_MARKERS[i]) {
+                    return NOPARAM_MARKER;
+                }
+            }
+            for (int i = 0; i < UNSUPPORTED_MARKERS.Length; i++) {
+                if (marker == UNSUPPORTED_MARKERS[i]) {
+                    return UNSUPPORTED_MARKER;
+                }
+            }
+            return NOT_A_MARKER;
+        }
+    
+        // private methods
+    
+        /// <summary>
+        /// This method checks if the image is a valid JPEG and processes some parameters.
+        /// </summary>
+        private void ProcessParameters() {
+            type = Element.JPEG;
+            originalType = ORIGINAL_JPEG;
+            Stream istr = null;
+            try {
+                string errorID;
+                if (rawData == null){
+                    WebRequest w = WebRequest.Create(url);
+                    istr = w.GetResponse().GetResponseStream();
+                    errorID = url.ToString();
+                }
+                else{
+                    istr = new MemoryStream(rawData);
+                    errorID = "Byte array";
+                }
+                if (istr.ReadByte() != 0xFF || istr.ReadByte() != 0xD8)    {
+                    throw new BadElementException(errorID + " is not a valid JPEG-file.");
+                }
+                bool firstPass = true;
+                int len;
+                while (true) {
+                    int v = istr.ReadByte();
+                    if (v < 0)
+                        throw new IOException("Premature EOF while reading JPG.");
+                    if (v == 0xFF) {
+                        int marker = istr.ReadByte();
+                        if (firstPass && marker == M_APP0) {
+                            firstPass = false;
+                            len = GetShort(istr);
+                            if (len < 16) {
+                                Utilities.Skip(istr, len - 2);
+                                continue;
+                            }
+                            byte[] bcomp = new byte[JFIF_ID.Length];
+                            int r = istr.Read(bcomp, 0, bcomp.Length);
+                            if (r != bcomp.Length)
+                                throw new BadElementException(errorID + " corrupted JFIF marker.");
+                            bool found = true;
+                            for (int k = 0; k < bcomp.Length; ++k) {
+                                if (bcomp[k] != JFIF_ID[k]) {
+                                    found = false;
+                                    break;
+                                }
+                            }
+                            if (!found) {
+                                Utilities.Skip(istr, len - 2 - bcomp.Length);
+                                continue;
+                            }
+                            Utilities.Skip(istr, 2);
+                            int units = istr.ReadByte();
+                            int dx = GetShort(istr);
+                            int dy = GetShort(istr);
+                            if (units == 1) {
+                                dpiX = dx;
+                                dpiY = dy;
+                            }
+                            else if (units == 2) {
+                                dpiX = (int)((float)dx * 2.54f + 0.5f);
+                                dpiY = (int)((float)dy * 2.54f + 0.5f);
+                            }
+                            Utilities.Skip(istr, len - 2 - bcomp.Length - 7);
+                            continue;
+                        }
+                        if (marker == M_APPE) {
+                            len = GetShort(istr) - 2;
+                            byte[] byteappe = new byte[len];
+                            for (int k = 0; k < len; ++k) {
+                                byteappe[k] = (byte)istr.ReadByte();
+                            }
+                            if (byteappe.Length >= 12) {
+                                string appe = System.Text.ASCIIEncoding.ASCII.GetString(byteappe,0,5);
+                                if (Util.EqualsIgnoreCase(appe, "adobe")) {
+                                    invert = true;
+                                }
+                            }
+                            continue;
+                        }
+                        if (marker == M_APP2) {
+                            len = GetShort(istr) - 2;
+                            byte[] byteapp2 = new byte[len];
+                            for (int k = 0; k < len; ++k) {
+                                byteapp2[k] = (byte)istr.ReadByte();
+                            }
+                            if (byteapp2.Length >= 14) {
+                                String app2 = System.Text.ASCIIEncoding.ASCII.GetString(byteapp2, 0, 11);
+                                if (app2.Equals("ICC_PROFILE")) {
+                                    int order = byteapp2[12] & 0xff;
+                                    int count = byteapp2[13] & 0xff;
+                                    if (icc == null)
+                                        icc = new byte[count][];
+                                    icc[order - 1] = byteapp2;
+                                }
+                            }
+                            continue;
+                        }
+                        firstPass = false;
+                        int markertype = MarkerType(marker);
+                        if (markertype == VALID_MARKER) {
+                            Utilities.Skip(istr, 2);
+                            if (istr.ReadByte() != 0x08) {
+                                throw new BadElementException(errorID + " must have 8 bits per component.");
+                            }
+                            scaledHeight = GetShort(istr);
+                            Top = scaledHeight;
+                            scaledWidth = GetShort(istr);
+                            Right = scaledWidth;
+                             colorspace = istr.ReadByte();
+                            bpc = 8;
+                            break;
+                        }
+                        else if (markertype == UNSUPPORTED_MARKER) {
+                            throw new BadElementException(errorID + ": unsupported JPEG marker: " + marker);
+                        }
+                        else if (markertype != NOPARAM_MARKER) {
+                            Utilities.Skip(istr, GetShort(istr) - 2);
+                        }
+                    }
+                }
+            }
+            finally {
+                if (istr != null) {
+                    istr.Close();
+                }
+            }
+            plainWidth = this.Width;
+            plainHeight = this.Height;
+            if (icc != null) {
+                int total = 0;
+                for (int k = 0; k < icc.Length; ++k) {
+                    if (icc[k] == null) {
+                        icc = null;
+                        return;
+                    }
+                    total += icc[k].Length - 14;
+                }
+                byte[] ficc = new byte[total];
+                total = 0;
+                for (int k = 0; k < icc.Length; ++k) {
+                    System.Array.Copy(icc[k], 14, ficc, total, icc[k].Length - 14);
+                    total += icc[k].Length - 14;
+                }
+                ICC_Profile icc_prof = ICC_Profile.GetInstance(ficc);
+                TagICC = icc_prof;
+                icc = null;
+            }
+        }
+    }
+}

src/core/iTextSharp/text/Jpeg2000.cs

@@ -0,0 +1,239 @@
+using System;
+using System.IO;
+using System.Net;
+using System.util;
+using iTextSharp.text.pdf;
+/*
+ * $Id: Jpeg2000.cs,v 1.5 2008/05/13 11:25:11 psoares33 Exp $
+ * 
+ *
+ * Copyright 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+
+namespace iTextSharp.text {
+
+    /**
+    * An <CODE>Jpeg2000</CODE> is the representation of a graphic element (JPEG)
+    * that has to be inserted into the document
+    *
+    * @see		Element
+    * @see		Image
+    */
+
+    public class Jpeg2000 : Image {
+        
+        // public static final membervariables
+        
+        public const int JP2_JP = 0x6a502020;
+        public const int JP2_IHDR = 0x69686472;
+        public const int JPIP_JPIP = 0x6a706970;
+
+        public const int JP2_FTYP = 0x66747970;
+        public const int JP2_JP2H = 0x6a703268;
+        public const int JP2_COLR = 0x636f6c72;
+        public const int JP2_JP2C = 0x6a703263;
+        public const int JP2_URL = 0x75726c20;
+        public const int JP2_DBTL = 0x6474626c;
+        public const int JP2_BPCC = 0x62706363;
+        public const int JP2_JP2 = 0x6a703220;
+
+        private Stream inp;
+        private int boxLength;
+        private int boxType;
+        
+        // Constructors
+        
+        public Jpeg2000(Image image) : base(image) {
+        }
+
+        /**
+        * Constructs a <CODE>Jpeg2000</CODE>-object, using an <VAR>url</VAR>.
+        *
+        * @param		url			the <CODE>URL</CODE> where the image can be found
+        * @throws BadElementException
+        * @throws IOException
+        */
+        public Jpeg2000(Uri url) : base(url) {
+            ProcessParameters();
+        }
+        
+        /**
+        * Constructs a <CODE>Jpeg2000</CODE>-object from memory.
+        *
+        * @param		img		the memory image
+        * @throws BadElementException
+        * @throws IOException
+        */
+        
+        public Jpeg2000(byte[] img) : base((Uri)null) {
+            rawData = img;
+            originalData = img;
+            ProcessParameters();
+        }
+        
+        /**
+        * Constructs a <CODE>Jpeg2000</CODE>-object from memory.
+        *
+        * @param		img			the memory image.
+        * @param		width		the width you want the image to have
+        * @param		height		the height you want the image to have
+        * @throws BadElementException
+        * @throws IOException
+        */
+        
+        public Jpeg2000(byte[] img, float width, float height) : this(img) {
+            scaledWidth = width;
+            scaledHeight = height;
+        }
+        
+        private int Cio_read(int n) {
+            int v = 0;
+            for (int i = n - 1; i >= 0; i--) {
+                v += inp.ReadByte() << (i << 3);
+            }
+            return v;
+        }
+        
+        public void Jp2_read_boxhdr() {
+            boxLength = Cio_read(4);
+            boxType = Cio_read(4);
+            if (boxLength == 1) {
+                if (Cio_read(4) != 0) {
+                    throw new IOException("Cannot handle box sizes higher than 2^32");
+                }
+                boxLength = Cio_read(4);
+                if (boxLength == 0) 
+                    throw new IOException("Unsupported box size == 0");
+            }
+            else if (boxLength == 0) {
+                throw new IOException("Unsupported box size == 0");
+            }
+        }
+        
+        /**
+        * This method checks if the image is a valid JPEG and processes some parameters.
+        * @throws BadElementException
+        * @throws IOException
+        */
+        private void ProcessParameters() {
+            type = JPEG2000;
+            originalType = ORIGINAL_JPEG2000;
+            inp = null;
+            try {
+                string errorID;
+                if (rawData == null){
+                    WebRequest w = WebRequest.Create(url);
+                    inp = w.GetResponse().GetResponseStream();
+                    errorID = url.ToString();
+                }
+                else{
+                    inp = new MemoryStream(rawData);
+                    errorID = "Byte array";
+                }
+                boxLength = Cio_read(4);
+                if (boxLength == 0x0000000c) {
+                    boxType = Cio_read(4);
+                    if (JP2_JP != boxType) {
+                        throw new IOException("Expected JP Marker");
+                    }
+                    if (0x0d0a870a != Cio_read(4)) {
+                        throw new IOException("Error with JP Marker");
+                    }
+
+                    Jp2_read_boxhdr();
+                    if (JP2_FTYP != boxType) {
+                        throw new IOException("Expected FTYP Marker");
+                    }
+                    Utilities.Skip(inp, boxLength - 8);
+                    Jp2_read_boxhdr();
+                    do {
+                        if (JP2_JP2H != boxType) {
+                            if (boxType == JP2_JP2C) {
+                                throw new IOException("Expected JP2H Marker");
+                            }
+                            Utilities.Skip(inp, boxLength - 8);
+                            Jp2_read_boxhdr();
+                        }
+                    } while (JP2_JP2H != boxType);
+                    Jp2_read_boxhdr();
+                    if (JP2_IHDR != boxType) {
+                        throw new IOException("Expected IHDR Marker");
+                    }
+                    scaledHeight = Cio_read(4);
+                    Top = scaledHeight;
+                    scaledWidth = Cio_read(4);
+                    Right = scaledWidth;
+                    bpc = -1;
+                }
+                else if ((uint)boxLength == 0xff4fff51) {
+                    Utilities.Skip(inp, 4);
+                    int x1 = Cio_read(4);
+                    int y1 = Cio_read(4);
+                    int x0 = Cio_read(4);
+                    int y0 = Cio_read(4);
+                    Utilities.Skip(inp, 16);
+                    colorspace = Cio_read(2);
+                    bpc = 8;
+                    scaledHeight = y1 - y0;
+                    Top = scaledHeight;
+                    scaledWidth = x1 - x0;
+                    Right = scaledWidth;
+                }
+                else {
+                    throw new IOException("Not a valid Jpeg2000 file");
+                }
+            }
+            finally {
+                if (inp != null) {
+                    try{inp.Close();}catch{}
+                    inp = null;
+                }
+            }
+            plainWidth = this.Width;
+            plainHeight = this.Height;
+        }
+    }
+}

src/core/iTextSharp/text/List.cs

@@ -0,0 +1,555 @@
+using System;
+using System.Collections;
+using System.util;
+using iTextSharp.text.factories;
+
+/*
+ * $Id: List.cs,v 1.20 2008/05/13 11:25:11 psoares33 Exp $
+ * 
+ *
+ * Copyright 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+
+namespace iTextSharp.text {
+    /// <summary>
+    /// A List contains several ListItems.
+    /// </summary>
+    /// <example>
+    /// <B>Example 1:</B>
+    /// <code>
+    /// <strong>List list = new List(true, 20);
+    /// list.Add(new ListItem("First line"));
+    /// list.Add(new ListItem("The second line is longer to see what happens once the end of the line is reached. Will it start on a new line?"));
+    /// list.Add(new ListItem("Third line"));</strong>
+    /// </code>
+    /// 
+    /// The result of this code looks like this:
+    /// <OL>
+    ///     <LI>
+    ///         First line
+    ///     </LI>
+    ///     <LI>
+    ///         The second line is longer to see what happens once the end of the line is reached. Will it start on a new line?
+    ///     </LI>
+    ///     <LI>
+    ///         Third line
+    ///     </LI>
+    /// </OL>
+    /// 
+    /// <B>Example 2:</B>
+    /// <code>
+    /// <strong>List overview = new List(false, 10);
+    /// overview.Add(new ListItem("This is an item"));
+    /// overview.Add("This is another item");</strong>
+    /// </code>
+    /// 
+    /// The result of this code looks like this:
+    /// <UL>
+    ///        <LI>
+    ///            This is an item
+    ///        </LI>
+    ///        <LI>
+    ///            This is another item
+    ///        </LI>
+    ///    </UL>
+    /// </example>
+    /// <seealso cref="T:iTextSharp.text.Element"/>
+    /// <seealso cref="T:iTextSharp.text.ListItem"/>
+    public class List : ITextElementArray {
+    
+        // membervariables
+        /** a possible value for the numbered parameter */
+        public const bool ORDERED = true;
+        /** a possible value for the numbered parameter */
+        public const bool UNORDERED = false;
+        /** a possible value for the lettered parameter */
+        public const bool NUMERICAL = false;
+        /** a possible value for the lettered parameter */
+        public const bool ALPHABETICAL = true;
+        /** a possible value for the lettered parameter */
+        public const bool UPPERCASE = false;
+        /** a possible value for the lettered parameter */
+        public const bool LOWERCASE = true;
+    
+        /// <summary> This is the ArrayList containing the different ListItems. </summary>
+        protected ArrayList list = new ArrayList();
+    
+        /** Indicates if the list has to be numbered. */
+        protected bool numbered = false;
+        /** Indicates if the listsymbols are numerical or alphabetical. */
+        protected bool lettered = false;
+        /** Indicates if the listsymbols are lowercase or uppercase. */
+        protected bool lowercase = false;
+        /** Indicates if the indentation has to be set automatically. */
+        protected bool autoindent = false;
+        /** Indicates if the indentation of all the items has to be aligned. */
+        protected bool alignindent = false;
+    
+        /// <summary> This variable indicates the first number of a numbered list. </summary>
+        protected int first = 1;
+    
+        /// <summary> This is the listsymbol of a list that is not numbered. </summary>
+        protected Chunk symbol = new Chunk("-");
+        /**
+        * In case you are using numbered/lettered lists, this String is added before the number/letter.
+        * @since   iText 2.1.1
+        */
+        protected String preSymbol = "";
+        /**
+        * In case you are using numbered/lettered lists, this String is added after the number/letter. 
+        * @since   iText 2.1.1
+        */
+        protected String postSymbol = ". ";
+    
+        /// <summary> The indentation of this list on the left side. </summary>
+        protected float indentationLeft = 0;
+    
+        /// <summary> The indentation of this list on the right side. </summary>
+        protected float indentationRight = 0;
+    
+        /// <summary> The indentation of the listitems. </summary>
+        protected float symbolIndent = 0;
+
+        // constructors
+    
+    /**
+    * Constructs a <CODE>List</CODE>.
+    */
+        public List() : this(false, false) {
+        }
+        
+        /**
+        * Constructs a <CODE>List</CODE> with a specific symbol indentation.
+        * @param   symbolIndent    the symbol indentation
+        * @since   iText 2.0.8
+        */
+        public List(float symbolIndent) {
+            this.symbolIndent = symbolIndent;
+        }
+
+    /**
+    * Constructs a <CODE>List</CODE>.
+    *
+    * @param    numbered        a bool
+    */
+        public List(bool numbered) : this(numbered, false) {
+        }
+            
+    /**
+    * Constructs a <CODE>List</CODE>.
+    *
+    * @param    numbered        a bool
+    * @param lettered has the list to be 'numbered' with letters
+    */
+        public List(bool numbered, bool lettered) {
+            this.numbered = numbered;
+            this.lettered = lettered;
+            this.autoindent = true;
+            this.alignindent = true;
+        }
+        
+
+        /// <summary>
+        /// Constructs a List.
+        /// </summary>
+        /// <remarks>
+        /// the parameter symbolIndent is important for instance when
+        /// generating PDF-documents; it indicates the indentation of the listsymbol.
+        /// </remarks>
+        /// <param name="numbered">a bool</param>
+        /// <param name="symbolIndent">the indentation that has to be used for the listsymbol</param>
+        public List(bool numbered, float symbolIndent) : this(numbered, false, symbolIndent) {
+        }
+    
+        /// <summary>
+        /// Constructs a List.
+        /// </summary>
+        /// <param name="numbered">a bool</param>
+        /// <param name="lettered">a bool</param>
+        /// <param name="symbolIndent">the indentation that has to be used for the listsymbol</param>
+        public List(bool numbered, bool lettered, float symbolIndent ) {
+            this.numbered = numbered;
+            this.lettered = lettered;
+            this.symbolIndent = symbolIndent;
+        }
+    
+        // implementation of the Element-methods
+    
+        /// <summary>
+        /// Processes the element by adding it (or the different parts) to an
+        /// IElementListener.
+        /// </summary>
+        /// <param name="listener">an IElementListener</param>
+        /// <returns>true if the element was processed successfully</returns>
+        public bool Process(IElementListener listener) {
+            try {
+                foreach (IElement ele in list) {
+                    listener.Add(ele);
+                }
+                return true;
+            }
+            catch (DocumentException) {
+                return false;
+            }
+        }
+    
+        /// <summary>
+        /// Gets the type of the text element.
+        /// </summary>
+        /// <value>a type</value>
+        public int Type {
+            get {
+                return Element.LIST;
+            }
+        }
+    
+        /// <summary>
+        /// Gets all the chunks in this element.
+        /// </summary>
+        /// <value>an ArrayList</value>
+        public ArrayList Chunks {
+            get {
+                ArrayList tmp = new ArrayList();
+                foreach (IElement ele in list) {
+                    tmp.AddRange(ele.Chunks);
+                }
+                return tmp;
+            }
+        }
+    
+        // methods to set the membervariables
+    
+        /// <summary>
+        /// Adds an Object to the List.
+        /// </summary>
+        /// <param name="o">the object to add</param>
+        /// <returns>true is successful</returns>
+        public virtual bool Add(Object o) {
+            if (o is ListItem) {
+                ListItem item = (ListItem) o;
+                if (numbered || lettered) {
+                    Chunk chunk = new Chunk(preSymbol, symbol.Font);
+                    int index = first + list.Count;
+                    if (lettered)
+                        chunk.Append(RomanAlphabetFactory.GetString(index, lowercase));
+                    else
+                        chunk.Append(index.ToString());
+                    chunk.Append(postSymbol);
+                    item.ListSymbol = chunk;
+                }
+                else {
+                    item.ListSymbol = symbol;
+                }
+                item.SetIndentationLeft(symbolIndent, autoindent);
+                item.IndentationRight = 0;
+                list.Add(item);
+                return true;
+            }
+            else if (o is List) {
+                List nested = (List) o;
+                nested.IndentationLeft = nested.IndentationLeft + symbolIndent;
+                first--;
+                list.Add(nested);
+                return true;
+            }
+            else if (o is string) {
+                return this.Add(new ListItem((string) o));
+            }
+            return false;
+        }
+    
+        // extra methods
+        
+        /** Makes sure all the items in the list have the same indentation. */
+        public void NormalizeIndentation() {
+            float max = 0;
+            foreach (IElement o in list) {
+                if (o is ListItem) {
+                    max = Math.Max(max, ((ListItem)o).IndentationLeft);
+                }
+            }
+            foreach (IElement o in list) {
+                if (o is ListItem) {
+                    ((ListItem)o).IndentationLeft = max;
+                }
+            }
+        }
+
+        //setters/getters
+
+        public bool Numbered {
+            set {
+                numbered = value;
+            }
+            get {
+                return numbered;
+            }
+        }
+
+        public bool Lettered {
+            set {
+                lettered = value;
+            }
+            get {
+                return lettered;
+            }
+        }
+
+        public bool Lowercase {
+            set {
+                lowercase = value;
+            }
+            get {
+                return lowercase;
+            }
+        }
+
+        public bool Autoindent {
+            set {
+                autoindent = value;
+            }
+            get {
+                return autoindent;
+            }
+        }
+
+        public bool Alignindent {
+            set {
+                alignindent = value;
+            }
+            get {
+                return alignindent;
+            }
+        }
+
+        /// <summary>
+        /// Get/set the first number
+        /// </summary>
+        /// <value>an int</value>
+        public int First {
+            get {
+                return first;
+            }
+
+            set {
+                this.first = value;
+            }
+        }
+    
+        /// <summary>
+        /// Sets the symbol
+        /// </summary>
+        /// <value>a Chunk</value>
+        public Chunk ListSymbol {
+            set {
+                this.symbol = value;
+            }
+        }
+
+        /// <summary>
+        /// Sets the listsymbol.
+        /// </summary>
+        /// <remarks>
+        /// This is a shortcut for SetListSymbol(Chunk symbol).
+        /// </remarks>
+        /// <param name="symbol">a string</param>
+        public void SetListSymbol(string symbol) {
+            this.symbol = new Chunk(symbol);
+        }
+    
+        /// <summary>
+        /// Get/set the indentation of this paragraph on the left side.
+        /// </summary>
+        /// <value>the indentation</value>
+        public float IndentationLeft {
+            get {
+                return indentationLeft;
+            }
+
+            set {
+                this.indentationLeft = value;
+            }
+        }
+    
+        /// <summary>
+        /// Get/set the indentation of this paragraph on the right side.
+        /// </summary>
+        /// <value>the indentation</value>
+        public float IndentationRight {
+            get {
+                return indentationRight;
+            }
+
+            set {
+                this.indentationRight = value;
+            }
+        }
+    
+        /// <summary>
+        /// Gets the symbol indentation.
+        /// </summary>
+        /// <value>the symbol indentation</value>
+        public float SymbolIndent {
+            set {
+                symbolIndent = value;
+            }
+            get {
+                return symbolIndent;
+            }
+        }
+    
+        /**
+        * @see com.lowagie.text.Element#isContent()
+        * @since   iText 2.0.8
+        */
+        public bool IsContent() {
+            return true;
+        }
+
+        /**
+        * @see com.lowagie.text.Element#isNestable()
+        * @since   iText 2.0.8
+        */
+        public bool IsNestable() {
+            return true;
+        }
+
+        // methods to retrieve information
+    
+        /// <summary>
+        /// Gets all the items in the list.
+        /// </summary>
+        /// <value>an ArrayList containing ListItems</value>
+        public ArrayList Items {
+            get {
+                return list;
+            }
+        }
+    
+        /// <summary>
+        /// Gets the size of the list.
+        /// </summary>
+        /// <value>a size</value>
+        public int Size {
+            get {
+                return list.Count;
+            }
+        }
+    
+        /**
+        * Returns <CODE>true</CODE> if the list is empty.
+        * 
+        * @return <CODE>true</CODE> if the list is empty
+        */
+        public virtual bool IsEmpty() {
+    	    return list.Count == 0;
+        }
+
+        /// <summary>
+        /// Gets the leading of the first listitem.
+        /// </summary>
+        /// <value>a leading</value>
+        public float TotalLeading {
+            get {
+                if (list.Count < 1) {
+                    return -1;
+                }
+                ListItem item = (ListItem)list[0];
+                return item.TotalLeading;
+            }
+        }
+    
+        /// <summary>
+        /// Get/set the symbol indentation.
+        /// </summary>
+        /// <value>a Chunk</value>
+        public Chunk Symbol {
+            get {
+                return symbol;
+            }
+            set {
+                this.symbol = value;
+            }
+        }
+
+	    /**
+	    * Returns the String that is after a number or letter in the list symbol.
+	    * @return	the String that is after a number or letter in the list symbol
+	    * @since	iText 2.1.1
+	    */
+	    public String getPostSymbol() {
+		    return postSymbol;
+	    }
+
+	    /**
+	    * Sets the String that has to be added after a number or letter in the list symbol.
+	    * @since	iText 2.1.1
+	    * @param	postSymbol the String that has to be added after a number or letter in the list symbol.
+	    */
+	    public String PostSymbol {
+            set {
+		        postSymbol = value;
+            }
+            get {
+                return postSymbol;
+            }
+	    }
+
+	    /**
+	    * Sets the String that has to be added before a number or letter in the list symbol.
+	    * @since	iText 2.1.1
+	    * @param	preSymbol the String that has to be added before a number or letter in the list symbol.
+	    */
+	    public String PreSymbol {
+            set {
+		        preSymbol = value;
+            }
+            get {
+                return preSymbol;
+            }
+	    }
+    }
+}

src/core/iTextSharp/text/ListItem.cs

@@ -0,0 +1,239 @@
+using System;
+using System.Collections;
+using System.util;
+using iTextSharp.text.factories;
+/*
+ * $Id: ListItem.cs,v 1.11 2008/05/13 11:25:11 psoares33 Exp $
+ * 
+ *
+ * Copyright 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+
+namespace iTextSharp.text {
+    /// <summary>
+    /// A ListItem is a Paragraph
+    /// that can be added to a List.
+    /// </summary>
+    /// <example>
+    /// <B>Example 1:</B>
+    /// <code>
+    /// List list = new List(true, 20);
+    /// list.Add(<strong>new ListItem("First line")</strong>);
+    /// list.Add(<strong>new ListItem("The second line is longer to see what happens once the end of the line is reached. Will it start on a new line?")</strong>);
+    /// list.Add(<strong>new ListItem("Third line")</strong>);
+    /// </code>
+    /// 
+    /// The result of this code looks like this:
+    /// <OL>
+    ///        <LI>
+    ///            First line
+    ///        </LI>
+    ///        <LI>
+    ///            The second line is longer to see what happens once the end of the line is reached. Will it start on a new line?
+    ///        </LI>
+    ///        <LI>
+    ///            Third line
+    ///        </LI>
+    ///    </OL>
+    ///    
+    /// <B>Example 2:</B>
+    /// <code>
+    /// List overview = new List(false, 10);
+    /// overview.Add(<strong>new ListItem("This is an item")</strong>);
+    /// overview.Add("This is another item");
+    /// </code>
+    /// 
+    /// The result of this code looks like this:
+    /// <UL>
+    ///        <LI>
+    ///            This is an item
+    ///        </LI>
+    ///        <LI>
+    ///            This is another item
+    ///        </LI>
+    ///    </UL>
+    /// </example>
+    /// <seealso cref="T:iTextSharp.text.Element"/>
+    /// <seealso cref="T:iTextSharp.text.List"/>
+    /// <seealso cref="T:iTextSharp.text.Paragraph"/>
+    public class ListItem : Paragraph {
+    
+        // membervariables
+    
+        /// <summary> this is the symbol that wil proceed the listitem. </summary>
+        private Chunk symbol;
+    
+        // constructors
+    
+        /// <summary>
+        /// Constructs a ListItem.
+        /// </summary>
+        public ListItem() : base() {}
+    
+        /// <summary>
+        ///    Constructs a ListItem with a certain leading.
+        /// </summary>
+        /// <param name="leading">the leading</param>
+        public ListItem(float leading) : base(leading) {}
+    
+        /// <summary>
+        /// Constructs a ListItem with a certain Chunk.
+        /// </summary>
+        /// <param name="chunk">a Chunk</param>
+        public ListItem(Chunk chunk) : base(chunk) {}
+    
+        /// <summary>
+        /// Constructs a ListItem with a certain string.
+        /// </summary>
+        /// <param name="str">a string</param>
+        public ListItem(string str) : base(str) {}
+    
+        /// <summary>
+        /// Constructs a ListItem with a certain string
+        /// and a certain Font.
+        /// </summary>
+        /// <param name="str">a string</param>
+        /// <param name="font">a string</param>
+        public ListItem(string str, Font font) : base(str, font) {}
+    
+        /// <summary>
+        /// Constructs a ListItem with a certain Chunk
+        /// and a certain leading.
+        /// </summary>
+        /// <param name="leading">the leading</param>
+        /// <param name="chunk">a Chunk</param>
+        public ListItem(float leading, Chunk chunk) : base(leading, chunk) {}
+    
+        /// <summary>
+        /// Constructs a ListItem with a certain string
+        /// and a certain leading.
+        /// </summary>
+        /// <param name="leading">the leading</param>
+        /// <param name="str">a string</param>
+        public ListItem(float leading, string str) : base(leading, str) {}
+    
+        /**
+         * Constructs a ListItem with a certain leading, string
+         * and Font.
+         *
+         * @param    leading        the leading
+         * @param    string        a string
+         * @param    font        a Font
+         */
+        /// <summary>
+        /// Constructs a ListItem with a certain leading, string
+        /// and Font.
+        /// </summary>
+        /// <param name="leading">the leading</param>
+        /// <param name="str">a string</param>
+        /// <param name="font">a Font</param>
+        public ListItem(float leading, string str, Font font) : base(leading, str, font) {}
+    
+        /// <summary>
+        /// Constructs a ListItem with a certain Phrase.
+        /// </summary>
+        /// <param name="phrase">a Phrase</param>
+        public ListItem(Phrase phrase) : base(phrase) {}
+    
+        // implementation of the Element-methods
+    
+        /// <summary>
+        /// Gets the type of the text element.
+        /// </summary>
+        /// <value>a type</value>
+        public override int Type {
+            get {
+                return Element.LISTITEM;
+            }
+        }
+    
+        // methods
+    
+        // methods to retrieve information
+    
+        /// <summary>
+        /// Get/set the listsymbol.
+        /// </summary>
+        /// <value>a Chunk</value>
+        public Chunk ListSymbol {
+            get {
+                return symbol;
+            }
+
+            set {
+                if (this.symbol == null) {
+                    this.symbol = value;
+                    if (this.symbol.Font.IsStandardFont()) {
+                        this.symbol.Font = font;
+                    }
+                }
+            }
+        }
+    
+        /// <summary>
+        /// Checks if a given tag corresponds with this object.
+        /// </summary>
+        /// <param name="tag">the given tag</param>
+        /// <returns>true if the tag corresponds</returns>
+        public new static bool IsTag(string tag) {
+            return ElementTags.LISTITEM.Equals(tag);
+        }
+
+        /**
+        * Sets the indentation of this paragraph on the left side.
+        *
+        * @param	indentation		the new indentation
+        */        
+        public void SetIndentationLeft(float indentation, bool autoindent) {
+            if (autoindent) {
+            	IndentationLeft = ListSymbol.GetWidthPoint();
+            }
+            else {
+            	IndentationLeft = indentation;
+            }
+        }
+    }
+}

src/core/iTextSharp/text/MarkedObject.cs

@@ -0,0 +1,154 @@
+using System;
+using System.Collections;
+using System.util;
+/*
+ * $Id: MarkedObject.cs,v 1.4 2008/05/13 11:25:11 psoares33 Exp $
+ * 
+ *
+ * Copyright 2007 by Bruno Lowagie.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999-2007 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000-2007 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+
+namespace iTextSharp.text {
+
+    /**
+    * Wrapper that allows to add properties to 'basic building block' objects.
+    * Before iText 1.5 every 'basic building block' implemented the MarkupAttributes interface.
+    * By setting attributes, you could add markup to the corresponding XML and/or HTML tag.
+    * This functionality was hardly used by anyone, so it was removed, and replaced by
+    * the MarkedObject functionality.
+    */
+
+    public class MarkedObject : IElement {
+
+        /** The element that is wrapped in a MarkedObject. */
+        protected internal IElement element;
+
+        /** Contains extra markupAttributes */
+        protected internal Properties markupAttributes = new Properties();
+            
+        /**
+        * This constructor is for internal use only.
+        */
+        protected MarkedObject() {
+            element = null;
+        }
+        
+        /**
+        * Creates a MarkedObject.
+        */
+        public MarkedObject(IElement element) {
+            this.element = element;
+        }
+        
+        /**
+        * Gets all the chunks in this element.
+        *
+        * @return  an <CODE>ArrayList</CODE>
+        */
+        public virtual ArrayList Chunks {
+            get {
+                return element.Chunks;
+            }
+        }
+
+        /**
+        * Processes the element by adding it (or the different parts) to an
+        * <CODE>ElementListener</CODE>.
+        *
+        * @param       listener        an <CODE>ElementListener</CODE>
+        * @return <CODE>true</CODE> if the element was processed successfully
+        */
+        public virtual bool Process(IElementListener listener) {
+            try {
+                return listener.Add(element);
+            }
+            catch (DocumentException) {
+                return false;
+            }
+        }
+        
+        /**
+        * Gets the type of the text element.
+        *
+        * @return  a type
+        */
+        public virtual int Type {
+            get {
+                return Element.MARKED;
+            }
+        }
+
+        /**
+        * @see com.lowagie.text.Element#isContent()
+        * @since   iText 2.0.8
+        */
+        public bool IsContent() {
+            return true;
+        }
+
+        /**
+        * @see com.lowagie.text.Element#isNestable()
+        * @since   iText 2.0.8
+        */
+        public bool IsNestable() {
+            return true;
+        }
+
+        /**
+        * @return the markupAttributes
+        */
+        public virtual Properties MarkupAttributes {
+            get {
+                return markupAttributes;
+            }
+        }
+        
+        public virtual void SetMarkupAttribute(String key, String value) {
+            markupAttributes.Add(key, value);
+        }
+
+    }
+}

src/core/iTextSharp/text/MarkedSection.cs

@@ -0,0 +1,297 @@
+using System;
+using System.Collections;
+using System.Text;
+using System.util;
+/*
+ * $Id: MarkedSection.cs,v 1.7 2008/05/13 11:25:12 psoares33 Exp $
+ * 
+ *
+ * Copyright 2007 by Bruno Lowagie.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999-2007 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000-2007 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+
+namespace iTextSharp.text {
+
+    /**
+    * Wrapper that allows to add properties to a Chapter/Section object.
+    * Before iText 1.5 every 'basic building block' implemented the MarkupAttributes interface.
+    * By setting attributes, you could add markup to the corresponding XML and/or HTML tag.
+    * This functionality was hardly used by anyone, so it was removed, and replaced by
+    * the MarkedObject functionality.
+    */
+
+    public class MarkedSection : MarkedObject {
+
+        /** This is the title of this section. */
+        protected MarkedObject title = null;
+            
+        /**
+        * Creates a MarkedObject with a Section or Chapter object.
+        * @param section   the marked section
+        */
+        public MarkedSection(Section section) : base() {
+            if (section.Title != null) {
+                title = new MarkedObject(section.Title);
+                section.Title = null;
+            }
+            this.element = section;
+        }
+        
+        /**
+        * Adds a <CODE>Paragraph</CODE>, <CODE>List</CODE> or <CODE>Table</CODE>
+        * to this <CODE>Section</CODE>.
+        *
+        * @param   index   index at which the specified element is to be inserted
+        * @param   o       an object of type <CODE>Paragraph</CODE>, <CODE>List</CODE> or <CODE>Table</CODE>=
+        * @throws  ClassCastException if the object is not a <CODE>Paragraph</CODE>, <CODE>List</CODE> or <CODE>Table</CODE>
+        */
+         
+        public void Add(int index, Object o) {
+            ((Section)element).Add(index, o);
+        }
+            
+        /**
+        * Adds a <CODE>Paragraph</CODE>, <CODE>List</CODE>, <CODE>Table</CODE> or another <CODE>Section</CODE>
+        * to this <CODE>Section</CODE>.
+        *
+        * @param   o       an object of type <CODE>Paragraph</CODE>, <CODE>List</CODE>, <CODE>Table</CODE> or another <CODE>Section</CODE>
+        * @return  a bool
+        * @throws  ClassCastException if the object is not a <CODE>Paragraph</CODE>, <CODE>List</CODE>, <CODE>Table</CODE> or <CODE>Section</CODE>
+        */
+            
+        public bool Add(Object o) {
+            return ((Section)element).Add(o);
+        }
+
+        /**
+        * Processes the element by adding it (or the different parts) to an
+        * <CODE>ElementListener</CODE>.
+        *
+        * @param       listener        an <CODE>ElementListener</CODE>
+        * @return <CODE>true</CODE> if the element was processed successfully
+        */
+        public override bool Process(IElementListener listener) {
+            try {
+                foreach (IElement element in ((Section)this.element)) {
+                    listener.Add(element);
+                }
+                return true;
+            }
+            catch (DocumentException) {
+                return false;
+            }
+        }
+        
+        /**
+        * Adds a collection of <CODE>Element</CODE>s
+        * to this <CODE>Section</CODE>.
+        *
+        * @param   collection  a collection of <CODE>Paragraph</CODE>s, <CODE>List</CODE>s and/or <CODE>Table</CODE>s
+        * @return  <CODE>true</CODE> if the action succeeded, <CODE>false</CODE> if not.
+        * @throws  ClassCastException if one of the objects isn't a <CODE>Paragraph</CODE>, <CODE>List</CODE>, <CODE>Table</CODE>
+        */
+            
+        public bool AddAll(ICollection collection) {
+            return ((Section)element).AddAll(collection);
+        }
+            
+        /**
+        * Creates a <CODE>Section</CODE>, adds it to this <CODE>Section</CODE> and returns it.
+        *
+        * @param   indentation the indentation of the new section
+        * @param   numberDepth the numberDepth of the section
+        * @return  a new Section object
+        */
+            
+        public MarkedSection AddSection(float indentation, int numberDepth) {
+            MarkedSection section = ((Section)element).AddMarkedSection();
+            section.Indentation = indentation;
+            section.NumberDepth = numberDepth;
+            return section;
+        }
+            
+        /**
+        * Creates a <CODE>Section</CODE>, adds it to this <CODE>Section</CODE> and returns it.
+        *
+        * @param   indentation the indentation of the new section
+        * @return  a new Section object
+        */
+            
+        public MarkedSection AddSection(float indentation) {
+            MarkedSection section = ((Section)element).AddMarkedSection();
+            section.Indentation = indentation;
+            return section;
+        }
+            
+        /**
+        * Creates a <CODE>Section</CODE>, add it to this <CODE>Section</CODE> and returns it.
+        *
+        * @param   numberDepth the numberDepth of the section
+        * @return  a new Section object
+        */
+        public MarkedSection AddSection(int numberDepth) {
+            MarkedSection section = ((Section)element).AddMarkedSection();
+            section.NumberDepth = numberDepth;
+            return section;
+        }
+            
+        /**
+        * Creates a <CODE>Section</CODE>, adds it to this <CODE>Section</CODE> and returns it.
+        *
+        * @return  a new Section object
+        */
+        public MarkedSection AddSection() {
+            return ((Section)element).AddMarkedSection();
+        }
+            
+        // public methods
+            
+        /**
+        * Sets the title of this section.
+        *
+        * @param   title   the new title
+        */
+        public MarkedObject Title {
+            set {
+                if (value.element is Paragraph)
+                    this.title = value;
+            }
+            get {
+                Paragraph result = Section.ConstructTitle((Paragraph)title.element, ((Section)element).numbers, ((Section)element).NumberDepth, ((Section)element).NumberStyle);
+                MarkedObject mo = new MarkedObject(result);
+                mo.markupAttributes = title.MarkupAttributes;
+                return mo;
+            }
+        }
+           
+        /**
+        * Sets the depth of the sectionnumbers that will be shown preceding the title.
+        * <P>
+        * If the numberdepth is 0, the sections will not be numbered. If the numberdepth
+        * is 1, the section will be numbered with their own number. If the numberdepth is
+        * higher (for instance x > 1), the numbers of x - 1 parents will be shown.
+        *
+        * @param   numberDepth     the new numberDepth
+        */
+        public int NumberDepth {
+            set {
+                ((Section)element).NumberDepth = value;
+            }
+        }
+            
+        /**
+        * Sets the indentation of this <CODE>Section</CODE> on the left side.
+        *
+        * @param   indentation     the indentation
+        */
+        public float IndentationLeft {
+            set {
+                ((Section)element).IndentationLeft = value;
+            }
+        }
+            
+        /**
+        * Sets the indentation of this <CODE>Section</CODE> on the right side.
+        *
+        * @param   indentation     the indentation
+        */
+            
+        public float IndentationRight {
+            set {
+                ((Section)element).IndentationRight = value;
+            }
+        }
+            
+        /**
+        * Sets the indentation of the content of this <CODE>Section</CODE>.
+        *
+        * @param   indentation     the indentation
+        */
+        public float Indentation {
+            set {
+                ((Section)element).Indentation = value;
+            }
+        }
+            
+        /** Setter for property bookmarkOpen.
+        * @param bookmarkOpen false if the bookmark children are not
+        * visible.
+        */
+        public bool BookmarkOpen {
+            set {
+                ((Section)element).BookmarkOpen = value;
+            }
+        }
+            
+        /**
+        * Setter for property triggerNewPage.
+        * @param triggerNewPage true if a new page has to be triggered.
+        */
+        public bool TriggerNewPage {
+            set {
+                ((Section)element).TriggerNewPage = value;
+            }
+        }
+            
+        /**
+        * Sets the bookmark title. The bookmark title is the same as the section title but
+        * can be changed with this method.
+        * @param bookmarkTitle the bookmark title
+        */    
+        public String BookmarkTitle {
+            set {
+                ((Section)element).BookmarkTitle = value;
+            }
+        }
+
+        /**
+        * Adds a new page to the section.
+        * @since    2.1.1
+        */
+        public void NewPage() {
+            ((Section)element).NewPage();
+        }
+    }
+}

src/core/iTextSharp/text/Meta.cs

@@ -0,0 +1,234 @@
+using System;
+using System.Text;
+using System.Collections;
+using System.util;
+
+/*
+ * $Id: Meta.cs,v 1.6 2008/05/13 11:25:12 psoares33 Exp $
+ * 
+ *
+ * Copyright 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+
+namespace iTextSharp.text {
+    /// <summary>
+    /// This is an Element that contains
+    /// some meta information about the document.
+    /// </summary>
+    /// <remarks>
+    /// An object of type Meta can not be constructed by the user.
+    /// Userdefined meta information should be placed in a Header-object.
+    /// Meta is reserved for: Subject, Keywords, Author, Title, Producer
+    /// and Creationdate information.
+    /// </remarks>
+    /// <seealso cref="T:iTextSharp.text.Element"/>
+    /// <seealso cref="T:iTextSharp.text.Header"/>
+    public class Meta : IElement {
+    
+        // membervariables
+    
+        ///<summary> This is the type of Meta-information this object contains. </summary>
+        private int type;
+    
+        ///<summary> This is the content of the Meta-information. </summary>
+        private StringBuilder content;
+
+        // constructors
+    
+        /// <summary>
+        /// Constructs a Meta.
+        /// </summary>
+        /// <param name="type">the type of meta-information</param>
+        /// <param name="content">the content</param>
+        public Meta(int type, string content) {
+            this.type = type;
+            this.content = new StringBuilder(content);
+        }
+    
+        /// <summary>
+        /// Constructs a Meta.
+        /// </summary>
+        /// <param name="tag">the tagname of the meta-information</param>
+        /// <param name="content">the content</param>
+        public Meta(string tag, string content) {
+            this.type = Meta.GetType(tag);
+            this.content = new StringBuilder(content);
+        }
+    
+        // implementation of the Element-methods
+    
+        /// <summary>
+        /// Processes the element by adding it (or the different parts) to a
+        /// IElementListener.
+        /// </summary>
+        /// <param name="listener">the IElementListener</param>
+        /// <returns>true if the element was processed successfully</returns>
+        public bool Process(IElementListener listener) {
+            try {
+                return listener.Add(this);
+            }
+            catch (DocumentException) {
+                return false;
+            }
+        }
+    
+        /// <summary>
+        /// Gets the type of the text element.
+        /// </summary>
+        /// <value>a type</value>
+        public int Type {
+            get {
+                return type;
+            }
+        }
+    
+        /// <summary>
+        /// Gets all the chunks in this element.
+        /// </summary>
+        /// <value>an ArrayList</value>
+        public ArrayList Chunks {
+            get {
+                return new ArrayList();
+            }
+        }
+    
+        /**
+        * @see com.lowagie.text.Element#isContent()
+        * @since   iText 2.0.8
+        */
+        public bool IsContent() {
+            return false;
+        }
+
+        /**
+        * @see com.lowagie.text.Element#isNestable()
+        * @since   iText 2.0.8
+        */
+        public bool IsNestable() {
+            return false;
+        }
+
+        // methods
+    
+        /// <summary>
+        /// appends some text to this Meta.
+        /// </summary>
+        /// <param name="str">a string</param>
+        /// <returns>a StringBuilder</returns>
+        public StringBuilder Append(string str) {
+            return content.Append(str);
+        }
+    
+        // methods to retrieve information
+    
+        /// <summary>
+        /// Returns the content of the meta information.
+        /// </summary>
+        /// <value>a string</value>
+        public string Content {
+            get {
+                return content.ToString();
+            }
+        }
+    
+        /// <summary>
+        /// Returns the name of the meta information.
+        /// </summary>
+        /// <value>a string</value>
+        public virtual string Name {
+            get {
+                switch (type) {
+                    case Element.SUBJECT:
+                        return ElementTags.SUBJECT;
+                    case Element.KEYWORDS:
+                        return ElementTags.KEYWORDS;
+                    case Element.AUTHOR:
+                        return ElementTags.AUTHOR;
+                    case Element.TITLE:
+                        return ElementTags.TITLE;
+                    case Element.PRODUCER:
+                        return ElementTags.PRODUCER;
+                    case Element.CREATIONDATE:
+                        return ElementTags.CREATIONDATE;
+                    default:
+                        return ElementTags.UNKNOWN;
+                }
+            }
+        }
+    
+        /// <summary>
+        /// Returns the name of the meta information.
+        /// </summary>
+        /// <param name="tag">name to match</param>
+        /// <returns>a string</returns>
+        public static int GetType(string tag) {
+            if (ElementTags.SUBJECT.Equals(tag)) {
+                return Element.SUBJECT;
+            }
+            if (ElementTags.KEYWORDS.Equals(tag)) {
+                return Element.KEYWORDS;
+            }
+            if (ElementTags.AUTHOR.Equals(tag)) {
+                return Element.AUTHOR;
+            }
+            if (ElementTags.TITLE.Equals(tag)) {
+                return Element.TITLE;
+            }
+            if (ElementTags.PRODUCER.Equals(tag)) {
+                return Element.PRODUCER;
+            }
+            if (ElementTags.CREATIONDATE.Equals(tag)) {
+                return Element.CREATIONDATE;
+            }
+            return Element.HEADER;
+        }
+    
+    
+        public override string ToString() {
+            return base.ToString();
+        }
+    }
+}

src/core/iTextSharp/text/PageSize.cs

@@ -0,0 +1,244 @@
+using System;
+
+/*
+ * $Id: PageSize.cs,v 1.9 2008/05/13 11:25:12 psoares33 Exp $
+ * 
+ *
+ * Copyright 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+
+namespace iTextSharp.text {
+    /// <summary>
+    /// The PageSize-object contains a number of read only rectangles representing the most common paper sizes.
+    /// </summary>
+    /// <seealso cref="T:iTextSharp.text.RectangleReadOnly"/>
+    public class PageSize {
+    
+        // membervariables
+    
+    /** This is the letter format */
+        public static readonly Rectangle LETTER = new RectangleReadOnly(612,792);
+        
+    /** This is the note format */
+        public static readonly Rectangle NOTE = new RectangleReadOnly(540,720);
+        
+    /** This is the legal format */
+        public static readonly Rectangle LEGAL = new RectangleReadOnly(612,1008);
+        
+    /** This is the tabloid format */
+        public static readonly Rectangle TABLOID = new RectangleReadOnly(792,1224);
+
+    /** This is the executive format */
+        public static readonly Rectangle EXECUTIVE = new RectangleReadOnly(522,756);
+
+    /** This is the postcard format */
+        public static readonly Rectangle POSTCARD = new RectangleReadOnly(283,416);
+        
+    /** This is the a0 format */
+        public static readonly Rectangle A0 = new RectangleReadOnly(2384,3370);
+        
+    /** This is the a1 format */
+        public static readonly Rectangle A1 = new RectangleReadOnly(1684,2384);
+        
+    /** This is the a2 format */
+        public static readonly Rectangle A2 = new RectangleReadOnly(1191,1684);
+        
+    /** This is the a3 format */
+        public static readonly Rectangle A3 = new RectangleReadOnly(842,1191);
+        
+    /** This is the a4 format */
+        public static readonly Rectangle A4 = new RectangleReadOnly(595,842);
+        
+    /** This is the a5 format */
+        public static readonly Rectangle A5 = new RectangleReadOnly(420,595);
+        
+    /** This is the a6 format */
+        public static readonly Rectangle A6 = new RectangleReadOnly(297,420);
+        
+    /** This is the a7 format */
+        public static readonly Rectangle A7 = new RectangleReadOnly(210,297);
+        
+    /** This is the a8 format */
+        public static readonly Rectangle A8 = new RectangleReadOnly(148,210);
+        
+    /** This is the a9 format */
+        public static readonly Rectangle A9 = new RectangleReadOnly(105,148);
+        
+    /** This is the a10 format */
+        public static readonly Rectangle A10 = new RectangleReadOnly(73,105);
+        
+    /** This is the b0 format */
+        public static readonly Rectangle B0 = new RectangleReadOnly(2834,4008);
+        
+    /** This is the b1 format */
+        public static readonly Rectangle B1 = new RectangleReadOnly(2004,2834);
+        
+    /** This is the b2 format */
+        public static readonly Rectangle B2 = new RectangleReadOnly(1417,2004);
+        
+    /** This is the b3 format */
+        public static readonly Rectangle B3 = new RectangleReadOnly(1000,1417);
+        
+    /** This is the b4 format */
+        public static readonly Rectangle B4 = new RectangleReadOnly(708,1000);
+        
+    /** This is the b5 format */
+        public static readonly Rectangle B5 = new RectangleReadOnly(498,708);
+
+    /** This is the b6 format */
+        public static readonly Rectangle B6 = new RectangleReadOnly(354,498);
+        
+    /** This is the b7 format */
+        public static readonly Rectangle B7 = new RectangleReadOnly(249,354);
+        
+    /** This is the b8 format */
+        public static readonly Rectangle B8 = new RectangleReadOnly(175,249);
+
+    /** This is the b9 format */
+        public static readonly Rectangle B9 = new RectangleReadOnly(124,175);
+
+    /** This is the b10 format */
+        public static readonly Rectangle B10 = new RectangleReadOnly(87,124);
+        
+    /** This is the archE format */
+        public static readonly Rectangle ARCH_E = new RectangleReadOnly(2592,3456);
+        
+    /** This is the archD format */
+        public static readonly Rectangle ARCH_D = new RectangleReadOnly(1728,2592);
+        
+    /** This is the archC format */
+        public static readonly Rectangle ARCH_C = new RectangleReadOnly(1296,1728);
+        
+    /** This is the archB format */
+        public static readonly Rectangle ARCH_B = new RectangleReadOnly(864,1296);
+        
+    /** This is the archA format */
+        public static readonly Rectangle ARCH_A = new RectangleReadOnly(648,864);
+        
+    /** This is the American Foolscap format */
+        public static readonly Rectangle FLSA = new RectangleReadOnly(612,936);
+        
+    /** This is the European Foolscap format */
+        public static readonly Rectangle FLSE = new RectangleReadOnly(648,936);
+        
+    /** This is the halfletter format */
+        public static readonly Rectangle HALFLETTER = new RectangleReadOnly(396,612);
+        
+    /** This is the 11x17 format */
+        public static readonly Rectangle _11X17 = new RectangleReadOnly(792,1224);
+        
+    /** This is the ISO 7810 ID-1 format (85.60 x 53.98 mm or 3.370 x 2.125 inch) */
+        public static readonly Rectangle ID_1 = new RectangleReadOnly(242.65f,153);
+        
+    /** This is the ISO 7810 ID-2 format (A7 rotated) */
+        public static readonly Rectangle ID_2 = new RectangleReadOnly(297,210);
+        
+    /** This is the ISO 7810 ID-3 format (B7 rotated) */
+        public static readonly Rectangle ID_3 = new RectangleReadOnly(354,249);
+        
+    /** This is the ledger format */
+        public static readonly Rectangle LEDGER = new RectangleReadOnly(1224,792);
+        
+    /** This is the Crown Quarto format */
+        public static readonly Rectangle CROWN_QUARTO = new RectangleReadOnly(535,697);
+
+    /** This is the Large Crown Quarto format */
+        public static readonly Rectangle LARGE_CROWN_QUARTO = new RectangleReadOnly(569,731);
+        
+    /** This is the Demy Quarto format. */
+        public static readonly Rectangle DEMY_QUARTO = new RectangleReadOnly(620,782);
+        
+    /** This is the Royal Quarto format. */
+        public static readonly Rectangle ROYAL_QUARTO = new RectangleReadOnly(671,884);
+        
+    /** This is the Crown Octavo format */
+        public static readonly Rectangle CROWN_OCTAVO = new RectangleReadOnly(348,527);
+        
+    /** This is the Large Crown Octavo format */
+        public static readonly Rectangle LARGE_CROWN_OCTAVO = new RectangleReadOnly(365,561);
+        
+    /** This is the Demy Octavo format */
+        public static readonly Rectangle DEMY_OCTAVO = new RectangleReadOnly(391,612);
+        
+    /** This is the Royal Octavo format. */
+        public static readonly Rectangle ROYAL_OCTAVO = new RectangleReadOnly(442,663);
+        
+    /** This is the small paperback format. */
+        public static readonly Rectangle SMALL_PAPERBACK = new RectangleReadOnly(314,504);
+        
+    /** This is the Pengiun small paperback format. */
+        public static readonly Rectangle PENGUIN_SMALL_PAPERBACK = new RectangleReadOnly(314,513);
+        
+    /** This is the Penguin large paparback format. */
+        public static readonly Rectangle PENGUIN_LARGE_PAPERBACK = new RectangleReadOnly(365,561);
+
+        /**
+        * This method returns a Rectangle based on a String.
+        * Possible values are the the names of a constant in this class
+        * (for instance "A4", "LETTER",...) or a value like "595 842"
+        */
+        public static Rectangle GetRectangle(String name)  {
+            name = name.Trim().ToUpper(System.Globalization.CultureInfo.InvariantCulture);
+            int pos = name.IndexOf(' ');
+            if (pos == -1) {
+                try {            
+                    return (Rectangle)typeof(PageSize).GetField(name).GetValue(null);
+                } catch (Exception) {
+                    throw new ArgumentException("Can't find page size " + name);          
+                }
+            }
+            else {
+                try {
+                    String width = name.Substring(0, pos);
+                    String height = name.Substring(pos + 1);
+                    return new Rectangle(float.Parse(width, System.Globalization.NumberFormatInfo.InvariantInfo), float.Parse(height, System.Globalization.NumberFormatInfo.InvariantInfo));
+                } catch(Exception e) {
+                    throw new ArgumentException(name + " is not a valid page size format: " + e.Message);
+                }
+            }
+        }    
+    }
+}

src/core/iTextSharp/text/Paragraph.cs

@@ -0,0 +1,414 @@
+using System;
+using System.Collections;
+using System.util;
+using iTextSharp.text.factories;
+
+/*
+ * $Id: Paragraph.cs,v 1.14 2008/06/01 13:10:51 psoares33 Exp $
+ * 
+ *
+ * Copyright 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+
+namespace iTextSharp.text {
+    /// <summary>
+    /// A Paragraph is a series of Chunks and/or Phrases.
+    /// </summary>
+    /// <remarks>
+    /// A Paragraph has the same qualities of a Phrase, but also
+    /// some additional layout-parameters:
+    /// <UL>
+    /// <LI/>the indentation
+    /// <LI/>the alignment of the text
+    /// </UL>
+    /// </remarks>
+    /// <example>
+    /// <code>
+    /// <strong>Paragraph p = new Paragraph("This is a paragraph",
+    ///                FontFactory.GetFont(FontFactory.HELVETICA, 18, Font.BOLDITALIC, new Color(0, 0, 255)));</strong>
+    ///    </code>
+    /// </example>
+    /// <seealso cref="T:iTextSharp.text.Element"/>
+    /// <seealso cref="T:iTextSharp.text.Phrase"/>
+    /// <seealso cref="T:iTextSharp.text.ListItem"/>
+    public class Paragraph : Phrase {
+    
+        // membervariables
+    
+        ///<summary> The alignment of the text. </summary>
+        protected int alignment = Element.ALIGN_UNDEFINED;
+    
+        /** The text leading that is multiplied by the biggest font size in the line. */
+        protected float multipliedLeading = 0;
+        
+        ///<summary> The indentation of this paragraph on the left side. </summary>
+        protected float indentationLeft;
+    
+        ///<summary> The indentation of this paragraph on the right side. </summary>
+        protected float indentationRight;
+    
+        /**
+        * Holds value of property firstLineIndent.
+        */
+        private float firstLineIndent = 0;
+
+    /** The spacing before the paragraph. */
+        protected float spacingBefore;
+        
+    /** The spacing after the paragraph. */
+        protected float spacingAfter;
+        
+        
+        /**
+        * Holds value of property extraParagraphSpace.
+        */
+        private float extraParagraphSpace = 0;
+        
+        ///<summary> Does the paragraph has to be kept together on 1 page. </summary>
+        protected bool keeptogether = false;
+    
+        // constructors
+    
+        /// <summary>
+        /// Constructs a Paragraph.
+        /// </summary>
+        public Paragraph() : base() {}
+    
+        /// <summary>
+        /// Constructs a Paragraph with a certain leading.
+        /// </summary>
+        /// <param name="leading">the leading</param>
+        public Paragraph(float leading) : base(leading) {}
+    
+        /// <summary>
+        /// Constructs a Paragraph with a certain Chunk.
+        /// </summary>
+        /// <param name="chunk">a Chunk</param>
+        public Paragraph(Chunk chunk) : base(chunk) {}
+    
+        /// <summary>
+        /// Constructs a Paragraph with a certain Chunk
+        /// and a certain leading.
+        /// </summary>
+        /// <param name="leading">the leading</param>
+        /// <param name="chunk">a Chunk</param>
+        public Paragraph(float leading, Chunk chunk) : base(leading, chunk) {}
+    
+        /// <summary>
+        /// Constructs a Paragraph with a certain string.
+        /// </summary>
+        /// <param name="str">a string</param>
+        public Paragraph(string str) : base(str) {}
+    
+        /// <summary>
+        /// Constructs a Paragraph with a certain string
+        /// and a certain Font.
+        /// </summary>
+        /// <param name="str">a string</param>
+        /// <param name="font">a Font</param>
+        public Paragraph(string str, Font font) : base(str, font) {}
+    
+        /// <summary>
+        /// Constructs a Paragraph with a certain string
+        /// and a certain leading.
+        /// </summary>
+        /// <param name="leading">the leading</param>
+        /// <param name="str">a string</param>
+        public Paragraph(float leading, string str) : base(leading, str) {}
+    
+        /// <summary>
+        /// Constructs a Paragraph with a certain leading, string
+        /// and Font.
+        /// </summary>
+        /// <param name="leading">the leading</param>
+        /// <param name="str">a string</param>
+        /// <param name="font">a Font</param>
+        public Paragraph(float leading, string str, Font font) : base(leading, str, font) {}
+    
+        /// <summary>
+        /// Constructs a Paragraph with a certain Phrase.
+        /// </summary>
+        /// <param name="phrase">a Phrase</param>
+        public Paragraph(Phrase phrase) : base(phrase) {
+            if (phrase is Paragraph) {
+                Paragraph p = (Paragraph)phrase;
+                Alignment = p.Alignment;
+                ExtraParagraphSpace = p.ExtraParagraphSpace;
+                FirstLineIndent = p.FirstLineIndent;
+                IndentationLeft = p.IndentationLeft;
+                IndentationRight = p.IndentationRight;
+                SpacingAfter = p.SpacingAfter;
+                SpacingBefore = p.SpacingBefore;
+            }
+        }
+    
+        // implementation of the Element-methods
+    
+        /// <summary>
+        /// Gets the type of the text element.
+        /// </summary>
+        /// <value>a type</value>
+        public override int Type {
+            get {
+                return Element.PARAGRAPH;
+            }
+        }
+    
+        // methods
+    
+        /// <summary>
+        /// Adds an Object to the Paragraph.
+        /// </summary>
+        /// <param name="o">the object to add</param>
+        /// <returns>a bool</returns>
+        public override bool Add(Object o) {
+            if (o is List) {
+                List list = (List) o;
+                list.IndentationLeft = list.IndentationLeft + indentationLeft;
+                list.IndentationRight = indentationRight;
+                base.Add(list);
+                return true;
+            }
+            else if (o is Image) {
+                base.AddSpecial((Image) o);
+                return true;
+            }
+            else if (o is Paragraph) {
+                base.Add(o);
+                if (Count > 0) {
+                    Chunk tmp = (Chunk)Chunks[Count - 1];
+                    base.Add(new Chunk("\n", tmp.Font));
+                }
+                else {
+                    base.Add(Chunk.NEWLINE);
+                }
+                return true;
+            }
+            base.Add(o);
+            return true;
+        }
+    
+        // setting the membervariables
+    
+        /// <summary>
+        /// Sets the alignment of this paragraph.
+        /// </summary>
+        /// <param name="alignment">the new alignment as a string</param>
+        public void SetAlignment(string alignment) {
+            if (Util.EqualsIgnoreCase(alignment, ElementTags.ALIGN_CENTER)) {
+                this.alignment = Element.ALIGN_CENTER;
+                return;
+            }
+            if (Util.EqualsIgnoreCase(alignment, ElementTags.ALIGN_RIGHT)) {
+                this.alignment = Element.ALIGN_RIGHT;
+                return;
+            }
+            if (Util.EqualsIgnoreCase(alignment, ElementTags.ALIGN_JUSTIFIED)) {
+                this.alignment = Element.ALIGN_JUSTIFIED;
+                return;
+            }
+            if (Util.EqualsIgnoreCase(alignment, ElementTags.ALIGN_JUSTIFIED_ALL)) {
+                this.alignment = Element.ALIGN_JUSTIFIED_ALL;
+                return;
+            }
+            this.alignment = Element.ALIGN_LEFT;
+        }
+    
+        public override float Leading {
+            set {
+                this.leading = value;
+                this.multipliedLeading = 0;
+            }
+        }
+
+        /**
+        * Sets the leading fixed and variable. The resultant leading will be
+        * fixedLeading+multipliedLeading*maxFontSize where maxFontSize is the
+        * size of the bigest font in the line.
+        * @param fixedLeading the fixed leading
+        * @param multipliedLeading the variable leading
+        */
+        public void SetLeading(float fixedLeading, float multipliedLeading) {
+            this.leading = fixedLeading;
+            this.multipliedLeading = multipliedLeading;
+        }
+
+    /**
+     * Sets the variable leading. The resultant leading will be
+     * multipliedLeading*maxFontSize where maxFontSize is the
+     * size of the bigest font in the line.
+     * @param multipliedLeading the variable leading
+     */
+        public float MultipliedLeading {
+            get {
+                return this.multipliedLeading;
+            }
+            set {
+                this.leading = 0;
+                this.multipliedLeading = value;
+            }
+        }
+
+    
+        /// <summary>
+        /// Get/set the alignment of this paragraph.
+        /// </summary>
+        /// <value>a integer</value>
+        public int Alignment{
+            get {
+                return alignment;
+            }
+            set {
+                this.alignment = value;
+            }
+        }
+    
+        /// <summary>
+        /// Get/set the indentation of this paragraph on the left side.
+        /// </summary>
+        /// <value>a float</value>
+        public float IndentationLeft {
+            get {
+                return indentationLeft;
+            }
+
+            set {
+                this.indentationLeft = value;
+            }
+        }
+    
+        /// <summary>
+        /// Get/set the indentation of this paragraph on the right side.
+        /// </summary>
+        /// <value>a float</value>
+        public float IndentationRight {
+            get {
+                return indentationRight;
+            }
+            
+            set {
+                this.indentationRight = value;
+            }
+        }
+    
+        /// <summary>
+        /// Checks if a given tag corresponds with this object.
+        /// </summary>
+        /// <param name="tag">the given tag</param>
+        /// <returns>true if the tag corresponds</returns>
+        public new static bool IsTag(string tag) {
+            return ElementTags.PARAGRAPH.Equals(tag);
+        }
+
+        public float SpacingBefore {
+            get {
+                return spacingBefore;
+            }
+            set {
+                spacingBefore = value;
+            }
+        }
+
+        public float SpacingAfter {
+            get {
+                return spacingAfter;
+            }
+            set {
+                spacingAfter = value;
+            }
+        }
+
+        /// <summary>
+        /// Set/get if this paragraph has to be kept together on one page.
+        /// </summary>
+        /// <value>a bool</value>
+        public bool KeepTogether {
+            get {
+                return keeptogether;
+            }
+            set {
+                this.keeptogether = value;
+            }
+        }    
+
+        /**
+        * Gets the total leading.
+        * This method is based on the assumption that the
+        * font of the Paragraph is the font of all the elements
+        * that make part of the paragraph. This isn't necessarily
+        * true.
+        * @return the total leading (fixed and multiplied)
+        */
+        public float TotalLeading {
+            get {
+                float m = font == null ?
+                        Font.DEFAULTSIZE * multipliedLeading : font.GetCalculatedLeading(multipliedLeading);
+                if (m > 0 && !HasLeading()) {
+                    return m;
+                }
+                return Leading + m;
+            }
+        }
+
+        public float FirstLineIndent {
+            get {
+                return this.firstLineIndent;
+            }
+            set {
+                this.firstLineIndent = value;
+            }
+        }
+
+        public float ExtraParagraphSpace {
+            get {
+                return this.extraParagraphSpace;
+            }
+            set {
+                this.extraParagraphSpace = value;
+            }
+        }
+    }
+}

src/core/iTextSharp/text/Phrase.cs

@@ -0,0 +1,509 @@
+using System;
+using System.Text;
+using System.Collections;
+using System.util;
+using iTextSharp.text.html;
+using iTextSharp.text.pdf;
+using iTextSharp.text.factories;
+
+namespace iTextSharp.text {
+    /// <summary>
+    /// A Phrase is a series of Chunks.
+    /// </summary>
+    /// <remarks>
+    /// A Phrase has a main Font, but some chunks
+    /// within the phrase can have a Font that differs from the
+    /// main Font. All the Chunks in a Phrase
+    /// have the same leading.
+    /// </remarks>
+    /// <example>
+    /// <code>
+    /// // When no parameters are passed, the default leading = 16
+    /// <strong>Phrase phrase0 = new Phrase();
+    /// Phrase phrase1 = new Phrase("this is a phrase");</strong>
+    /// // In this example the leading is passed as a parameter
+    /// <strong>Phrase phrase2 = new Phrase(16, "this is a phrase with leading 16");</strong>
+    /// // When a Font is passed (explicitely or embedded in a chunk), the default leading = 1.5 * size of the font
+    /// <strong>Phrase phrase3 = new Phrase("this is a phrase with a red, normal font Courier, size 12", FontFactory.GetFont(FontFactory.COURIER, 12, Font.NORMAL, new Color(255, 0, 0)));
+    /// Phrase phrase4 = new Phrase(new Chunk("this is a phrase"));
+    /// Phrase phrase5 = new Phrase(18, new Chunk("this is a phrase", FontFactory.GetFont(FontFactory.HELVETICA, 16, Font.BOLD, new Color(255, 0, 0)));</strong>
+    /// </code>
+    /// </example>
+    public class Phrase : ArrayList, ITextElementArray {
+    
+        // membervariables
+    
+        /// <summary>This is the leading of this phrase.</summary>
+        protected Single leading = Single.NaN;
+    
+        ///<summary> This is the font of this phrase. </summary>
+        protected Font font;
+
+        /** Null, unless the Phrase has to be hyphenated.
+        * @since   2.1.2
+        */
+        protected IHyphenationEvent hyphenation = null;
+        
+        // constructors
+    
+        /// <summary>
+        /// Constructs a Phrase without specifying a leading.
+        /// </summary>
+        /// <overloads>
+        /// Has nine overloads.
+        /// </overloads>
+        public Phrase() : this(16) {}
+    
+        /**
+        * Copy constructor for <CODE>Phrase</CODE>.
+        */
+        public Phrase(Phrase phrase) : base() {
+            this.AddAll(phrase);
+            leading = phrase.Leading;
+            font = phrase.Font;
+            hyphenation = phrase.hyphenation;
+        }
+
+        /// <summary>
+        /// Constructs a Phrase with a certain leading.
+        /// </summary>
+        /// <param name="leading">the leading</param>
+        public Phrase(float leading) {
+            this.leading = leading;
+            font = new Font();
+        }
+    
+        /// <summary>
+        /// Constructs a Phrase with a certain Chunk.
+        /// </summary>
+        /// <param name="chunk">a Chunk</param>
+        public Phrase(Chunk chunk) {
+            base.Add(chunk);
+            font = chunk.Font;
+            hyphenation = chunk.GetHyphenation();
+        }
+    
+        /// <summary>
+        /// Constructs a Phrase with a certain Chunk and a certain leading.
+        /// </summary>
+        /// <param name="leading">the leading</param>
+        /// <param name="chunk">a Chunk</param>
+        public Phrase(float leading, Chunk chunk) {
+            this.leading = leading;
+            base.Add(chunk);
+            font = chunk.Font;
+            hyphenation = chunk.GetHyphenation();
+        }
+    
+        /// <summary>
+        /// Constructs a Phrase with a certain string.
+        /// </summary>
+        /// <param name="str">a string</param>
+        public Phrase(string str) : this(float.NaN, str, new Font()) {}
+    
+        /// <summary>
+        /// Constructs a Phrase with a certain string and a certain Font.
+        /// </summary>
+        /// <param name="str">a string</param>
+        /// <param name="font">a Font</param>
+        public Phrase(string str, Font font) : this(float.NaN, str, font) {
+        }
+    
+        /// <summary>
+        /// Constructs a Phrase with a certain leading and a certain string.
+        /// </summary>
+        /// <param name="leading">the leading</param>
+        /// <param name="str">a string</param>
+        public Phrase(float leading, string str) : this(leading, str, new Font()) {}
+    
+        public Phrase(float leading, string str, Font font) {
+            this.leading = leading;
+            this.font = font;
+            /* bugfix by August Detlefsen */
+            if (str != null && str.Length != 0) {
+                base.Add(new Chunk(str, font));
+            }
+        }
+        
+        // implementation of the Element-methods
+    
+        /// <summary>
+        /// Processes the element by adding it (or the different parts) to an
+        /// <see cref="iTextSharp.text.IElementListener"/>.
+        /// </summary>
+        /// <param name="listener">an IElementListener</param>
+        /// <returns>true if the element was processed successfully</returns>
+        public virtual bool Process(IElementListener listener) {
+            try {
+                foreach (IElement ele in this) {
+                    listener.Add(ele);
+                }
+                return true;
+            }
+            catch (DocumentException) {
+                return false;
+            }
+        }
+    
+        /// <summary>
+        /// Gets the type of the text element.
+        /// </summary>
+        /// <value>a type</value>
+        public virtual int Type {
+            get {
+                return Element.PHRASE;
+            }
+        }
+    
+        /// <summary>
+        /// Gets all the chunks in this element.
+        /// </summary>
+        /// <value>an ArrayList</value>
+        public virtual ArrayList Chunks {
+            get {
+                ArrayList tmp = new ArrayList();
+                foreach (IElement ele in this) {
+                    tmp.AddRange(ele.Chunks);
+                }
+                return tmp;
+            }
+        }
+    
+        /**
+        * @see com.lowagie.text.Element#isContent()
+        * @since   iText 2.0.8
+        */
+        public bool IsContent() {
+            return true;
+        }
+
+        /**
+        * @see com.lowagie.text.Element#isNestable()
+        * @since   iText 2.0.8
+        */
+        public bool IsNestable() {
+            return true;
+        }
+
+        // overriding some of the ArrayList-methods
+    
+        /// <summary>
+        /// Adds a Chunk, an Anchor or another Phrase
+        /// to this Phrase.
+        /// </summary>
+        /// <param name="index">index at which the specified element is to be inserted</param>
+        /// <param name="o">an object of type Chunk, Anchor, or Phrase</param>
+        public virtual void Add(int index, Object o) {
+            if (o == null) return;
+            try {
+                IElement element = (IElement) o;
+                if (element.Type == Element.CHUNK) {
+                    Chunk chunk = (Chunk)element;
+                    if (!font.IsStandardFont()) {
+                        chunk.Font = font.Difference(chunk.Font);
+                    }
+                    if (hyphenation != null) {
+                        chunk.SetHyphenation(hyphenation);
+                    }
+                    base.Insert(index, chunk);
+                }
+                else if (element.Type == Element.PHRASE ||
+                    element.Type == Element.ANCHOR ||
+                    element.Type == Element.ANNOTATION ||
+                    element.Type == Element.TABLE || // line added by David Freels
+                    element.Type == Element.YMARK || 
+                    element.Type == Element.MARKED) {
+                    base.Insert(index, element);
+                }
+                else {
+                    throw new Exception(element.Type.ToString());
+                }
+            }
+            catch (Exception cce) {
+                throw new Exception("Insertion of illegal Element: " + cce.Message);
+            }
+        }
+    
+        /// <summary>
+        /// Adds a Chunk, Anchor or another Phrase
+        /// to this Phrase.
+        /// </summary>
+        /// <param name="o">an object of type Chunk, Anchor or Phrase</param>
+        /// <returns>a bool</returns>
+        public virtual new bool Add(Object o) {
+            if (o == null) return false;
+            if (o is string) {
+                base.Add(new Chunk((string) o, font));
+                return true;
+            }
+            if (o is IRtfElementInterface) {
+        	    base.Add(o);
+                return true;
+            }
+            try {
+                IElement element = (IElement) o;
+                switch (element.Type) {
+                    case Element.CHUNK:
+                        return AddChunk((Chunk) o);
+                    case Element.PHRASE:
+                    case Element.PARAGRAPH:
+                        Phrase phrase = (Phrase) o;
+                        bool success = true;
+                        foreach (IElement e in phrase) {
+                            if (e is Chunk) {
+                                success &= AddChunk((Chunk)e);
+                            }
+                            else {
+                                success &= this.Add(e);
+                            }
+                        }
+                        return success;
+                    case Element.MARKED:
+                    case Element.ANCHOR:
+                    case Element.ANNOTATION:
+                    case Element.TABLE: // case added by David Freels
+                    case Element.PTABLE: // case added by Karen Vardanyan
+                        // This will only work for PDF!!! Not for RTF/HTML
+                    case Element.LIST:
+                    case Element.YMARK:
+                        base.Add(o);
+                        return true;
+                    default:
+                        throw new Exception(element.Type.ToString());
+                }
+            }
+            catch (Exception cce) {
+                throw new Exception("Insertion of illegal Element: " + cce.Message);
+            }
+        }
+    
+        /// <summary>
+        /// Adds a collection of Chunks
+        /// to this Phrase.
+        /// </summary>
+        /// <param name="collection">a collection of Chunks, Anchors and Phrases.</param>
+        /// <returns>true if the action succeeded, false if not.</returns>
+        public bool AddAll(ICollection collection) {
+            foreach (object itm in collection) {
+                this.Add(itm);
+            }
+            return true;
+        }
+    
+        /// <summary>
+        /// Adds a Chunk.
+        /// </summary>
+        /// <remarks>
+        /// This method is a hack to solve a problem I had with phrases that were split between chunks
+        /// in the wrong place.
+        /// </remarks>
+        /// <param name="chunk">a Chunk</param>
+        /// <returns>a bool</returns>
+        protected bool AddChunk(Chunk chunk) {
+    	    Font f = chunk.Font;
+    	    String c = chunk.Content;
+            if (font != null && !font.IsStandardFont()) {
+                f = font.Difference(chunk.Font);
+            }
+            if (Count > 0 && !chunk.HasAttributes()) {
+                try {
+                    Chunk previous = (Chunk) this[Count - 1];
+                    if (!previous.HasAttributes()
+                            && (f == null
+                            || f.CompareTo(previous.Font) == 0)
+                            && previous.Font.CompareTo(f) == 0
+                            && !"".Equals(previous.Content.Trim())
+                            && !"".Equals(c.Trim())) {
+                        previous.Append(c);
+                        return true;
+                    }
+                }
+                catch {
+                }
+            }
+            Chunk newChunk = new Chunk(c, f);
+            newChunk.Attributes = chunk.Attributes;
+            if (newChunk.GetHyphenation() == null) {
+                newChunk.SetHyphenation(hyphenation);
+            }
+            base.Add(newChunk);
+            return true;
+        }
+    
+        /// <summary>
+        /// Adds a Object to the Paragraph.
+        /// </summary>
+        /// <param name="obj">the object to add.</param>
+        public void AddSpecial(Object obj) {
+            base.Add(obj);
+        }
+    
+        // methods
+    
+        // methods to retrieve information
+    
+        /// <summary>
+        /// Checks is this Phrase contains no or 1 empty Chunk.
+        /// </summary>
+        /// <returns>
+        /// false if the Phrase
+        /// contains more than one or more non-emptyChunks.
+        /// </returns>
+        public bool IsEmpty() {
+            switch (Count) {
+                case 0:
+                    return true;
+                case 1:
+                    IElement element = (IElement) this[0];
+                    if (element.Type == Element.CHUNK && ((Chunk) element).IsEmpty()) {
+                        return true;
+                    }
+                    return false;
+                default:
+                    return false;
+            }
+        }
+    
+        public bool HasLeading() {
+            if (float.IsNaN(leading)) {
+                return false;
+            }
+            return true;
+        }
+
+        /// <summary>
+        /// Gets/sets the leading of this phrase.
+        /// </summary>
+        /// <value>the linespacing</value>
+        public virtual float Leading {
+            get {
+                if (float.IsNaN(leading) && font != null) {
+                    return font.GetCalculatedLeading(1.5f);
+                }
+                return leading;
+            }
+
+            set {
+                this.leading = value;
+            }
+        }
+    
+        /// <summary>
+        /// Gets the font of the first Chunk that appears in this Phrase.
+        /// </summary>
+        /// <value>a Font</value>
+        public Font Font {
+            get {
+                return font;
+            }
+            set {
+                font = value;
+            }
+        }
+    
+    /**
+    * Returns the content as a String object.
+    * This method differs from toString because toString will return an ArrayList with the toString value of the Chunks in this Phrase.
+    */
+        public String Content {
+            get {
+    	        StringBuilder buf = new StringBuilder();
+                foreach (object obj in Chunks)
+    		        buf.Append(obj.ToString());
+    	        return buf.ToString();
+            }
+        }
+        /// <summary>
+        /// Checks if a given tag corresponds with this object.
+        /// </summary>
+        /// <param name="tag">the given tag</param>
+        /// <returns>true if the tag corresponds</returns>
+        public static bool IsTag(string tag) {
+            return ElementTags.PHRASE.Equals(tag);
+        }
+    
+        public override string ToString() {
+            return base.ToString();
+        }
+
+        /**
+        * Setter/getter for the hyphenation.
+        * @param   hyphenation a HyphenationEvent instance
+        * @since   2.1.2
+        */
+        public IHyphenationEvent Hyphenation {
+            set {
+                hyphenation = value;
+            }
+            get {
+                return hyphenation;
+            }
+        }
+        
+
+        // kept for historical reasons; people should use FontSelector
+        // eligable for deprecation, but the methods are mentioned in the book p277.
+        
+        /**
+        * Constructs a Phrase that can be used in the static GetInstance() method.
+        * @param	dummy	a dummy parameter
+        */
+        private Phrase(bool dummy) {
+        }
+        
+        /**
+        * Gets a special kind of Phrase that changes some characters into corresponding symbols.
+        * @param string
+        * @return a newly constructed Phrase
+        */
+        public static Phrase GetInstance(String str) {
+    	    return GetInstance(16, str, new Font());
+        }
+        
+        /**
+        * Gets a special kind of Phrase that changes some characters into corresponding symbols.
+        * @param leading
+        * @param string
+        * @return a newly constructed Phrase
+        */
+        public static Phrase GetInstance(int leading, String str) {
+    	    return GetInstance(leading, str, new Font());
+        }
+        
+        /**
+        * Gets a special kind of Phrase that changes some characters into corresponding symbols.
+        * @param leading
+        * @param string
+        * @param font
+        * @return a newly constructed Phrase
+        */
+        public static Phrase GetInstance(int leading, String str, Font font) {
+    	    Phrase p = new Phrase(true);
+    	    p.Leading = leading;
+    	    p.font = font;
+    	    if (font.Family != Font.SYMBOL && font.Family != Font.ZAPFDINGBATS && font.BaseFont == null) {
+                int index;
+                while ((index = SpecialSymbol.Index(str)) > -1) {
+                    if (index > 0) {
+                        String firstPart = str.Substring(0, index);
+                        ((ArrayList)p).Add(new Chunk(firstPart, font));
+                        str = str.Substring(index);
+                    }
+                    Font symbol = new Font(Font.SYMBOL, font.Size, font.Style, font.Color);
+                    StringBuilder buf = new StringBuilder();
+                    buf.Append(SpecialSymbol.GetCorrespondingSymbol(str[0]));
+                    str = str.Substring(1);
+                    while (SpecialSymbol.Index(str) == 0) {
+                        buf.Append(SpecialSymbol.GetCorrespondingSymbol(str[0]));
+                        str = str.Substring(1);
+                    }
+                    ((ArrayList)p).Add(new Chunk(buf.ToString(), symbol));
+                }
+            }
+            if (str != null && str.Length != 0) {
+        	    ((ArrayList)p).Add(new Chunk(str, font));
+            }
+    	    return p;
+        }
+    }
+}

src/core/iTextSharp/text/Rectangle.cs

@@ -0,0 +1,733 @@
+using System;
+using System.Collections;
+using System.Text;
+using System.util;
+using iTextSharp.text.pdf;
+
+/*
+ * $Id: Rectangle.cs,v 1.18 2008/05/13 11:25:12 psoares33 Exp $
+ * 
+ *
+ * Copyright 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+
+namespace iTextSharp.text {
+    /// <summary>
+    /// A Rectangle is the representation of a geometric figure.
+    /// </summary>
+    /// <seealso cref="T:iTextSharp.text.Element"/>
+    /// <seealso cref="T:iTextSharp.text.Table"/>
+    /// <seealso cref="T:iTextSharp.text.Cell"/>
+    /// <seealso cref="T:iTextSharp.text.HeaderFooter"/>
+    public class Rectangle : Element, IElement {
+    
+        // static membervariables (concerning the presence of borders)
+    
+        ///<summary> This is the value that will be used as <VAR>undefined</VAR>. </summary>
+        public const int UNDEFINED = -1;
+    
+        ///<summary> This represents one side of the border of the Rectangle. </summary>
+        public const int TOP_BORDER = 1;
+    
+        ///<summary> This represents one side of the border of the Rectangle. </summary>
+        public const int BOTTOM_BORDER = 2;
+    
+        ///<summary> This represents one side of the border of the Rectangle. </summary>
+        public const int LEFT_BORDER = 4;
+    
+        ///<summary> This represents one side of the border of the Rectangle. </summary>
+        public const int RIGHT_BORDER = 8;
+    
+        ///<summary> This represents a rectangle without borders. </summary>
+        public const int NO_BORDER = 0;
+    
+        ///<summary> This represents a type of border. </summary>
+        public const int BOX = TOP_BORDER + BOTTOM_BORDER + LEFT_BORDER + RIGHT_BORDER;
+    
+        // membervariables
+    
+        ///<summary> the lower left x-coordinate. </summary>
+        protected float llx;
+    
+        ///<summary> the lower left y-coordinate. </summary>
+        protected float lly;
+    
+        ///<summary> the upper right x-coordinate. </summary>
+        protected float urx;
+    
+        ///<summary> the upper right y-coordinate. </summary>
+        protected float ury;
+    
+        ///<summary> This represents the status of the 4 sides of the rectangle. </summary>
+        protected int border = UNDEFINED;
+    
+        ///<summary> This is the width of the border around this rectangle. </summary>
+        protected float borderWidth = UNDEFINED;
+    
+        ///<summary> This is the color of the border of this rectangle. </summary>
+        protected Color borderColor = null;
+    
+        /** The color of the left border of this rectangle. */
+        protected Color borderColorLeft = null;
+
+        /** The color of the right border of this rectangle. */
+        protected Color borderColorRight = null;
+
+        /** The color of the top border of this rectangle. */
+        protected Color borderColorTop = null;
+
+        /** The color of the bottom border of this rectangle. */
+        protected Color borderColorBottom = null;
+
+        /** The width of the left border of this rectangle. */
+        protected float borderWidthLeft = UNDEFINED;
+
+        /** The width of the right border of this rectangle. */
+        protected float borderWidthRight = UNDEFINED;
+
+        /** The width of the top border of this rectangle. */
+        protected float borderWidthTop = UNDEFINED;
+
+        /** The width of the bottom border of this rectangle. */
+        protected float borderWidthBottom = UNDEFINED;
+
+        /** Whether variable width borders are used. */
+        protected bool useVariableBorders = false;
+
+        ///<summary> This is the color of the background of this rectangle. </summary>
+        protected Color backgroundColor = null;
+    
+        ///<summary> This is the rotation value of this rectangle. </summary>
+        protected int rotation = 0;
+
+        // constructors
+    
+        /// <summary>
+        /// Constructs a Rectangle-object.
+        /// </summary>
+        /// <param name="llx">lower left x</param>
+        /// <param name="lly">lower left y</param>
+        /// <param name="urx">upper right x</param>
+        /// <param name="ury">upper right y</param>
+        public Rectangle(float llx, float lly, float urx, float ury) {
+            this.llx = llx;
+            this.lly = lly;
+            this.urx = urx;
+            this.ury = ury;
+        }
+    
+        /// <summary>
+        /// Constructs a Rectangle-object starting from the origin (0, 0).
+        /// </summary>
+        /// <param name="urx">upper right x</param>
+        /// <param name="ury">upper right y</param>
+        public Rectangle(float urx, float ury) : this(0, 0, urx, ury) {}
+    
+        /// <summary>
+        /// Constructs a Rectangle-object.
+        /// </summary>
+        /// <param name="rect">another Rectangle</param>
+        public Rectangle(Rectangle rect) : this(rect.llx, rect.lly, rect.urx, rect.ury) {
+            CloneNonPositionParameters(rect);
+        }
+
+        /**
+        * Copies all of the parameters from a <CODE>Rectangle</CODE> object
+        * except the position.
+        * 
+        * @param rect
+        *            <CODE>Rectangle</CODE> to copy from
+        */
+
+        public virtual void CloneNonPositionParameters(Rectangle rect) {
+            this.rotation = rect.rotation;
+            this.border = rect.border;
+            this.borderWidth = rect.borderWidth;
+            this.borderColor = rect.borderColor;
+            this.backgroundColor = rect.backgroundColor;
+            this.borderColorLeft = rect.borderColorLeft;
+            this.borderColorRight = rect.borderColorRight;
+            this.borderColorTop = rect.borderColorTop;
+            this.borderColorBottom = rect.borderColorBottom;
+            this.borderWidthLeft = rect.borderWidthLeft;
+            this.borderWidthRight = rect.borderWidthRight;
+            this.borderWidthTop = rect.borderWidthTop;
+            this.borderWidthBottom = rect.borderWidthBottom;
+            this.useVariableBorders = rect.useVariableBorders;
+        }
+
+        /**
+        * Copies all of the parameters from a <CODE>Rectangle</CODE> object
+        * except the position.
+        * 
+        * @param rect
+        *            <CODE>Rectangle</CODE> to copy from
+        */
+
+        public virtual void SoftCloneNonPositionParameters(Rectangle rect) {
+            if (rect.rotation != 0)
+                this.rotation = rect.rotation;
+            if (rect.border != UNDEFINED)
+                this.border = rect.border;
+            if (rect.borderWidth != UNDEFINED)
+                this.borderWidth = rect.borderWidth;
+            if (rect.borderColor != null)
+                this.borderColor = rect.borderColor;
+            if (rect.backgroundColor != null)
+                this.backgroundColor = rect.backgroundColor;
+            if (rect.borderColorLeft != null)
+                this.borderColorLeft = rect.borderColorLeft;
+            if (rect.borderColorRight != null)
+                this.borderColorRight = rect.borderColorRight;
+            if (rect.borderColorTop != null)
+                this.borderColorTop = rect.borderColorTop;
+            if (rect.borderColorBottom != null)
+                this.borderColorBottom = rect.borderColorBottom;
+            if (rect.borderWidthLeft != UNDEFINED)
+                this.borderWidthLeft = rect.borderWidthLeft;
+            if (rect.borderWidthRight != UNDEFINED)
+                this.borderWidthRight = rect.borderWidthRight;
+            if (rect.borderWidthTop != UNDEFINED)
+                this.borderWidthTop = rect.borderWidthTop;
+            if (rect.borderWidthBottom != UNDEFINED)
+                this.borderWidthBottom = rect.borderWidthBottom;
+            if (useVariableBorders)
+                this.useVariableBorders = rect.useVariableBorders;
+        }
+
+        // implementation of the Element interface
+    
+        /// <summary>
+        /// Processes the element by adding it (or the different parts) to an
+        /// IElementListener.
+        /// </summary>
+        /// <param name="listener">an IElementListener</param>
+        /// <returns>true if the element was processed successfully</returns>
+        public virtual bool Process(IElementListener listener) {
+            try {
+                return listener.Add(this);
+            }
+            catch (DocumentException) {
+                return false;
+            }
+        }
+    
+        /// <summary>
+        /// Gets the type of the text element.
+        /// </summary>
+        /// <value>a type</value>
+        public virtual int Type {
+            get {
+                return Element.RECTANGLE;
+            }
+        }
+    
+        /// <summary>
+        /// Gets all the chunks in this element.
+        /// </summary>
+        /// <value>an ArrayList</value>
+        public virtual ArrayList Chunks {
+            get {
+                return new ArrayList();
+            }
+        }
+    
+        /**
+        * @see com.lowagie.text.Element#isContent()
+        * @since   iText 2.0.8
+        */
+        public bool IsContent() {
+            return true;
+        }
+
+        /**
+        * @see com.lowagie.text.Element#isNestable()
+        * @since   iText 2.0.8
+        */
+        public virtual bool IsNestable() {
+            return false;
+        }
+
+        // methods
+    
+        /**
+        * Switches lowerleft with upperright
+        */
+        public virtual void Normalize() {
+            if (llx > urx) {
+                float a = llx;
+                llx = urx;
+                urx = a;
+            }
+            if (lly > ury) {
+                float a = lly;
+                lly = ury;
+                ury = a;
+            }
+        }
+
+        /// <summary>
+        /// Gets a Rectangle that is altered to fit on the page.
+        /// </summary>
+        /// <param name="top">the top position</param>
+        /// <param name="bottom">the bottom position</param>
+        /// <returns>a Rectangle</returns>
+        public Rectangle GetRectangle(float top, float bottom) {
+            Rectangle tmp = new Rectangle(this);
+            if (this.Top > top) {
+                tmp.Top = top;
+                tmp.Border = border - (border & TOP_BORDER);
+            }
+            if (Bottom < bottom) {
+                tmp.Bottom = bottom;
+                tmp.Border = border - (border & BOTTOM_BORDER);
+            }
+            return tmp;
+        }
+    
+        /// <summary>
+        /// Swaps the values of urx and ury and of lly and llx in order to rotate the rectangle.
+        /// </summary>
+        /// <returns>a Rectangle</returns>
+        public Rectangle Rotate() {
+            Rectangle rect = new Rectangle(lly, llx, ury, urx);
+            rect.rotation = rotation + 90;
+            rect.rotation %= 360;
+            return rect;
+        }
+    
+        // methods to set the membervariables
+    
+        /// <summary>
+        /// Get/set the upper right y-coordinate. 
+        /// </summary>
+        /// <value>a float</value>
+        public virtual float Top {
+            get {
+                return ury;
+            }
+
+            set {
+                ury = value;
+            }
+        }
+
+        /**
+        * Enables the border on the specified side.
+        * 
+        * @param side
+        *            the side to enable. One of <CODE>LEFT, RIGHT, TOP, BOTTOM
+        *            </CODE>
+        */
+        public virtual void EnableBorderSide(int side) {
+            if (border == UNDEFINED) {
+                border = 0;
+            }
+            border |= side;
+        }
+
+        /**
+        * Disables the border on the specified side.
+        * 
+        * @param side
+        *            the side to disable. One of <CODE>LEFT, RIGHT, TOP, BOTTOM
+        *            </CODE>
+        */
+        public virtual void DisableBorderSide(int side) {
+            if (border == UNDEFINED) {
+                border = 0;
+            }
+            border &= ~side;
+        }
+
+
+        /// <summary>
+        /// Get/set the border
+        /// </summary>
+        /// <value>a int</value>
+        public virtual int Border {
+            get {
+                return this.border;
+            }
+
+            set {
+                border = value;
+            }
+        }
+    
+        /// <summary>
+        /// Get/set the grayscale of the rectangle.
+        /// </summary>
+        /// <value>a float</value>
+        public virtual float GrayFill {
+            get {
+                if (backgroundColor is GrayColor)
+                    return ((GrayColor)backgroundColor).Gray;
+                else
+                    return 0;
+            }
+            set {
+                backgroundColor = new GrayColor(value);            }
+        }
+    
+        // methods to get the membervariables
+    
+        /// <summary>
+        /// Get/set the lower left x-coordinate.
+        /// </summary>
+        /// <value>a float</value>
+        public virtual float Left {
+            get {
+                return llx;
+            }
+
+            set {
+                llx = value;
+            }
+        }
+    
+        /// <summary>
+        /// Get/set the upper right x-coordinate.
+        /// </summary>
+        /// <value>a float</value>
+        public virtual float Right {
+            get {
+                return urx;
+            }
+        
+            set {
+                urx = value;
+            }
+        }
+    
+        /// <summary>
+        /// Get/set the lower left y-coordinate.
+        /// </summary>
+        /// <value>a float</value>
+        public virtual float Bottom {
+            get {
+                return lly;
+            }
+            set {
+                lly = value;
+            }
+        }
+    
+        public virtual Color BorderColorBottom {
+            get {
+                if (borderColorBottom == null) return borderColor;
+                return borderColorBottom;
+            }
+            set {
+                borderColorBottom = value;
+            }
+        }
+    
+        public virtual Color BorderColorTop {
+            get {
+                if (borderColorTop == null) return borderColor;
+                return borderColorTop;
+            }
+            set {
+                borderColorTop = value;
+            }
+        }
+    
+        public virtual Color BorderColorLeft {
+            get {
+                if (borderColorLeft == null) return borderColor;
+                return borderColorLeft;
+            }
+            set {
+                borderColorLeft = value;
+            }
+        }
+    
+        public virtual Color BorderColorRight {
+            get {
+                if (borderColorRight == null) return borderColor;
+                return borderColorRight;
+            }
+            set {
+                borderColorRight = value;
+            }
+        }
+    
+        /// <summary>
+        /// Returns the lower left x-coordinate, considering a given margin.
+        /// </summary>
+        /// <param name="margin">a margin</param>
+        /// <returns>the lower left x-coordinate</returns>
+        public virtual float GetLeft(float margin) {
+            return llx + margin;
+        }
+    
+        /// <summary>
+        /// Returns the upper right x-coordinate, considering a given margin.
+        /// </summary>
+        /// <param name="margin">a margin</param>
+        /// <returns>the upper right x-coordinate</returns>
+        public virtual float GetRight(float margin) {
+            return urx - margin;
+        }
+    
+        /// <summary>
+        /// Returns the upper right y-coordinate, considering a given margin.
+        /// </summary>
+        /// <param name="margin">a margin</param>
+        /// <returns>the upper right y-coordinate</returns>
+        public virtual float GetTop(float margin) {
+            return ury - margin;
+        }
+    
+        /// <summary>
+        /// Returns the lower left y-coordinate, considering a given margin.
+        /// </summary>
+        /// <param name="margin">a margin</param>
+        /// <returns>the lower left y-coordinate</returns>
+        public virtual float GetBottom(float margin) {
+            return lly + margin;
+        }
+    
+        /// <summary>
+        /// Returns the width of the rectangle.
+        /// </summary>
+        /// <value>a width</value>
+        public virtual float Width {
+            get {
+                return urx - llx;
+            }
+            set {
+                throw new InvalidOperationException("The width cannot be set.");
+            }
+        }
+    
+        /// <summary>
+        /// Returns the height of the rectangle.
+        /// </summary>
+        /// <value>a height</value>
+        public float Height {
+            get {
+                return ury - lly;
+            }
+        }
+    
+        /// <summary>
+        /// Indicates if the table has borders.
+        /// </summary>
+        /// <returns>a bool</returns>
+        public bool HasBorders() {
+            return (border > 0)
+                && ((borderWidth > 0) || (borderWidthLeft > 0)
+                || (borderWidthRight > 0) || (borderWidthTop > 0) || (borderWidthBottom > 0));
+        }
+    
+        /// <summary>
+        /// Indicates if the table has a some type of border.
+        /// </summary>
+        /// <param name="type">the type of border</param>
+        /// <returns>a bool</returns>
+        public bool HasBorder(int type) {
+            return border != UNDEFINED && (border & type) == type;
+        }
+    
+        /// <summary>
+        /// Get/set the borderwidth.
+        /// </summary>
+        /// <value>a float</value>
+        public virtual float BorderWidth {
+            get {
+                return borderWidth;
+            }
+
+            set {
+                borderWidth = value;
+            }
+        }
+    
+        /**
+         * Gets the color of the border.
+         *
+         * @return    a value
+         */
+        /// <summary>
+        /// Get/set the color of the border.
+        /// </summary>
+        /// <value>a Color</value>
+        public virtual Color BorderColor {
+            get {
+                return borderColor;
+            }
+
+            set {
+                borderColor = value;
+            }
+        }
+    
+        /**
+         * Gets the backgroundcolor.
+         *
+         * @return    a value
+         */
+        /// <summary>
+        /// Get/set the backgroundcolor.
+        /// </summary>
+        /// <value>a Color</value>
+        public virtual Color BackgroundColor {
+            get {
+                return backgroundColor;
+            }
+
+            set {
+                backgroundColor = value;
+            }
+        }
+
+        /// <summary>
+        /// Returns the rotation
+        /// </summary>
+        /// <value>a int</value>    
+        public int Rotation {
+            get {
+                return rotation;
+            }
+        }
+    
+        public virtual float BorderWidthLeft {
+            get {
+                return GetVariableBorderWidth(borderWidthLeft, LEFT_BORDER);
+            }
+            set {
+                borderWidthLeft = value;
+                UpdateBorderBasedOnWidth(value, LEFT_BORDER);
+            }
+        }
+
+        public virtual float BorderWidthRight {
+            get {
+                return GetVariableBorderWidth(borderWidthRight, RIGHT_BORDER);
+            }
+            set {
+                borderWidthRight = value;
+                UpdateBorderBasedOnWidth(value, RIGHT_BORDER);
+            }
+        }
+
+        public virtual float BorderWidthTop {
+            get {
+                return GetVariableBorderWidth(borderWidthTop, TOP_BORDER);
+            }
+            set {
+                borderWidthTop = value;
+                UpdateBorderBasedOnWidth(value, TOP_BORDER);
+            }
+        }
+
+        public virtual float BorderWidthBottom {
+            get {
+                return GetVariableBorderWidth(borderWidthBottom, BOTTOM_BORDER);
+            }
+            set {
+                borderWidthBottom = value;
+                UpdateBorderBasedOnWidth(value, BOTTOM_BORDER);
+            }
+        }
+
+        /**
+        * Updates the border flag for a side based on the specified width. A width
+        * of 0 will disable the border on that side. Any other width enables it.
+        * 
+        * @param width
+        *            width of border
+        * @param side
+        *            border side constant
+        */
+
+        private void UpdateBorderBasedOnWidth(float width, int side) {
+            useVariableBorders = true;
+            if (width > 0) {
+                EnableBorderSide(side);
+            } else {
+                DisableBorderSide(side);
+            }
+        }
+
+        private float GetVariableBorderWidth(float variableWidthValue, int side) {
+            if ((border & side) != 0) {
+                return variableWidthValue != UNDEFINED ? variableWidthValue
+                        : borderWidth;
+            } else {
+                return 0;
+            }
+        }
+
+        /**
+        * Sets a parameter indicating if the rectangle has variable borders
+        * 
+        * @param useVariableBorders
+        *            indication if the rectangle has variable borders
+        */
+        public virtual bool UseVariableBorders{
+            get {
+                return useVariableBorders;
+            }
+            set {
+                useVariableBorders = value;
+            }
+        }
+
+	    public override String ToString() {
+		    StringBuilder buf = new StringBuilder("Rectangle: ");
+		    buf.Append(Width);
+		    buf.Append('x');
+		    buf.Append(Height);
+		    buf.Append(" (rot: ");
+		    buf.Append(rotation);
+		    buf.Append(" degrees)");
+		    return buf.ToString();
+	    }
+    }
+}

src/core/iTextSharp/text/RectangleReadOnly.cs

@@ -0,0 +1,329 @@
+using System;
+using System.Collections;
+using System.Text;
+using System.util;
+using iTextSharp.text.pdf;
+
+/*
+ * $Id: RectangleReadOnly.cs,v 1.2 2008/05/13 11:25:12 psoares33 Exp $
+ * 
+ *
+ * Copyright 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+
+namespace iTextSharp.text {
+    /// <summary>
+    /// A RectangleReadOnly is the representation of a geometric figure.
+    /// It's the same as a Rectangle but immutable.
+    /// </summary>
+    /// <seealso cref="T:iTextSharp.text.Element"/>
+    /// <seealso cref="T:iTextSharp.text.Table"/>
+    /// <seealso cref="T:iTextSharp.text.Cell"/>
+    /// <seealso cref="T:iTextSharp.text.HeaderFooter"/>
+    public class RectangleReadOnly : Rectangle {
+    
+        // constructors
+    
+        /// <summary>
+        /// Constructs a RectangleReadOnly-object.
+        /// </summary>
+        /// <param name="llx">lower left x</param>
+        /// <param name="lly">lower left y</param>
+        /// <param name="urx">upper right x</param>
+        /// <param name="ury">upper right y</param>
+        public RectangleReadOnly(float llx, float lly, float urx, float ury) : base(llx, lly, urx, ury) {
+        }
+    
+        /// <summary>
+        /// Constructs a RectangleReadOnly-object starting from the origin (0, 0).
+        /// </summary>
+        /// <param name="urx">upper right x</param>
+        /// <param name="ury">upper right y</param>
+        public RectangleReadOnly(float urx, float ury) : base(0, 0, urx, ury) {}
+    
+        /// <summary>
+        /// Constructs a RectangleReadOnly-object.
+        /// </summary>
+        /// <param name="rect">another Rectangle</param>
+        public RectangleReadOnly(Rectangle rect) : base(rect.Left, rect.Bottom, rect.Right, rect.Top) {
+            base.CloneNonPositionParameters(rect);
+        }
+
+        /**
+        * Copies all of the parameters from a <CODE>Rectangle</CODE> object
+        * except the position.
+        * 
+        * @param rect
+        *            <CODE>Rectangle</CODE> to copy from
+        */
+        public override void CloneNonPositionParameters(Rectangle rect) {
+            ThrowReadOnlyError();
+        }
+
+        private void ThrowReadOnlyError() {
+            throw new InvalidOperationException("RectangleReadOnly: this Rectangle is read only.");
+        }
+
+        /**
+        * Copies all of the parameters from a <CODE>Rectangle</CODE> object
+        * except the position.
+        * 
+        * @param rect
+        *            <CODE>Rectangle</CODE> to copy from
+        */
+
+        public override void SoftCloneNonPositionParameters(Rectangle rect) {
+            ThrowReadOnlyError();
+        }
+
+        // methods
+    
+        /**
+        * Switches lowerleft with upperright
+        */
+        public override void Normalize() {
+            ThrowReadOnlyError();
+        }
+
+        // methods to set the membervariables
+    
+        /// <summary>
+        /// Get/set the upper right y-coordinate. 
+        /// </summary>
+        /// <value>a float</value>
+        public override float Top {
+            set {
+                ThrowReadOnlyError();
+            }
+        }
+
+        /**
+        * Enables the border on the specified side.
+        * 
+        * @param side
+        *            the side to enable. One of <CODE>LEFT, RIGHT, TOP, BOTTOM
+        *            </CODE>
+        */
+        public override void EnableBorderSide(int side) {
+            ThrowReadOnlyError();
+        }
+
+        /**
+        * Disables the border on the specified side.
+        * 
+        * @param side
+        *            the side to disable. One of <CODE>LEFT, RIGHT, TOP, BOTTOM
+        *            </CODE>
+        */
+        public override void DisableBorderSide(int side) {
+            ThrowReadOnlyError();
+        }
+
+
+        /// <summary>
+        /// Get/set the border
+        /// </summary>
+        /// <value>a int</value>
+        public override int Border {
+            set {
+                ThrowReadOnlyError();
+            }
+        }
+    
+        /// <summary>
+        /// Get/set the grayscale of the rectangle.
+        /// </summary>
+        /// <value>a float</value>
+        public override float GrayFill {
+            set {
+                ThrowReadOnlyError();
+            }
+        }
+    
+        // methods to get the membervariables
+    
+        /// <summary>
+        /// Get/set the lower left x-coordinate.
+        /// </summary>
+        /// <value>a float</value>
+        public override float Left {
+            set {
+                ThrowReadOnlyError();
+            }
+        }
+    
+        /// <summary>
+        /// Get/set the upper right x-coordinate.
+        /// </summary>
+        /// <value>a float</value>
+        public override float Right {
+            set {
+                ThrowReadOnlyError();
+            }
+        }
+    
+        /// <summary>
+        /// Get/set the lower left y-coordinate.
+        /// </summary>
+        /// <value>a float</value>
+        public override float Bottom {
+            set {
+                ThrowReadOnlyError();
+            }
+        }
+    
+        public override Color BorderColorBottom {
+            set {
+                ThrowReadOnlyError();
+            }
+        }
+    
+        public override Color BorderColorTop {
+            set {
+                ThrowReadOnlyError();
+            }
+        }
+    
+        public override Color BorderColorLeft {
+            set {
+                ThrowReadOnlyError();
+            }
+        }
+    
+        public override Color BorderColorRight {
+            set {
+                ThrowReadOnlyError();
+            }
+        }
+    
+        /// <summary>
+        /// Get/set the borderwidth.
+        /// </summary>
+        /// <value>a float</value>
+        public override float BorderWidth {
+            set {
+                ThrowReadOnlyError();
+            }
+        }
+    
+        /**
+         * Gets the color of the border.
+         *
+         * @return    a value
+         */
+        /// <summary>
+        /// Get/set the color of the border.
+        /// </summary>
+        /// <value>a Color</value>
+        public override Color BorderColor {
+            set {
+                ThrowReadOnlyError();
+            }
+        }
+    
+        /**
+         * Gets the backgroundcolor.
+         *
+         * @return    a value
+         */
+        /// <summary>
+        /// Get/set the backgroundcolor.
+        /// </summary>
+        /// <value>a Color</value>
+        public override Color BackgroundColor {
+            set {
+                ThrowReadOnlyError();
+            }
+        }
+
+        public override float BorderWidthLeft {
+            set {
+                ThrowReadOnlyError();
+            }
+        }
+
+        public override float BorderWidthRight {
+            set {
+                ThrowReadOnlyError();
+            }
+        }
+
+        public override float BorderWidthTop {
+            set {
+                ThrowReadOnlyError();
+            }
+        }
+
+        public override float BorderWidthBottom {
+            set {
+                ThrowReadOnlyError();
+            }
+        }
+
+        /**
+        * Sets a parameter indicating if the rectangle has variable borders
+        * 
+        * @param useVariableBorders
+        *            indication if the rectangle has variable borders
+        */
+        public override bool UseVariableBorders{
+            set {
+                ThrowReadOnlyError();
+            }
+        }
+
+	    public override String ToString() {
+		    StringBuilder buf = new StringBuilder("RectangleReadOnly: ");
+		    buf.Append(Width);
+		    buf.Append('x');
+		    buf.Append(Height);
+		    buf.Append(" (rot: ");
+		    buf.Append(rotation);
+		    buf.Append(" degrees)");
+		    return buf.ToString();
+	    }
+    }
+}

src/core/iTextSharp/text/RomanList.cs

@@ -0,0 +1,116 @@
+using System;
+using System.Text;
+using iTextSharp.text.factories;
+
+/*
+ * Copyright 2003 by Michael Niedermair.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+namespace iTextSharp.text {
+
+/**
+ * 
+ * A special-version of <CODE>LIST</CODE> which use roman-letters.
+ * 
+ * @see com.lowagie.text.List
+ * @version 2003-06-22
+ * @author Michael Niedermair
+ */
+
+    public class RomanList : List {
+
+        /**
+        * Initialization
+        */
+        public RomanList() : base(true) {
+        }
+
+        /**
+        * Initialization
+        * 
+        * @param symbolIndent    indent
+        */
+        public RomanList(int symbolIndent) : base(true, symbolIndent){
+        }
+
+        /**
+        * Initialization 
+        * @param    romanlower        roman-char in lowercase   
+        * @param     symbolIndent    indent
+        */
+        public RomanList(bool romanlower, int symbolIndent) : base(true, symbolIndent) {
+            this.lowercase = romanlower;
+        }
+
+        /**
+        * Adds an <CODE>Object</CODE> to the <CODE>List</CODE>.
+        *
+        * @param    o    the object to add.
+        * @return true if adding the object succeeded
+        */
+        public override bool Add(Object o) {
+            if (o is ListItem) {
+                ListItem item = (ListItem) o;
+                Chunk chunk = new Chunk(preSymbol, symbol.Font);
+                chunk.Append(RomanNumberFactory.GetString(first + list.Count, lowercase));
+                chunk.Append(postSymbol);
+                item.ListSymbol = chunk;
+                item.SetIndentationLeft(symbolIndent, autoindent);
+                item.IndentationRight = 0;
+                list.Add(item);
+                return true;
+            } else if (o is List) {
+                List nested = (List) o;
+                nested.IndentationLeft = nested.IndentationLeft + symbolIndent;
+                first--;
+                list.Add(nested);
+                return true;
+            } else if (o is string) {
+                return this.Add(new ListItem((string) o));
+            }
+            return false;
+        }
+    }
+}

src/core/iTextSharp/text/Row.cs

@@ -0,0 +1,376 @@
+using System;
+using System.Collections;
+using System.util;
+
+/*
+ * $Id: Row.cs,v 1.10 2008/05/13 11:25:12 psoares33 Exp $
+ * 
+ *
+ * Copyright 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU LIBRARY GENERAL PUBLIC LICENSE for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+
+namespace iTextSharp.text {
+    /// <summary>
+    /// A Row is part of a Table
+    /// and contains some Cells.
+    /// </summary>
+    /// <remarks>
+    /// All Rows are constructed by a Table-object.
+    /// You don't have to construct any Row yourself.
+    /// In fact you can't construct a Row outside the package.
+    /// <P/>
+    /// Since a Cell can span several rows and/or columns
+    /// a row can contain reserved space without any content.
+    /// </remarks>
+    /// <seealso cref="T:iTextSharp.text.Element"/>
+    /// <seealso cref="T:iTextSharp.text.Cell"/>
+    /// <seealso cref="T:iTextSharp.text.Table"/>
+    public class Row : IElement {
+    
+        // membervariables
+    
+        /// <summary> id of a null element in a Row</summary>
+        public static int NULL = 0;
+    
+        /// <summary> id of the Cell element in a Row</summary>
+        public static int CELL = 1;
+    
+        /// <summary> id of the Table element in a Row</summary>
+        public static int TABLE = 2;
+    
+        /// <summary> This is the number of columns in the Row. </summary>
+        protected int columns;
+    
+        /// <summary> This is a valid position the Row. </summary>
+        protected int currentColumn;
+    
+        /// <summary> This is the array that keeps track of reserved cells. </summary>
+        protected bool[] reserved;
+    
+        /// <summary> This is the array of Objects (Cell or Table). </summary>
+        protected Object[] cells;
+    
+        /// <summary> This is the horizontal alignment. </summary>
+        protected int horizontalAlignment;
+    
+        // constructors
+    
+        /// <summary>
+        /// Constructs a Row with a certain number of columns.
+        /// </summary>
+        /// <param name="columns">a number of columns</param>
+        internal Row(int columns) {
+            this.columns = columns;
+            reserved = new bool[columns];
+            cells = new Object[columns];
+            currentColumn = 0;
+        }
+    
+        // implementation of the Element-methods
+    
+        /// <summary>
+        /// Processes the element by adding it (or the different parts) to a
+        /// IElementListener.
+        /// </summary>
+        /// <param name="listener">an IElementListener</param>
+        /// <returns>true if the element was processed successfully</returns>
+        public bool Process(IElementListener listener) {
+            try {
+                return listener.Add(this);
+            }
+            catch (DocumentException) {
+                return false;
+            }
+        }
+    
+        /// <summary>
+        /// Gets the type of the text element.
+        /// </summary>
+        /// <value>a type</value>
+        public int Type {
+            get {
+                return Element.ROW;
+            }
+        }
+    
+        /// <summary>
+        /// Gets all the chunks in this element.
+        /// </summary>
+        /// <value>an ArrayList</value>
+        public ArrayList Chunks {
+            get {
+                return new ArrayList();
+            }
+        }
+    
+        /**
+        * @see com.lowagie.text.Element#isContent()
+        * @since   iText 2.0.8
+        */
+        public bool IsContent() {
+            return true;
+        }
+
+        /**
+        * @see com.lowagie.text.Element#isNestable()
+        * @since   iText 2.0.8
+        */
+        public bool IsNestable() {
+            return false;
+        }
+
+        /// <summary>
+        /// Deletes a certain column has been deleted.
+        /// </summary>
+        /// <param name="column">the number of the column to delete</param>
+        internal void DeleteColumn(int column) {
+            if ((column >= columns) || (column < 0)) {
+                throw new Exception("getCell at illegal index : " + column);
+            }
+            columns--;
+            bool[] newReserved = new bool[columns];
+                Object[] newCells = new Cell[columns];
+        
+                    for (int i = 0; i < column; i++) {
+                        newReserved[i] = reserved[i];
+                        newCells[i] = cells[i];
+                        if (newCells[i] != null && (i + ((Cell) newCells[i]).Colspan > column)) {
+                            ((Cell) newCells[i]).Colspan = ((Cell) cells[i]).Colspan - 1;
+                        }
+                    }
+            for (int i = column; i < columns; i++) {
+                newReserved[i] = reserved[i + 1];
+                newCells[i] = cells[i + 1];
+            }
+            if (cells[column] != null && ((Cell) cells[column]).Colspan > 1) {
+                newCells[column] = cells[column];
+                ((Cell) newCells[column]).Colspan = ((Cell) newCells[column]).Colspan - 1;
+            }
+            reserved = newReserved;
+            cells = newCells;
+        }
+    
+        // methods
+    
+        /// <summary>
+        /// Adds a Cell to the Row.
+        /// </summary>
+        /// <param name="element">the element to add (currently only Cells and Tables supported)</param>
+        /// <returns>
+        /// the column position the Cell was added,
+        ///        or -1 if the element couldn't be added.
+        /// </returns>
+        internal int AddElement(Object element) {
+            return AddElement(element, currentColumn);
+        }
+    
+        /// <summary>
+        /// Adds an element to the Row at the position given.
+        /// </summary>
+        /// <param name="element">the element to add. (currently only Cells and Tables supported</param>
+        /// <param name="column">the position where to add the cell</param>
+        /// <returns>
+        /// the column position the Cell was added,
+        ///        or -1 if the Cell couldn't be added.
+        /// </returns>
+        internal int AddElement(Object element, int column) {
+            if (element == null) throw new Exception("addCell - null argument");
+            if ((column < 0) || (column > columns)) throw new Exception("addCell - illegal column argument");
+            if ( !((GetObjectID(element) == CELL) || (GetObjectID(element) == TABLE)) ) throw new ArgumentException("addCell - only Cells or Tables allowed");
+        
+            int lColspan = ((element is Cell) ? ((Cell)element).Colspan : 1);
+        
+            if (!Reserve(column, lColspan)) {
+                return -1;
+            }
+        
+            cells[column] = element;
+            currentColumn += lColspan - 1;
+        
+            return column;
+        }
+    
+        /// <summary>
+        /// Puts Cell to the Row at the position given, doesn't reserve colspan.
+        /// </summary>
+        /// <param name="aElement">the cell to add.</param>
+        /// <param name="column">the position where to add the cell.</param>
+        internal void SetElement(Object aElement, int column) {
+            if (reserved[column]) throw new ArgumentException("setElement - position already taken");
+        
+            cells[column] = aElement;
+            if (aElement != null) {
+                reserved[column] = true;
+            }
+        }
+    
+        /// <summary>
+        /// Reserves a Cell in the Row.
+        /// </summary>
+        /// <param name="column">the column that has to be reserved.</param>
+        /// <returns>true if the column was reserved, false if not.</returns>
+        internal bool Reserve(int column) {
+            return Reserve(column, 1);
+        }
+    
+    
+        /// <summary>
+        /// Reserves a Cell in the Row.
+        /// </summary>
+        /// <param name="column">the column that has to be reserved.</param>
+        /// <param name="size">the number of columns</param>
+        /// <returns>true if the column was reserved, false if not.</returns>
+        internal bool Reserve(int column, int size) {
+            if ((column < 0) || ((column + size) > columns)) throw new Exception("reserve - incorrect column/size");
+        
+            for (int i=column; i < column + size; i++) {
+                if (reserved[i]) {
+                    // undo reserve
+                    for (int j=i; j >= column; j--) {
+                        reserved[j] = false;
+                    }
+                    return false;
+                }
+                reserved[i] = true;
+            }
+            return true;
+        }
+    
+        // methods to retrieve information
+    
+        /// <summary>
+        /// Returns true/false when this position in the Row has been reserved, either filled or through a colspan of an Element.
+        /// </summary>
+        /// <param name="column">the column.</param>
+        /// <returns>true if the column was reserved, false if not.</returns>
+        internal bool IsReserved(int column) {
+            return reserved[column];
+        }
+    
+        /// <summary>
+        /// Returns the type-id of the element in a Row.
+        /// </summary>
+        /// <param name="column">the column of which you'd like to know the type</param>
+        /// <returns>the element id</returns>
+        int GetElementID(int column) {
+            if (cells[column] == null) return NULL;
+            else if (cells[column] is Cell) return CELL;
+            else if (cells[column] is Table) return TABLE;
+        
+            return -1;
+        }
+    
+    
+        /// <summary>
+        /// Returns the type-id of an Object.
+        /// </summary>
+        /// <param name="element"></param>
+        /// <returns>the object of which you'd like to know the type-id, -1 if invalid</returns>
+        int GetObjectID(Object element) {
+            if (element == null) return NULL;
+            else if (element is Cell) return CELL;
+            else if (element is Table) return TABLE;
+        
+            return -1;
+        }
+    
+    
+        /// <summary>
+        /// Gets a Cell or Table from a certain column.
+        /// </summary>
+        /// <param name="column">the column the Cell/Table is in.</param>
+        /// <returns>
+        /// the Cell,Table or Object if the column was
+        /// reserved or null if empty.
+        /// </returns>
+        public Object GetCell(int column) {
+            if ((column < 0) || (column > columns)) {
+                throw new Exception("getCell at illegal index :" + column + " max is " + columns);
+            }
+            return cells[column];
+        }
+    
+        /// <summary>
+        /// Checks if the row is empty.
+        /// </summary>
+        /// <returns>true if none of the columns is reserved.</returns>
+        public bool IsEmpty() {
+            for (int i = 0; i < columns; i++) {
+                if (cells[i] != null) {
+                    return false;
+                }
+            }
+            return true;
+        }
+    
+        /// <summary>
+        /// Gets the number of columns.
+        /// </summary>
+        /// <value>a value</value>
+        public int Columns {
+            get {
+                return columns;
+            }
+        }
+    
+        /// <summary>
+        /// Gets the horizontal Element.
+        /// </summary>
+        /// <value>a value</value>
+        public int HorizontalAlignment {
+            get {
+                return horizontalAlignment;
+            }
+            set {
+                horizontalAlignment = value;
+            }
+        }
+    
+        public override string ToString() {
+            return base.ToString();
+        }
+    }
+}

src/core/iTextSharp/text/Section.cs

@@ -0,0 +1,756 @@
+using System;
+using System.Text;
+using System.Collections;
+using System.util;
+using iTextSharp.text.factories;
+
+/*
+ * $Id: Section.cs,v 1.17 2008/05/13 11:25:13 psoares33 Exp $
+ * 
+ *
+ * Copyright 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+
+namespace iTextSharp.text {
+    /// <summary>
+    /// A Section is a part of a Document containing
+    /// other Sections, Paragraphs, List
+    /// and/or Tables.
+    /// </summary>
+    /// <remarks>
+    /// You can not construct a Section yourself.
+    /// You will have to ask an instance of Section to the
+    /// Chapter or Section to which you want to
+    /// add the new Section.
+    /// </remarks>
+    /// <example>
+    /// <code>
+    /// Paragraph title2 = new Paragraph("This is Chapter 2", FontFactory.GetFont(FontFactory.HELVETICA, 18, Font.BOLDITALIC, new Color(0, 0, 255)));
+    /// Chapter chapter2 = new Chapter(title2, 2);
+    /// Paragraph someText = new Paragraph("This is some text");
+    /// chapter2.Add(someText);
+    /// Paragraph title21 = new Paragraph("This is Section 1 in Chapter 2", FontFactory.GetFont(FontFactory.HELVETICA, 16, Font.BOLD, new Color(255, 0, 0)));
+    /// <strong>Section section1 = chapter2.AddSection(title21);</strong>
+    /// Paragraph someSectionText = new Paragraph("This is some silly paragraph in a chapter and/or section. It contains some text to test the functionality of Chapters and Section.");
+    /// <strong>section1.Add(someSectionText);</strong>
+    /// Paragraph title211 = new Paragraph("This is SubSection 1 in Section 1 in Chapter 2", FontFactory.GetFont(FontFactory.HELVETICA, 14, Font.BOLD, new Color(255, 0, 0)));
+    /// <strong>Section section11 = section1.AddSection(40, title211, 2);
+    /// section11.Add(someSectionText);</strong>strong>
+    /// </code>
+    /// </example>
+    public class Section : ArrayList, ITextElementArray, ILargeElement {
+        
+        // constant
+        /**
+        * A possible number style. The default number style: "1.2.3."
+        * @since   iText 2.0.8
+        */
+        public const int NUMBERSTYLE_DOTTED = 0;
+        /**
+        * A possible number style. For instance: "1.2.3"
+        * @since   iText 2.0.8
+        */
+        public const int NUMBERSTYLE_DOTTED_WITHOUT_FINAL_DOT = 1;
+        
+        // membervariables
+    
+        ///<summary> This is the title of this section. </summary>
+        protected Paragraph title;
+    
+        ///<summary> This is the number of sectionnumbers that has to be shown before the section title. </summary>
+        protected int numberDepth;
+    
+        /**
+        * The style for sectionnumbers.
+        * @since    iText 2.0.8
+        */
+        protected int numberStyle = NUMBERSTYLE_DOTTED;
+        
+        ///<summary> The indentation of this section on the left side. </summary>
+        protected float indentationLeft;
+    
+        ///<summary> The indentation of this section on the right side. </summary>
+        protected float indentationRight;
+    
+        ///<summary> The additional indentation of the content of this section. </summary>
+        protected float indentation;
+    
+        ///<summary> This is the number of subsections. </summary>
+        protected int subsections = 0;
+    
+        ///<summary> This is the complete list of sectionnumbers of this section and the parents of this section. </summary>
+        protected internal ArrayList numbers = null;
+    
+    /**
+        * Indicates if the Section will be complete once added to the document.
+        * @since   iText 2.0.8
+        */
+        protected bool complete = true;
+        
+        /**
+        * Indicates if the Section was added completely to the document.
+        * @since   iText 2.0.8
+        */
+        protected bool addedCompletely = false;
+        
+        /**
+        * Indicates if this is the first time the section was added.
+        * @since   iText 2.0.8
+        */
+        protected bool notAddedYet = true;
+        
+        ///<summary> false if the bookmark children are not visible </summary>
+        protected bool bookmarkOpen = true;
+    
+        /** true if the section has to trigger a new page */
+        protected bool triggerNewPage = false;
+
+        /** The bookmark title if different from the content title */
+        protected string bookmarkTitle;
+
+        // constructors
+    
+        /// <summary>
+        /// Constructs a new Section.
+        /// </summary>
+        /// <overloads>
+        /// Has 2 overloads.
+        /// </overloads>
+        protected internal Section() {
+            title = new Paragraph();
+            numberDepth = 1;
+        }
+    
+        /// <summary>
+        /// Constructs a new Section.
+        /// </summary>
+        /// <param name="title">a Paragraph</param>
+        /// <param name="numberDepth">the numberDepth</param>
+        protected internal Section(Paragraph title, int numberDepth) {
+            this.numberDepth = numberDepth;
+            this.title = title;
+        }
+    
+        // private methods
+    
+        /// <summary>
+        /// Sets the number of this section.
+        /// </summary>
+        /// <param name="number">the number of this section</param>
+        /// <param name="numbers">an ArrayList, containing the numbers of the Parent</param>
+        private void SetNumbers(int number, ArrayList numbers) {
+            this.numbers = new ArrayList();
+            this.numbers.Add(number);
+            this.numbers.AddRange(numbers);
+        }
+    
+        // implementation of the Element-methods
+    
+        /// <summary>
+        /// Processes the element by adding it (or the different parts) to an
+        /// IElementListener.
+        /// </summary>
+        /// <param name="listener">the IElementListener</param>
+        /// <returns>true if the element was processed successfully</returns>
+        public bool Process(IElementListener listener) {
+            try {
+                foreach (IElement ele in this) {
+                    listener.Add(ele);
+                }
+                return true;
+            }
+            catch (DocumentException) {
+                return false;
+            }
+        }
+    
+        /// <summary>
+        /// Gets the type of the text element.
+        /// </summary>
+        /// <value>a type</value>
+        public virtual int Type {
+            get {
+                return Element.SECTION;
+            }
+        }
+    
+        /// <summary>
+        /// Gets all the chunks in this element.
+        /// </summary>
+        /// <value>an ArrayList</value>
+        public ArrayList Chunks {
+            get {
+                ArrayList tmp = new ArrayList();
+                foreach (IElement ele in this) {
+                    tmp.AddRange(ele.Chunks);
+                }
+                return tmp;
+            }
+        }
+    
+        /**
+        * @see com.lowagie.text.Element#isContent()
+        * @since   iText 2.0.8
+        */
+        public bool IsContent() {
+            return true;
+        }
+
+        /**
+        * @see com.lowagie.text.Element#isNestable()
+        * @since   iText 2.0.8
+        */
+        public virtual bool IsNestable() {
+            return false;
+        }
+        
+        // overriding some of the ArrayList-methods
+    
+        /// <summary>
+        /// Adds a Paragraph, List or Table
+        /// to this Section.
+        /// </summary>
+        /// <param name="index">index at which the specified element is to be inserted</param>
+        /// <param name="o">an object of type Paragraph, List or Table</param>
+        public void Add(int index, Object o) {
+            if (AddedCompletely) {
+                throw new InvalidOperationException("This LargeElement has already been added to the Document.");
+            }
+            try {
+                IElement element = (IElement) o;
+                if (element.IsNestable()) {
+                    base.Insert(index, element);
+                }
+                else {
+                    throw new Exception(element.Type.ToString());
+                }
+            }
+            catch (Exception cce) {
+                throw new Exception("Insertion of illegal Element: " + cce.Message);
+            }
+        }
+    
+        /// <summary>
+        /// Adds a Paragraph, List, Table or another Section
+        /// to this Section.
+        /// </summary>
+        /// <param name="o">an object of type Paragraph, List, Table or another Section</param>
+        /// <returns>a bool</returns>
+        public new bool Add(Object o) {
+            try {
+                IElement element = (IElement) o;
+                if (element.Type == Element.SECTION) {
+                    Section section = (Section) o;
+                    section.SetNumbers(++subsections, numbers);
+                    base.Add(section);
+                    return true;
+                }
+                else if (o is MarkedSection && ((MarkedObject)o).element.Type == Element.SECTION) {
+                    MarkedSection mo = (MarkedSection)o;
+                    Section section = (Section)(mo.element);
+                    section.SetNumbers(++subsections, numbers);
+                    base.Add(mo);
+                    return true;
+                }
+                else if (element.IsNestable()) {
+                    base.Add(o);
+                    return true;
+                }
+                else {
+                    throw new Exception(element.Type.ToString());
+                }
+            }
+            catch (Exception cce) {
+                throw new Exception("Insertion of illegal Element: " + cce.Message);
+            }
+        }
+    
+        /// <summary>
+        /// Adds a collection of Elements
+        /// to this Section.
+        /// </summary>
+        /// <param name="collection">a collection of Paragraphs, Lists and/or Tables</param>
+        /// <returns>true if the action succeeded, false if not.</returns>
+        public bool AddAll(ICollection collection) {
+            foreach (object itm in collection) {
+                this.Add(itm);
+            }
+            return true;
+        }
+    
+        // methods that return a Section
+    
+        /// <summary>
+        /// Creates a Section, adds it to this Section and returns it.
+        /// </summary>
+        /// <param name="indentation">the indentation of the new section</param>
+        /// <param name="title">the title of the new section</param>
+        /// <param name="numberDepth">the numberDepth of the section</param>
+        /// <returns>the newly added Section</returns>
+        public virtual Section AddSection(float indentation, Paragraph title, int numberDepth) {
+            if (AddedCompletely) {
+                throw new InvalidOperationException("This LargeElement has already been added to the Document.");
+            }
+            Section section = new Section(title, numberDepth);
+            section.Indentation = indentation;
+            Add(section);
+            return section;
+        }
+    
+        /// <summary>
+        /// Creates a Section, adds it to this Section and returns it.
+        /// </summary>
+        /// <param name="indentation">the indentation of the new section</param>
+        /// <param name="title">the title of the new section</param>
+        /// <returns>the newly added Section</returns>
+        public virtual Section AddSection(float indentation, Paragraph title) {
+            return AddSection(indentation, title, numberDepth + 1);
+        }
+    
+        /// <summary>
+        /// Creates a Section, add it to this Section and returns it.
+        /// </summary>
+        /// <param name="title">the title of the new section</param>
+        /// <param name="numberDepth">the numberDepth of the section</param>
+        /// <returns>the newly added Section</returns>
+        public virtual Section AddSection(Paragraph title, int numberDepth) {
+            return AddSection(0, title, numberDepth);
+        }
+    
+        /**
+        * Adds a marked section. For use in class MarkedSection only!
+        */
+        public MarkedSection AddMarkedSection() {
+            MarkedSection section = new MarkedSection(new Section(null, numberDepth + 1));
+            Add(section);
+            return section;
+        }
+
+        /// <summary>
+        /// Creates a Section, adds it to this Section and returns it.
+        /// </summary>
+        /// <param name="title">the title of the new section</param>
+        /// <returns>the newly added Section</returns>
+        public virtual Section AddSection(Paragraph title) {
+            return AddSection(0, title, numberDepth + 1);
+        }
+    
+        /**
+         * Adds a Section to this Section and returns it.
+         *
+         * @param    indentation    the indentation of the new section
+         * @param    title        the title of the new section
+         * @param    numberDepth    the numberDepth of the section
+         */
+        /// <summary>
+        /// Adds a Section to this Section and returns it.
+        /// </summary>
+        /// <param name="indentation">the indentation of the new section</param>
+        /// <param name="title">the title of the new section</param>
+        /// <param name="numberDepth">the numberDepth of the section</param>
+        /// <returns>the newly added Section</returns>
+        public virtual Section AddSection(float indentation, string title, int numberDepth) {
+            return AddSection(indentation, new Paragraph(title), numberDepth);
+        }
+    
+        /**
+         * Adds a Section to this Section and returns it.
+         *
+         * @param    title        the title of the new section
+         * @param    numberDepth    the numberDepth of the section
+         */
+        /// <summary>
+        /// Adds a Section to this Section and returns it.
+        /// </summary>
+        /// <param name="title">the title of the new section</param>
+        /// <param name="numberDepth">the numberDepth of the section</param>
+        /// <returns>the newly added Section</returns>
+        public virtual Section AddSection(string title, int numberDepth) {
+            return AddSection(new Paragraph(title), numberDepth);
+        }
+    
+        /// <summary>
+        /// Adds a Section to this Section and returns it.
+        /// </summary>
+        /// <param name="indentation">the indentation of the new section</param>
+        /// <param name="title">the title of the new section</param>
+        /// <returns>the newly added Section</returns>
+        public virtual Section AddSection(float indentation, string title) {
+            return AddSection(indentation, new Paragraph(title));
+        }
+    
+        /// <summary>
+        /// Adds a Section to this Section and returns it.
+        /// </summary>
+        /// <param name="title">the title of the new section</param>
+        /// <returns>the newly added Section</returns>
+        public virtual Section AddSection(string title) {
+            return AddSection(new Paragraph(title));
+        }
+    
+        // public methods
+    
+        /// <summary>
+        /// Alters the attributes of this Section.
+        /// </summary>
+        /// <param name="attributes">the attributes</param>
+        public void Set(Properties attributes) {
+            string value;
+            if ((value = attributes.Remove(ElementTags.NUMBERDEPTH)) != null) {
+                NumberDepth = int.Parse(value);
+            }
+            if ((value = attributes.Remove(ElementTags.INDENT)) != null) {
+                Indentation = float.Parse(value, System.Globalization.NumberFormatInfo.InvariantInfo);
+            }
+            if ((value = attributes.Remove(ElementTags.INDENTATIONLEFT)) != null) {
+                IndentationLeft = float.Parse(value, System.Globalization.NumberFormatInfo.InvariantInfo);
+            }
+            if ((value = attributes.Remove(ElementTags.INDENTATIONRIGHT)) != null) {
+                IndentationRight = float.Parse(value, System.Globalization.NumberFormatInfo.InvariantInfo);
+            }
+        }
+    
+        /// <summary>
+        /// Get/set the title of this section
+        /// </summary>
+        /// <value>a Paragraph</value>
+        public Paragraph Title {
+            get {
+                return ConstructTitle(title, numbers, numberDepth, numberStyle);
+            }
+            
+            set {
+                this.title = value;
+            }
+        }
+
+        /**
+        * Sets the style for numbering sections.
+        * Possible values are NUMBERSTYLE_DOTTED: 1.2.3. (the default)
+        * or NUMBERSTYLE_DOTTED_WITHOUT_FINAL_DOT: 1.2.3
+        * @since    iText 2.0.8
+        */
+        public int NumberStyle {
+            set {
+                numberStyle = value;
+            }
+            get {
+                return numberStyle;
+            }
+        }
+        
+        /**
+        * Constructs a Paragraph that will be used as title for a Section or Chapter.
+        * @param    title   the title of the section
+        * @param    numbers a list of sectionnumbers
+        * @param    numberDepth how many numbers have to be shown
+        * @param    numberStyle the numbering style
+        * @return   a Paragraph object
+        * @since    iText 2.0.8
+        */
+        public static Paragraph ConstructTitle(Paragraph title, ArrayList numbers, int numberDepth, int numberStyle) {
+            if (title == null) {
+                return null;
+            }
+            int depth = Math.Min(numbers.Count, numberDepth);
+            if (depth < 1) {
+                return title;
+            }
+            StringBuilder buf = new StringBuilder(" ");
+            for (int i = 0; i < depth; i++) {
+                buf.Insert(0, ".");
+                buf.Insert(0, (int)numbers[i]);
+            }
+            if (numberStyle == NUMBERSTYLE_DOTTED_WITHOUT_FINAL_DOT) {
+                buf.Remove(buf.Length - 2, 1);
+            }
+            Paragraph result = new Paragraph(title);
+            result.Insert(0, new Chunk(buf.ToString(), title.Font));
+            return result;
+        }
+
+        // methods to retrieve information
+    
+        /// <summary>
+        /// Checks if this object is a Chapter.
+        /// </summary>
+        /// <returns>
+        /// true if it is a Chapter,
+        /// false if it is a Section
+        /// </returns>
+        public bool IsChapter() {
+            return Type == Element.CHAPTER;
+        }
+    
+        /// <summary>
+        /// Checks if this object is a Section.
+        /// </summary>
+        /// <returns>
+        /// true if it is a Section,
+        /// false if it is a Chapter.
+        /// </returns>
+        public bool IsSection() {
+            return Type == Element.SECTION;
+        }
+    
+        /// <summary>
+        /// Get/set the numberdepth of this Section.
+        /// </summary>
+        /// <value>a int</value>
+        public int NumberDepth {
+            get {
+                return numberDepth;
+            }
+
+            set {
+                this.numberDepth = value;
+            }
+        }
+    
+        /// <summary>
+        /// Get/set the indentation of this Section on the left side.
+        /// </summary>
+        /// <value>the indentation</value>
+        public float IndentationLeft {
+            get {
+                return indentationLeft;
+            }
+
+            set {
+                indentationLeft = value;
+            }
+        }
+    
+        /// <summary>
+        /// Get/set the indentation of this Section on the right side.
+        /// </summary>
+        /// <value>the indentation</value>
+        public float IndentationRight {
+            get {
+                return indentationRight;
+            }
+
+            set {
+                indentationRight = value;
+            }
+        }
+    
+        /// <summary>
+        /// Get/set the indentation of the content of this Section.
+        /// </summary>
+        /// <value>the indentation</value>
+        public float Indentation {
+            get {
+                return indentation;
+            }
+
+            set {
+                indentation = value;
+            }
+        }
+    
+        /// <summary>
+        /// Returns the depth of this section.
+        /// </summary>
+        /// <value>the depth</value>
+        public int Depth {
+            get {
+                return numbers.Count;
+            }
+        }
+    
+        /// <summary>
+        /// Checks if a given tag corresponds with a title tag for this object.
+        /// </summary>
+        /// <param name="tag">the given tag</param>
+        /// <returns>true if the tag corresponds</returns>
+        public static bool IsTitle(string tag) {
+            return ElementTags.TITLE.Equals(tag);
+        }
+    
+        /// <summary>
+        /// Checks if a given tag corresponds with this object.
+        /// </summary>
+        /// <param name="tag">the given tag</param>
+        /// <returns>true if the tag corresponds</returns>
+        public static bool IsTag(string tag) {
+            return ElementTags.SECTION.Equals(tag);
+        }
+    
+        /// <summary>
+        /// Get/set the bookmark
+        /// </summary>
+        /// <value>a bool</value>
+        public bool BookmarkOpen {
+            get {
+                return bookmarkOpen;
+            }
+
+            set {
+                this.bookmarkOpen = value;
+            }
+        }
+
+        /**
+        * Gets the bookmark title.
+        * @return the bookmark title
+        */    
+        public Paragraph GetBookmarkTitle() {
+            if (bookmarkTitle == null)
+                return Title;
+            else
+                return new Paragraph(bookmarkTitle);
+        }
+        
+        /**
+        * Sets the bookmark title. The bookmark title is the same as the section title but
+        * can be changed with this method.
+        * @param bookmarkTitle the bookmark title
+        */    
+        public String BookmarkTitle {
+            set {
+                this.bookmarkTitle = value;
+            }
+        }
+
+        public override string ToString() {
+            return base.ToString();
+        }
+
+        public virtual bool TriggerNewPage {
+            get {
+                return triggerNewPage && notAddedYet;
+            }
+            set {
+                triggerNewPage = value;
+            }
+        }
+
+        /**
+        * Changes the Chapter number.
+        */
+        public void SetChapterNumber(int number) {
+            numbers[numbers.Count - 1] = number;
+            foreach (Object s in this) {
+                if (s is Section) {
+                    ((Section)s).SetChapterNumber(number);
+                }
+            }
+        }
+
+        /**
+        * Indicates if this is the first time the section is added.
+        * @since   iText2.0.8
+        * @return  true if the section wasn't added yet
+        */
+        public bool NotAddedYet {
+            get {
+                return notAddedYet;
+            }
+            set {
+                notAddedYet = value;
+            }
+        }
+
+        /**
+        * @see com.lowagie.text.LargeElement#isAddedCompletely()
+        * @since   iText 2.0.8
+        */
+        protected bool AddedCompletely {
+            get {
+                return addedCompletely;
+            }
+            set {
+                addedCompletely = value;
+            }
+        }
+        
+        /**
+        * @since   iText 2.0.8
+        * @see com.lowagie.text.LargeElement#flushContent()
+        */
+        public void FlushContent() {
+            NotAddedYet = false;
+            title = null;
+            for (int k = 0; k < Count; ++k) {
+                IElement element = (IElement)this[k];
+                if (element is Section) {
+                    Section s = (Section)element;
+                    if (!s.ElementComplete && Count == 1) {
+                        s.FlushContent();
+                        return;
+                    }
+                    else {
+                        s.AddedCompletely = true;
+                    }
+                }
+                this.RemoveAt(k);
+                --k;
+            }
+        }
+
+        /**
+        * @since   iText 2.0.8
+        * @see com.lowagie.text.LargeElement#isComplete()
+        */
+        public bool ElementComplete {
+            get {
+                return complete;
+            }
+            set {
+                complete = value;
+            }
+        }
+
+        /**
+        * Adds a new page to the section.
+        * @since   2.1.1
+        */
+        public void NewPage() {
+            this.Add(Chunk.NEXTPAGE);
+        }
+    }
+}

src/core/iTextSharp/text/SimpleCell.cs

@@ -0,0 +1,453 @@
+using System;
+using System.Collections;
+using iTextSharp.text.pdf;
+
+namespace iTextSharp.text
+{
+    /// <summary>
+    /// Summary description for SimpleCell.
+    /// </summary>
+    public class SimpleCell : Rectangle, IPdfPCellEvent, ITextElementArray {
+
+        /** the CellAttributes object represents a row. */
+        public new const bool ROW = true;
+        /** the CellAttributes object represents a cell. */
+        public new const bool CELL = false;
+        /** the content of the Cell. */
+        private ArrayList content = new ArrayList();
+        /** the width of the Cell. */
+        private float width = 0f;
+        /** the widthpercentage of the Cell. */
+        private float widthpercentage = 0f;
+        /** an extra spacing variable */
+        private float spacing_left = float.NaN;
+        /** an extra spacing variable */
+        private float spacing_right = float.NaN;
+        /** an extra spacing variable */
+        private float spacing_top = float.NaN;
+        /** an extra spacing variable */
+        private float spacing_bottom = float.NaN;
+        /** an extra padding variable */
+        private float padding_left = float.NaN;
+        /** an extra padding variable */
+        private float padding_right = float.NaN;
+        /** an extra padding variable */
+        private float padding_top = float.NaN;
+        /** an extra padding variable */
+        private float padding_bottom = float.NaN;
+        /** the colspan of a Cell */
+        private int colspan = 1;
+        /** horizontal alignment inside the Cell. */
+        private int horizontalAlignment = Element.ALIGN_UNDEFINED;
+        /** vertical alignment inside the Cell. */
+        private int verticalAlignment = Element.ALIGN_UNDEFINED;
+        /** indicates if these are the attributes of a single Cell (false) or a group of Cells (true). */
+        private bool cellgroup = false;
+        /** Indicates that the largest ascender height should be used to determine the
+        * height of the first line.  Note that this only has an effect when rendered
+        * to PDF.  Setting this to true can help with vertical alignment problems. */
+        protected bool useAscender = false;
+        /** Indicates that the largest descender height should be added to the height of
+        * the last line (so characters like y don't dip into the border).   Note that
+        * this only has an effect when rendered to PDF. */
+        protected bool useDescender = false;
+        /**
+        * Adjusts the cell contents to compensate for border widths.  Note that
+        * this only has an effect when rendered to PDF.
+        */
+        protected bool useBorderPadding;
+        
+        /**
+        * A CellAttributes object is always constructed without any dimensions.
+        * Dimensions are defined after creation.
+        * @param row only true if the CellAttributes object represents a row.
+        */
+        public SimpleCell(bool row) : base (0f, 0f, 0f, 0f) {
+            cellgroup = row;
+            Border = BOX;
+        }
+        
+        /**
+        * Adds content to this object.
+        * @param element
+        * @throws BadElementException
+        */
+        public void AddElement(IElement element) {
+            if (cellgroup) {
+                if (element is SimpleCell) {
+                    if (((SimpleCell)element).Cellgroup) {
+                        throw new BadElementException("You can't add one row to another row.");
+                    }
+                    content.Add(element);
+                    return;
+                }
+                else {
+                    throw new BadElementException("You can only add cells to rows, no objects of type " + element.GetType().ToString());
+                }
+            }
+            if (element.Type == Element.PARAGRAPH
+                    || element.Type == Element.PHRASE
+                    || element.Type == Element.ANCHOR
+                    || element.Type == Element.CHUNK
+                    || element.Type == Element.LIST
+                    || element.Type == Element.MARKED
+                    || element.Type == Element.JPEG
+    				|| element.Type == Element.JPEG2000
+                    || element.Type == Element.IMGRAW
+                    || element.Type == Element.IMGTEMPLATE) {
+                content.Add(element);
+            }
+            else {
+                throw new BadElementException("You can't add an element of type " + element.GetType().ToString() + " to a SimpleCell.");
+            }
+        }
+        
+        /**
+        * Creates a Cell with these attributes.
+        * @param rowAttributes
+        * @return a cell based on these attributes.
+        * @throws BadElementException
+        */
+        public Cell CreateCell(SimpleCell rowAttributes) {
+            Cell cell = new Cell();
+            cell.CloneNonPositionParameters(rowAttributes);
+            cell.SoftCloneNonPositionParameters(this);
+            cell.Colspan = colspan;
+            cell.HorizontalAlignment = horizontalAlignment;
+            cell.VerticalAlignment = verticalAlignment;
+            cell.UseAscender = useAscender;
+            cell.UseBorderPadding = useBorderPadding;
+            cell.UseDescender = useDescender;
+            foreach (IElement element in content) {
+                cell.AddElement(element);
+            }
+            return cell;
+        }
+        
+        /**
+        * Creates a PdfPCell with these attributes.
+        * @param rowAttributes
+        * @return a PdfPCell based on these attributes.
+        */
+        public PdfPCell CreatePdfPCell(SimpleCell rowAttributes) {
+            PdfPCell cell = new PdfPCell();
+            cell.Border = NO_BORDER;
+            SimpleCell tmp = new SimpleCell(CELL);
+            tmp.Spacing_left = spacing_left;
+            tmp.Spacing_right = spacing_right;
+            tmp.Spacing_top = spacing_top;
+            tmp.Spacing_bottom = spacing_bottom;
+            tmp.CloneNonPositionParameters(rowAttributes);
+            tmp.SoftCloneNonPositionParameters(this);
+            cell.CellEvent = tmp;
+            cell.HorizontalAlignment = rowAttributes.horizontalAlignment;
+            cell.VerticalAlignment = rowAttributes.verticalAlignment;
+            cell.UseAscender = rowAttributes.useAscender;
+            cell.UseBorderPadding = rowAttributes.useBorderPadding;
+            cell.UseDescender = rowAttributes.useDescender;
+            cell.Colspan = colspan;
+            if (horizontalAlignment != Element.ALIGN_UNDEFINED)
+                cell.HorizontalAlignment = horizontalAlignment;
+            if (verticalAlignment != Element.ALIGN_UNDEFINED)
+                cell.VerticalAlignment = verticalAlignment;
+            if (useAscender)
+                cell.UseAscender = useAscender;
+            if (useBorderPadding)
+                cell.UseBorderPadding = useBorderPadding;
+            if (useDescender)
+                cell.UseDescender = useDescender;
+            float p;
+            float sp_left = spacing_left;
+            if (float.IsNaN(sp_left)) sp_left = 0f;
+            float sp_right = spacing_right;
+            if (float.IsNaN(sp_right)) sp_right = 0f;
+            float sp_top = spacing_top;
+            if (float.IsNaN(sp_top)) sp_top = 0f;
+            float sp_bottom = spacing_bottom;
+            if (float.IsNaN(sp_bottom)) sp_bottom = 0f;
+            p = padding_left;
+            if (float.IsNaN(p)) p = 0f; 
+            cell.PaddingLeft = p + sp_left;
+            p = padding_right;
+            if (float.IsNaN(p)) p = 0f; 
+            cell.PaddingRight = p + sp_right;
+            p = padding_top;
+            if (float.IsNaN(p)) p = 0f; 
+            cell.PaddingTop = p + sp_top;
+            p = padding_bottom;
+            if (float.IsNaN(p)) p = 0f; 
+            cell.PaddingBottom = p + sp_bottom;
+            foreach (IElement element in content) {
+                cell.AddElement(element);
+            }
+            return cell;
+        }
+        
+        /**
+        * @param rectangle
+        * @param spacing
+        * @return a rectangle
+        */
+        public static SimpleCell GetDimensionlessInstance(Rectangle rectangle, float spacing) {
+            SimpleCell cell = new SimpleCell(CELL);
+            cell.CloneNonPositionParameters(rectangle);
+            cell.Spacing = spacing * 2;
+            return cell;
+        }
+
+        /**
+        * @see com.lowagie.text.pdf.PdfPCellEvent#cellLayout(com.lowagie.text.pdf.PdfPCell, com.lowagie.text.Rectangle, com.lowagie.text.pdf.PdfContentByte[])
+        */
+        public void CellLayout(PdfPCell cell, Rectangle position, PdfContentByte[] canvases) {
+            float sp_left = spacing_left;
+            if (float.IsNaN(sp_left)) sp_left = 0f;
+            float sp_right = spacing_right;
+            if (float.IsNaN(sp_right)) sp_right = 0f;
+            float sp_top = spacing_top;
+            if (float.IsNaN(sp_top)) sp_top = 0f;
+            float sp_bottom = spacing_bottom;
+            if (float.IsNaN(sp_bottom)) sp_bottom = 0f;
+            Rectangle rect = new Rectangle(position.GetLeft(sp_left), position.GetBottom(sp_bottom), position.GetRight(sp_right), position.GetTop(sp_top));
+            rect.CloneNonPositionParameters(this);
+            canvases[PdfPTable.BACKGROUNDCANVAS].Rectangle(rect);
+            rect.BackgroundColor = null;
+            canvases[PdfPTable.LINECANVAS].Rectangle(rect);
+        }
+        
+        /** Sets the padding parameters if they are undefined. 
+        * @param padding*/
+        public float Padding {
+            set {
+                if (float.IsNaN(padding_right)) {
+                    Padding_right = value;
+                }
+                if (float.IsNaN(padding_left)) {
+                    Padding_left = value;
+                }
+                if (float.IsNaN(padding_bottom)) {
+                    Padding_bottom = value;
+                }
+                if (float.IsNaN(padding_top)) {
+                    Padding_top = value;
+                }
+            }
+        }
+        
+        /**
+        * @return Returns the colspan.
+        */
+        public int Colspan {
+            get {
+                return colspan;
+            }
+            set {
+                if (value > 0) this.colspan = value;
+            }
+        }
+
+        /**
+        * @param padding_bottom The padding_bottom to set.
+        */
+        public float Padding_bottom {
+            get {
+                return padding_bottom;
+            }
+            set {
+                padding_bottom = value;
+            }
+        }
+
+        public float Padding_left {
+            get {
+                return padding_left;
+            }
+            set {
+                padding_left = value;
+            }
+        }
+
+        public float Padding_right {
+            get {
+                return padding_right;
+            }
+            set {
+                padding_right = value;
+            }
+        }
+
+        public float Padding_top {
+            get {
+                return padding_top;
+            }
+            set {
+                padding_top = value;
+            }
+        }
+
+        /**
+        * @return Returns the spacing.
+        */
+        public float Spacing {
+            set {
+                this.spacing_left = value;
+                this.spacing_right = value;
+                this.spacing_top = value;
+                this.spacing_bottom = value;
+            }
+            
+        }
+        
+        public float Spacing_top {
+            get {
+                return spacing_top;
+            }
+            set {
+                spacing_top = value;
+            }
+        }
+
+        public float Spacing_bottom {
+            get {
+                return spacing_bottom;
+            }
+            set {
+                spacing_bottom = value;
+            }
+        }
+
+        public float Spacing_left {
+            get {
+                return spacing_left;
+            }
+            set {
+                spacing_left = value;
+            }
+        }
+
+        public float Spacing_right {
+            get {
+                return spacing_right;
+            }
+            set {
+                spacing_right = value;
+            }
+        }
+
+        /**
+        * @return Returns the cellgroup.
+        */
+        public bool Cellgroup {
+            get {
+                return cellgroup;
+            }
+            set {
+                cellgroup = value;
+            }
+        }
+
+        /**
+        * @return Returns the horizontal alignment.
+        */
+        public int HorizontalAlignment {
+            get {
+                return horizontalAlignment;
+            }
+            set {
+                horizontalAlignment = value;
+            }
+        }
+
+        public int VerticalAlignment {
+            get {
+                return verticalAlignment;
+            }
+            set {
+                verticalAlignment = value;
+            }
+        }
+        /**
+        * @return Returns the width.
+        */
+        public new float Width {
+            get {
+                return width;
+            }
+            set {
+                width = value;
+            }
+        }
+
+        /**
+        * @return Returns the widthpercentage.
+        */
+        public float Widthpercentage {
+            get {
+                return widthpercentage;
+            }
+            set {
+                widthpercentage = value;
+            }
+        }
+
+        /**
+        * @return Returns the useAscender.
+        */
+        public bool UseAscender {
+            get {
+                return useAscender;
+            }
+            set {
+                useAscender = value;
+            }
+        }
+
+        public bool UseDescender {
+            get {
+                return useDescender;
+            }
+            set {
+                useDescender = value;
+            }
+        }
+        /**
+        * @return Returns the useBorderPadding.
+        */
+        public bool UseBorderPadding {
+            get {
+                return useBorderPadding;
+            }
+            set {
+                useBorderPadding = value;
+            }
+        }
+        
+        /**
+        * @return Returns the content.
+        */
+        internal ArrayList Content {
+            get {
+                return content;
+            }
+        }
+
+        /**
+        * @see com.lowagie.text.TextElementArray#add(java.lang.Object)
+        */
+        public bool Add(Object o) {
+            try {
+                AddElement((IElement)o);
+                return true;
+            }
+            catch (InvalidCastException) {
+                return false;
+            }
+        }
+
+        public override int Type {
+            get {
+                return Element.CELL;
+            }
+        }
+
+    }
+}

src/core/iTextSharp/text/SimpleTable.cs

@@ -0,0 +1,302 @@
+using System;
+using System.Collections;
+using iTextSharp.text.pdf;
+
+namespace iTextSharp.text
+{
+        /// <summary>
+        /// Summary description for SimpleTable.
+        /// </summary>
+    public class SimpleTable : Rectangle, IPdfPTableEvent, ITextElementArray {
+
+        /** the content of a Table. */
+        private ArrayList content = new ArrayList();
+        /** the width of the Table. */
+        private float width = 0f;
+        /** the widthpercentage of the Table. */
+        private float widthpercentage = 0f;
+        /** the spacing of the Cells. */
+        private float cellspacing;
+        /** the padding of the Cells. */
+        private float cellpadding;
+        /** the alignment of the table. */
+        private int alignment;
+        
+        /**
+        * A RectangleCell is always constructed without any dimensions.
+        * Dimensions are defined after creation.
+        */
+        public SimpleTable() : base(0f, 0f, 0f, 0f) {
+            Border = BOX;
+            BorderWidth = 2f;
+        }
+        
+        /**
+        * Adds content to this object.
+        * @param element
+        * @throws BadElementException
+        */
+        public void AddElement(SimpleCell element) {
+            if (!element.Cellgroup) {
+                throw new BadElementException("You can't add cells to a table directly, add them to a row first.");
+            }
+            content.Add(element);
+        }
+        
+        /**
+        * Creates a Table object based on this TableAttributes object.
+        * @return a com.lowagie.text.Table object
+        * @throws BadElementException
+        */
+        public Table CreateTable() {
+            if (content.Count == 0) throw new BadElementException("Trying to create a table without rows.");
+            SimpleCell rowx = (SimpleCell)content[0];
+            int columns = 0;
+            foreach (SimpleCell cell in rowx.Content) {
+                columns += cell.Colspan;
+            }
+            float[] widths = new float[columns];
+            float[] widthpercentages = new float[columns];
+            Table table = new Table(columns);
+            table.Alignment = alignment;
+            table.Spacing = cellspacing;
+            table.Padding = cellpadding;
+            table.CloneNonPositionParameters(this);
+            int pos;
+            foreach (SimpleCell row in content) {
+                pos = 0;
+                foreach (SimpleCell cell in row.Content) {
+                    table.AddCell(cell.CreateCell(row));
+                    if (cell.Colspan == 1) {
+                        if (cell.Width > 0) widths[pos] = cell.Width;
+                        if (cell.Widthpercentage > 0) widthpercentages[pos] = cell.Widthpercentage;
+                    }
+                    pos += cell.Colspan;
+                }
+            }
+            float sumWidths = 0f;
+            for (int i = 0; i < columns; i++) {
+                if (widths[i] == 0) {
+                    sumWidths = 0;
+                    break;
+                }
+                sumWidths += widths[i];
+            }
+            if (sumWidths > 0) {
+                table.Width = sumWidths;
+                table.Locked = true;
+                table.Widths = widths;
+            }
+            else {
+                for (int i = 0; i < columns; i++) {
+                    if (widthpercentages[i] == 0) {
+                        sumWidths = 0;
+                        break;
+                    }
+                    sumWidths += widthpercentages[i];
+                }
+                if (sumWidths > 0) {
+                    table.Widths = widthpercentages;
+                }
+            }
+            if (width > 0) {
+                table.Width = width;
+                table.Locked = true;
+            }
+            else if (widthpercentage > 0) {
+                table.Width = widthpercentage;
+            }
+            return table;
+        }
+        
+        /**
+        * Creates a PdfPTable object based on this TableAttributes object.
+        * @return a com.lowagie.text.pdf.PdfPTable object
+        * @throws DocumentException
+        */
+        public PdfPTable CreatePdfPTable() {
+            if (content.Count == 0) throw new BadElementException("Trying to create a table without rows.");
+            SimpleCell rowx = (SimpleCell)content[0];
+            int columns = 0;
+            foreach (SimpleCell cell in rowx.Content) {
+                columns += cell.Colspan;
+            }
+            float[] widths = new float[columns];
+            float[] widthpercentages = new float[columns];
+            PdfPTable table = new PdfPTable(columns);
+            table.TableEvent = this;
+            table.HorizontalAlignment = alignment;
+            int pos;
+            foreach (SimpleCell row in content) {
+                pos = 0;
+                foreach (SimpleCell cell in row.Content) {
+                    if (float.IsNaN(cell.Spacing_left))    {
+                        cell.Spacing_left = cellspacing / 2f;
+                    }
+                    if (float.IsNaN(cell.Spacing_right))   {
+                        cell.Spacing_right = cellspacing / 2f;
+                    }
+                    if (float.IsNaN(cell.Spacing_top)) {
+                        cell.Spacing_top = cellspacing / 2f;
+                    }
+                    if (float.IsNaN(cell.Spacing_bottom))  {
+                        cell.Spacing_bottom = cellspacing / 2f;
+                    }
+                    cell.Padding = cellpadding;
+                    table.AddCell(cell.CreatePdfPCell(row));
+                    if (cell.Colspan == 1) {
+                        if (cell.Width > 0) widths[pos] = cell.Width;
+                        if (cell.Widthpercentage > 0) widthpercentages[pos] = cell.Widthpercentage;
+                    }
+                    pos += cell.Colspan;
+                }
+            }
+            float sumWidths = 0f;
+            for (int i = 0; i < columns; i++) {
+                if (widths[i] == 0) {
+                    sumWidths = 0;
+                    break;
+                }
+                sumWidths += widths[i];
+            }
+            if (sumWidths > 0) {
+                table.TotalWidth = sumWidths;
+                table.SetWidths(widths);
+            }
+            else {
+                for (int i = 0; i < columns; i++) {
+                    if (widthpercentages[i] == 0) {
+                        sumWidths = 0;
+                        break;
+                    }
+                    sumWidths += widthpercentages[i];
+                }
+                if (sumWidths > 0) {
+                    table.SetWidths(widthpercentages);
+                }
+            }
+            if (width > 0) {
+                table.TotalWidth = width;
+            }
+            if (widthpercentage > 0) {
+                table.WidthPercentage = widthpercentage;
+            }
+            return table;
+        }
+        
+        /**
+        * @param rectangle
+        * @param spacing
+        * @return a rectangle
+        */
+        public static SimpleTable GetDimensionlessInstance(Rectangle rectangle, float spacing) {
+            SimpleTable ev = new SimpleTable();
+            ev.CloneNonPositionParameters(rectangle);
+            ev.Cellspacing = spacing;
+            return ev;
+        }
+        
+        /**
+        * @see com.lowagie.text.pdf.PdfPTableEvent#tableLayout(com.lowagie.text.pdf.PdfPTable, float[][], float[], int, int, com.lowagie.text.pdf.PdfContentByte[])
+         */
+        public void TableLayout(PdfPTable table, float[][] widths, float[] heights, int headerRows, int rowStart, PdfContentByte[] canvases) {
+            float[] width = widths[0];
+            Rectangle rect = new Rectangle(width[0], heights[heights.Length - 1], width[width.Length - 1], heights[0]);
+            rect.CloneNonPositionParameters(this);
+            int bd = rect.Border;
+            rect.Border = Rectangle.NO_BORDER;
+            canvases[PdfPTable.BACKGROUNDCANVAS].Rectangle(rect);
+            rect.Border = bd;
+            rect.BackgroundColor = null;
+            canvases[PdfPTable.LINECANVAS].Rectangle(rect);
+        }
+        
+        /**
+        * @return Returns the cellpadding.
+        */
+        public float Cellpadding {
+            get {
+                return cellpadding;
+            }
+            set {
+                cellpadding = value;
+            }
+        }
+
+        /**
+        * @return Returns the cellspacing.
+        */
+        public float Cellspacing {
+            get {
+                return cellspacing;
+            }
+            set {
+                cellspacing = value;
+            }
+        }
+        
+        /**
+        * @return Returns the alignment.
+        */
+        public int Alignment {
+            get {
+                return alignment;
+            }
+            set {
+                alignment = value;
+            }
+        }
+
+        /**
+        * @return Returns the width.
+        */
+        public override float Width {
+            get {
+                return width;
+            }
+            set {
+                width = value;
+            }
+        }
+        /**
+        * @return Returns the widthpercentage.
+        */
+        public float Widthpercentage {
+            get {
+                return widthpercentage;
+            }
+            set {
+                widthpercentage = value;
+            }
+        }
+        /**
+        * @see com.lowagie.text.Element#type()
+        */
+        public override int Type {
+            get {
+                return Element.TABLE;
+            }
+        }
+
+        /**
+        * @see com.lowagie.text.Element#isNestable()
+        * @since   iText 2.0.8
+        */
+        public override bool IsNestable() {
+            return true;
+        }
+
+        /**
+        * @see com.lowagie.text.TextElementArray#add(java.lang.Object)
+        */
+        public bool Add(Object o) {
+            try {
+                AddElement((SimpleCell)o);
+                return true;
+            }
+            catch (InvalidCastException) {
+                return false;
+            }
+        }
+    }
+}

src/core/iTextSharp/text/SpecialSymbol.cs

@@ -0,0 +1,202 @@
+using System;
+
+/*
+ * $Id: SpecialSymbol.cs,v 1.4 2008/05/13 11:25:13 psoares33 Exp $
+ * 
+ *
+ * Copyright 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+
+namespace iTextSharp.text
+{
+    public class SpecialSymbol {
+        
+    /**
+    * Returns the first occurrence of a special symbol in a <CODE>String</CODE>.
+    *
+    * @param    string        a <CODE>String</CODE>
+    * @return    an index of -1 if no special symbol was found
+    */
+        
+        public static int Index(string str) {
+            int length = str.Length;
+            for (int i = 0; i < length; i++) {
+                if (GetCorrespondingSymbol(str[i]) != ' ') {
+                    return i;
+                }
+            }
+            return -1;
+        }
+        
+    /**
+    * Gets a chunk with a symbol character.
+    * @param c a character that has to be changed into a symbol
+    * @param font Font if there is no SYMBOL character corresponding with c
+    * @return a SYMBOL version of a character
+    */
+        
+        public static Chunk Get(char c, Font font) {
+            char greek = SpecialSymbol.GetCorrespondingSymbol(c);
+            if (greek == ' ') {
+                return new Chunk(c.ToString(), font);
+            }
+            Font symbol = new Font(Font.SYMBOL, font.Size, font.Style, font.Color);
+            return new Chunk(greek.ToString(), symbol);
+        }
+        
+    /**
+    * Looks for the corresponding symbol in the font Symbol.
+    *
+    * @param    c    the original ASCII-char
+    * @return    the corresponding symbol in font Symbol
+    */
+        
+        public static char GetCorrespondingSymbol(char c) {
+            switch (c) {
+                case (char)913:
+                    return 'A'; // ALFA
+                case (char)914:
+                    return 'B'; // BETA
+                case (char)915:
+                    return 'G'; // GAMMA
+                case (char)916:
+                    return 'D'; // DELTA
+                case (char)917:
+                    return 'E'; // EPSILON
+                case (char)918:
+                    return 'Z'; // ZETA
+                case (char)919:
+                    return 'H'; // ETA
+                case (char)920:
+                    return 'Q'; // THETA
+                case (char)921:
+                    return 'I'; // IOTA
+                case (char)922:
+                    return 'K'; // KAPPA
+                case (char)923:
+                    return 'L'; // LAMBDA
+                case (char)924:
+                    return 'M'; // MU
+                case (char)925:
+                    return 'N'; // NU
+                case (char)926:
+                    return 'X'; // XI
+                case (char)927:
+                    return 'O'; // OMICRON
+                case (char)928:
+                    return 'P'; // PI
+                case (char)929:
+                    return 'R'; // RHO
+                case (char)931:
+                    return 'S'; // SIGMA
+                case (char)932:
+                    return 'T'; // TAU
+                case (char)933:
+                    return 'U'; // UPSILON
+                case (char)934:
+                    return 'J'; // PHI
+                case (char)935:
+                    return 'C'; // CHI
+                case (char)936:
+                    return 'Y'; // PSI
+                case (char)937:
+                    return 'W'; // OMEGA
+                case (char)945:
+                    return 'a'; // alfa
+                case (char)946:
+                    return 'b'; // beta
+                case (char)947:
+                    return 'g'; // gamma
+                case (char)948:
+                    return 'd'; // delta
+                case (char)949:
+                    return 'e'; // epsilon
+                case (char)950:
+                    return 'z'; // zeta
+                case (char)951:
+                    return 'h'; // eta
+                case (char)952:
+                    return 'q'; // theta
+                case (char)953:
+                    return 'i'; // iota
+                case (char)954:
+                    return 'k'; // kappa
+                case (char)955:
+                    return 'l'; // lambda
+                case (char)956:
+                    return 'm'; // mu
+                case (char)957:
+                    return 'n'; // nu
+                case (char)958:
+                    return 'x'; // xi
+                case (char)959:
+                    return 'o'; // omicron
+                case (char)960:
+                    return 'p'; // pi
+                case (char)961:
+                    return 'r'; // rho
+                case (char)962:
+                    return 'V'; // sigma
+                case (char)963:
+                    return 's'; // sigma
+                case (char)964:
+                    return 't'; // tau
+                case (char)965:
+                    return 'u'; // upsilon
+                case (char)966:
+                    return 'j'; // phi
+                case (char)967:
+                    return 'c'; // chi
+                case (char)968:
+                    return 'y'; // psi
+                case (char)969:
+                    return 'w'; // omega
+                default:
+                        return ' ';
+            }
+        }
+    }
+}

src/core/iTextSharp/text/Utilities.cs

@@ -0,0 +1,267 @@
+using System;
+using System.util;
+using System.Collections;
+using System.Text;
+using System.IO;
+using iTextSharp.text.pdf;
+/*
+ * $Id: Utilities.cs,v 1.9 2008/05/13 11:25:13 psoares33 Exp $
+ * 
+ *
+ * Copyright 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+namespace iTextSharp.text {
+
+    /**
+    * A collection of convenience methods that were present in many different iText
+    * classes.
+    */
+
+    public class Utilities {
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="table"></param>
+        /// <returns></returns>
+        public static ICollection GetKeySet(Properties table) {
+            return (table == null) ? new Properties().Keys : table.Keys;
+        }
+
+        /**
+        * Utility method to extend an array.
+        * @param original the original array or <CODE>null</CODE>
+        * @param item the item to be added to the array
+        * @return a new array with the item appended
+        */    
+        public static Object[][] AddToArray(Object[][] original, Object[] item) {
+            if (original == null) {
+                original = new Object[1][];
+                original[0] = item;
+                return original;
+            }
+            else {
+                Object[][] original2 = new Object[original.Length + 1][];
+                Array.Copy(original, 0, original2, 0, original.Length);
+                original2[original.Length] = item;
+                return original2;
+            }
+        }
+
+	    /**
+	    * Checks for a true/false value of a key in a Properties object.
+	    * @param attributes
+	    * @param key
+	    * @return
+	    */
+	    public static bool CheckTrueOrFalse(Properties attributes, String key) {
+		    return Util.EqualsIgnoreCase("true", attributes[key]);
+	    }
+
+        /// <summary>
+        /// This method makes a valid URL from a given filename.
+        /// </summary>
+        /// <remarks>
+        /// 
+        /// </remarks>
+        /// <param name="filename">a given filename</param>
+        /// <returns>a valid URL</returns>
+        public static Uri ToURL(string filename) {
+            try {
+                return new Uri(filename);
+            }
+            catch {
+                return new Uri("file:///" + filename);
+            }
+        }
+    
+        /**
+        * Unescapes an URL. All the "%xx" are replaced by the 'xx' hex char value.
+        * @param src the url to unescape
+        * @return the eunescaped value
+        */    
+        public static String UnEscapeURL(String src) {
+            StringBuilder bf = new StringBuilder();
+            char[] s = src.ToCharArray();
+            for (int k = 0; k < s.Length; ++k) {
+                char c = s[k];
+                if (c == '%') {
+                    if (k + 2 >= s.Length) {
+                        bf.Append(c);
+                        continue;
+                    }
+                    int a0 = PRTokeniser.GetHex((int)s[k + 1]);
+                    int a1 = PRTokeniser.GetHex((int)s[k + 2]);
+                    if (a0 < 0 || a1 < 0) {
+                        bf.Append(c);
+                        continue;
+                    }
+                    bf.Append((char)(a0 * 16 + a1));
+                    k += 2;
+                }
+                else
+                    bf.Append(c);
+            }
+            return bf.ToString();
+        }
+        
+        private static byte[] skipBuffer = new byte[4096];
+
+        /// <summary>
+        /// This method is an alternative for the Stream.Skip()-method
+        /// that doesn't seem to work properly for big values of size.
+        /// </summary>
+        /// <param name="istr">the stream</param>
+        /// <param name="size">the number of bytes to skip</param>
+        public static void Skip(Stream istr, int size) {
+            while (size > 0) {
+                int r = istr.Read(skipBuffer, 0, Math.Min(skipBuffer.Length, size));
+                if (r <= 0)
+                    return;
+                size -= r;
+            }
+        }
+
+        /**
+        * Measurement conversion from millimeters to points.
+        * @param    value   a value in millimeters
+        * @return   a value in points
+        * @since    2.1.2
+        */
+        public static float MillimetersToPoints(float value) {
+            return InchesToPoints(MillimetersToInches(value));
+        }
+
+        /**
+        * Measurement conversion from millimeters to inches.
+        * @param    value   a value in millimeters
+        * @return   a value in inches
+        * @since    2.1.2
+        */
+        public static float MillimetersToInches(float value) {
+            return value / 25.4f;
+        }
+
+        /**
+        * Measurement conversion from points to millimeters.
+        * @param    value   a value in points
+        * @return   a value in millimeters
+        * @since    2.1.2
+        */
+        public static float PointsToMillimeters(float value) {
+            return InchesToMillimeters(PointsToInches(value));
+        }
+
+        /**
+        * Measurement conversion from points to inches.
+        * @param    value   a value in points
+        * @return   a value in inches
+        * @since    2.1.2
+        */
+        public static float PointsToInches(float value) {
+            return value / 72f;
+        }
+
+        /**
+        * Measurement conversion from inches to millimeters.
+        * @param    value   a value in inches
+        * @return   a value in millimeters
+        * @since    2.1.2
+        */
+        public static float InchesToMillimeters(float value) {
+            return value * 25.4f;
+        }
+
+        /**
+        * Measurement conversion from inches to points.
+        * @param    value   a value in inches
+        * @return   a value in points
+        * @since    2.1.2
+        */
+        public static float InchesToPoints(float value) {
+            return value * 72f;
+        }
+
+        public static bool IsSurrogateHigh(char c) {
+            return c >= '\ud800' && c <= '\udbff';
+        }
+
+        public static bool IsSurrogateLow(char c) {
+            return c >= '\udc00' && c <= '\udfff';
+        }
+
+        public static bool IsSurrogatePair(string text, int idx) {
+            if (idx < 0 || idx > text.Length - 2)
+                return false;
+            return IsSurrogateHigh(text[idx]) && IsSurrogateLow(text[idx + 1]);
+        }
+
+        public static bool IsSurrogatePair(char[] text, int idx) {
+            if (idx < 0 || idx > text.Length - 2)
+                return false;
+            return IsSurrogateHigh(text[idx]) && IsSurrogateLow(text[idx + 1]);
+        }
+
+        public static int ConvertToUtf32(char highSurrogate, char lowSurrogate) {
+             return (((highSurrogate - 0xd800) * 0x400) + (lowSurrogate - 0xdc00)) + 0x10000;
+        }
+
+        public static int ConvertToUtf32(char[] text, int idx) {
+             return (((text[idx] - 0xd800) * 0x400) + (text[idx + 1] - 0xdc00)) + 0x10000;
+        }
+
+        public static int ConvertToUtf32(string text, int idx) {
+             return (((text[idx] - 0xd800) * 0x400) + (text[idx + 1] - 0xdc00)) + 0x10000;
+        }
+
+        public static string ConvertFromUtf32(int codePoint) {
+            if (codePoint < 0x10000)
+                return Char.ToString((char)codePoint);
+            codePoint -= 0x10000;
+            return new string(new char[]{(char)((codePoint / 0x400) + 0xd800), (char)((codePoint % 0x400) + 0xdc00)});
+        }
+    }
+}

src/core/iTextSharp/text/ZapfDingbatsList.cs

@@ -0,0 +1,85 @@
+using System;
+
+namespace iTextSharp.text
+{
+    /**
+    * 
+    * A special-version of <CODE>LIST</CODE> whitch use zapfdingbats-letters.
+    * 
+    * @see com.lowagie.text.List
+    * @author Michael Niedermair and Bruno Lowagie
+    */
+    public class ZapfDingbatsList : List {
+        /**
+        * char-number in zapfdingbats
+        */
+        protected int zn;
+
+        /**
+        * Creates a ZapfDingbatsList
+        * 
+        * @param zn a char-number
+        */
+        public ZapfDingbatsList(int zn) : base(true) {
+            this.zn = zn;
+            float fontsize = symbol.Font.Size;
+            symbol.Font = FontFactory.GetFont(FontFactory.ZAPFDINGBATS, fontsize, Font.NORMAL);
+            postSymbol = " ";
+        }
+
+        /**
+        * Creates a ZapfDingbatsList
+        * 
+        * @param zn a char-number
+        * @param symbolIndent    indent
+        */
+        public ZapfDingbatsList(int zn, int symbolIndent) : base(true, symbolIndent) {
+            this.zn = zn;
+            float fontsize = symbol.Font.Size;
+            symbol.Font = FontFactory.GetFont(FontFactory.ZAPFDINGBATS, fontsize, Font.NORMAL);
+            postSymbol = " ";
+        }
+
+        /**
+        * set the char-number 
+        * @param zn a char-number
+        */
+        public int CharNumber {
+            set {
+                this.zn = value;
+            }
+            get {
+                return this.zn;
+            }
+        }
+
+        /**
+        * Adds an <CODE>Object</CODE> to the <CODE>List</CODE>.
+        *
+        * @param    o    the object to add.
+        * @return true if adding the object succeeded
+        */
+        public override bool Add(Object o) {
+            if (o is ListItem) {
+                ListItem item = (ListItem) o;
+                Chunk chunk = new Chunk(preSymbol, symbol.Font);
+                chunk.Append(((char)zn).ToString());
+                chunk.Append(postSymbol);
+                item.ListSymbol = chunk;
+                item.SetIndentationLeft(symbolIndent, autoindent);
+                item.IndentationRight = 0;
+                list.Add(item);
+                return true;
+            } else if (o is List) {
+                List nested = (List) o;
+                nested.IndentationLeft = nested.IndentationLeft + symbolIndent;
+                first--;
+                list.Add(nested);
+                return true;
+            } else if (o is String) {
+                return this.Add(new ListItem((string) o));
+            }
+            return false;
+        }
+    }
+}

src/core/iTextSharp/text/ZapfDingbatsNumberList.cs

@@ -0,0 +1,100 @@
+using System;
+
+namespace iTextSharp.text
+{
+    /**
+    * 
+    * A special-version of <CODE>LIST</CODE> whitch use zapfdingbats-numbers (1..10).
+    * 
+    * @see com.lowagie.text.List
+    * @version 2003-06-22
+    * @author Michael Niedermair
+    */
+    public class ZapfDingbatsNumberList : List {
+
+        /**
+        * which type
+        */
+        protected int type;
+
+        /**
+        * Creates a ZapdDingbatsNumberList
+        * @param type the type of list
+        * @param symbolIndent  indent
+        */
+        public ZapfDingbatsNumberList(int type) : base(true) {
+            this.type = type;
+            float fontsize = symbol.Font.Size;
+            symbol.Font = FontFactory.GetFont(FontFactory.ZAPFDINGBATS, fontsize, Font.NORMAL);
+            postSymbol = " ";
+        }
+
+        /**
+        * Creates a ZapdDingbatsNumberList
+        * @param type the type of list
+        * @param symbolIndent    indent
+        */
+        public ZapfDingbatsNumberList(int type, int symbolIndent) : base(true, symbolIndent) {
+            this.type = type;
+            float fontsize = symbol.Font.Size;
+            symbol.Font = FontFactory.GetFont(FontFactory.ZAPFDINGBATS, fontsize, Font.NORMAL);
+            postSymbol = " ";
+        }
+
+        /**
+        * get the type
+        *
+        * @return    char-number
+        */
+        public int NumberType {
+            get {
+                return type;
+            }
+            set {
+                type = value;
+            }
+        }
+
+        /**
+        * Adds an <CODE>Object</CODE> to the <CODE>List</CODE>.
+        *
+        * @param    o    the object to add.
+        * @return true if adding the object succeeded
+        */
+        public override bool Add(Object o) {
+            if (o is ListItem) {
+                ListItem item = (ListItem) o;
+                Chunk chunk = new Chunk(preSymbol, symbol.Font);
+                switch (type ) {
+                    case 0:
+                        chunk.Append(((char)(first + list.Count + 171)).ToString());
+                        break;
+                    case 1:
+                        chunk.Append(((char)(first + list.Count + 181)).ToString());
+                        break;
+                    case 2:
+                        chunk.Append(((char)(first + list.Count + 191)).ToString());
+                        break;
+                    default:
+                        chunk.Append(((char)(first + list.Count + 201)).ToString());
+                        break;
+                }
+                chunk.Append(postSymbol);
+                item.ListSymbol = chunk;
+                item.SetIndentationLeft(symbolIndent, autoindent);
+                item.IndentationRight = 0;
+                list.Add(item);
+                return true;
+            } else if (o is List) {
+                List nested = (List) o;
+                nested.IndentationLeft = nested.IndentationLeft + symbolIndent;
+                first--;
+                list.Add(nested);
+                return true;
+            } else if (o is String) {
+                return this.Add(new ListItem((string) o));
+            }
+            return false;
+        }
+    }
+}

src/core/iTextSharp/text/factories/ElementFactory.cs

@@ -0,0 +1,533 @@
+using System;
+using System.Collections;
+using System.util;
+using iTextSharp.text;
+using iTextSharp.text.html;
+using iTextSharp.text.factories;
+/*
+ * $Id: ElementFactory.cs,v 1.9 2008/05/13 11:25:14 psoares33 Exp $
+ * 
+ *
+ * Copyright 2007 by Bruno Lowagie.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+namespace iTextSharp.text.factories {
+
+    /**
+    * This class is able to create Element objects based on a list of properties.
+    */
+
+    public class ElementFactory {
+
+        public static Chunk GetChunk(Properties attributes) {
+            Chunk chunk = new Chunk();
+            
+            chunk.Font = FontFactory.GetFont(attributes);
+            String value;
+            
+            value = attributes[ElementTags.ITEXT];
+            if (value != null) {
+                chunk.Append(value);
+            }
+            value = attributes[ElementTags.LOCALGOTO];
+            if (value != null) {
+                chunk.SetLocalGoto(value);
+            }
+            value = attributes[ElementTags.REMOTEGOTO];
+            if (value != null) {
+                String page = attributes[ElementTags.PAGE];
+                if (page != null) {
+                    chunk.SetRemoteGoto(value, int.Parse(page));
+                }
+                else {
+                    String destination = attributes[ElementTags.DESTINATION];
+                    if (destination != null) {
+                        chunk.SetRemoteGoto(value, destination);
+                    }
+                }
+            }
+            value = attributes[ElementTags.LOCALDESTINATION];
+            if (value != null) {
+                chunk.SetLocalDestination(value);
+            }
+            value = attributes[ElementTags.SUBSUPSCRIPT];
+            if (value != null) {
+                chunk.SetTextRise(float.Parse(value, System.Globalization.NumberFormatInfo.InvariantInfo));
+            }
+            value = attributes[Markup.CSS_KEY_VERTICALALIGN];
+            if (value != null && value.EndsWith("%")) {
+                float p = float.Parse(value.Substring(0, value.Length - 1), System.Globalization.NumberFormatInfo.InvariantInfo) / 100f;
+                chunk.SetTextRise(p * chunk.Font.Size);
+            }
+            value = attributes[ElementTags.GENERICTAG];
+            if (value != null) {
+                chunk.SetGenericTag(value);
+            }
+            value = attributes[ElementTags.BACKGROUNDCOLOR];
+            if (value != null) {
+                chunk.SetBackground(Markup.DecodeColor(value));
+            }
+            return chunk;
+        }
+        
+        public static Phrase GetPhrase(Properties attributes) {
+            Phrase phrase = new Phrase();
+            phrase.Font = FontFactory.GetFont(attributes);
+            String value;
+            value = attributes[ElementTags.LEADING];
+            if (value != null) {
+                phrase.Leading = float.Parse(value, System.Globalization.NumberFormatInfo.InvariantInfo);
+            }
+            value = attributes[Markup.CSS_KEY_LINEHEIGHT];
+            if (value != null) {
+                phrase.Leading = Markup.ParseLength(value);
+            }
+            value = attributes[ElementTags.ITEXT];
+            if (value != null) {
+                Chunk chunk = new Chunk(value);
+                if ((value = attributes[ElementTags.GENERICTAG]) != null) {
+                    chunk.SetGenericTag(value);
+                }
+                phrase.Add(chunk);
+            }
+            return phrase;
+        }
+        
+        public static Anchor GetAnchor(Properties attributes) {
+            Anchor anchor = new Anchor(GetPhrase(attributes));
+            String value;
+            value = attributes[ElementTags.NAME];
+            if (value != null) {
+                anchor.Name = value;
+            }
+            value = (String)attributes.Remove(ElementTags.REFERENCE);
+            if (value != null) {
+                anchor.Reference = value;
+            }
+            return anchor;
+        }
+        
+        public static Paragraph GetParagraph(Properties attributes) {
+            Paragraph paragraph = new Paragraph(GetPhrase(attributes));
+            String value;
+            value = attributes[ElementTags.ALIGN];
+            if (value != null) {
+                paragraph.SetAlignment(value);
+            }
+            value = attributes[ElementTags.INDENTATIONLEFT];
+            if (value != null) {
+                paragraph.IndentationLeft = float.Parse(value, System.Globalization.NumberFormatInfo.InvariantInfo);
+            }
+            value = attributes[ElementTags.INDENTATIONRIGHT];
+            if (value != null) {
+                paragraph.IndentationRight = float.Parse(value, System.Globalization.NumberFormatInfo.InvariantInfo);
+            }
+            return paragraph;
+        }
+        
+        public static ListItem GetListItem(Properties attributes) {
+            ListItem item = new ListItem(GetParagraph(attributes));
+            return item;
+        }
+        
+        public static List GetList(Properties attributes) {
+            List list = new List();
+
+            list.Numbered = Utilities.CheckTrueOrFalse(attributes, ElementTags.NUMBERED);
+            list.Lettered = Utilities.CheckTrueOrFalse(attributes, ElementTags.LETTERED);
+            list.Lowercase = Utilities.CheckTrueOrFalse(attributes, ElementTags.LOWERCASE);
+            list.Autoindent = Utilities.CheckTrueOrFalse(attributes, ElementTags.AUTO_INDENT_ITEMS);
+            list.Alignindent = Utilities.CheckTrueOrFalse(attributes, ElementTags.ALIGN_INDENTATION_ITEMS);
+            
+            String value;
+            
+            value = attributes[ElementTags.FIRST];
+            if (value != null) {
+                char character = value[0];
+                if (char.IsLetter(character) ) {
+                    list.First = (int)character;
+                }
+                else {
+                    list.First = int.Parse(value);
+                }
+            }
+            
+            value = attributes[ElementTags.LISTSYMBOL];
+            if (value != null) {
+                list.ListSymbol = new Chunk(value, FontFactory.GetFont(attributes));
+            }
+            
+            value = attributes[ElementTags.INDENTATIONLEFT];
+            if (value != null) {
+                list.IndentationLeft = float.Parse(value, System.Globalization.NumberFormatInfo.InvariantInfo);
+            }
+            
+            value = attributes[ElementTags.INDENTATIONRIGHT];
+            if (value != null) {
+                list.IndentationRight = float.Parse(value, System.Globalization.NumberFormatInfo.InvariantInfo);
+            }
+            
+            value = attributes[ElementTags.SYMBOLINDENT];
+            if (value != null) {
+                list.SymbolIndent = float.Parse(value, System.Globalization.NumberFormatInfo.InvariantInfo);
+            }
+            
+            return list;
+        }
+
+        public static Cell GetCell(Properties attributes) {
+            Cell cell = new Cell();
+            String value;
+
+            cell.SetHorizontalAlignment(attributes[ElementTags.HORIZONTALALIGN]);
+            cell.SetVerticalAlignment(attributes[ElementTags.VERTICALALIGN]);
+            value = attributes[ElementTags.WIDTH];
+            if (value != null) {
+                cell.SetWidth(value);
+            }
+            value = attributes[ElementTags.COLSPAN];
+            if (value != null) {
+                cell.Colspan = int.Parse(value);
+            }
+            value = attributes[ElementTags.ROWSPAN];
+            if (value != null) {
+                cell.Rowspan = int.Parse(value);
+            }
+            value = attributes[ElementTags.LEADING];
+            if (value != null) {
+                cell.Leading = float.Parse(value, System.Globalization.NumberFormatInfo.InvariantInfo);
+            }
+            cell.Header = Utilities.CheckTrueOrFalse(attributes, ElementTags.HEADER);
+            if (Utilities.CheckTrueOrFalse(attributes, ElementTags.NOWRAP)) {
+                cell.MaxLines = 1;
+            }
+            SetRectangleProperties(cell, attributes);
+            return cell;
+        }
+
+        /**
+        * Creates an Table object based on a list of properties.
+        * @param attributes
+        * @return a Table
+        */
+        public static Table GetTable(Properties attributes) {
+            String value;
+            Table table;
+
+            value = attributes[ElementTags.WIDTHS];
+            if (value != null) {
+                StringTokenizer widthTokens = new StringTokenizer(value, ";");
+                ArrayList values = new ArrayList();
+                while (widthTokens.HasMoreTokens()) {
+                    values.Add(widthTokens.NextToken());
+                }
+                table = new Table(values.Count);
+                float[] widths = new float[table.Columns];
+                for (int i = 0; i < values.Count; i++) {
+                    value = (String)values[i];
+                    widths[i] = float.Parse(value, System.Globalization.NumberFormatInfo.InvariantInfo);
+                }
+                table.Widths = widths;
+            }
+            else {
+                value = attributes[ElementTags.COLUMNS];
+                try {
+                    table = new Table(int.Parse(value));
+                }
+                catch {
+                    table = new Table(1);
+                }
+            }
+            
+            table.Border = Table.BOX;
+            table.BorderWidth = 1;
+            table.DefaultCell.Border = Table.BOX;
+            
+            value = attributes[ElementTags.LASTHEADERROW];
+            if (value != null) {
+                table.LastHeaderRow = int.Parse(value);
+            }
+            value = attributes[ElementTags.ALIGN];
+            if (value != null) {
+                table.SetAlignment(value);
+            }
+            value = attributes[ElementTags.CELLSPACING];
+            if (value != null) {
+                table.Spacing = float.Parse(value, System.Globalization.NumberFormatInfo.InvariantInfo);
+            }
+            value = attributes[ElementTags.CELLPADDING];
+            if (value != null) {
+                table.Padding = float.Parse(value, System.Globalization.NumberFormatInfo.InvariantInfo);
+            }
+            value = attributes[ElementTags.OFFSET];
+            if (value != null) {
+                table.Offset = float.Parse(value, System.Globalization.NumberFormatInfo.InvariantInfo);
+            }
+            value = attributes[ElementTags.WIDTH];
+            if (value != null) {
+                if (value.EndsWith("%"))
+                    table.Width = float.Parse(value.Substring(0, value.Length - 1), System.Globalization.NumberFormatInfo.InvariantInfo);
+                else {
+                    table.Width = float.Parse(value, System.Globalization.NumberFormatInfo.InvariantInfo);
+                    table.Locked = true;
+                }
+            }
+            table.TableFitsPage = Utilities.CheckTrueOrFalse(attributes, ElementTags.TABLEFITSPAGE);
+            table.CellsFitPage = Utilities.CheckTrueOrFalse(attributes, ElementTags.CELLSFITPAGE);
+            table.Convert2pdfptable = Utilities.CheckTrueOrFalse(attributes, ElementTags.CONVERT2PDFP);
+            
+            SetRectangleProperties(table, attributes);
+            return table;
+        }
+
+        /**
+        * Sets some Rectangle properties (for a Cell, Table,...).
+        */
+        private static void SetRectangleProperties(Rectangle rect, Properties attributes) {
+            String value;
+            value = attributes[ElementTags.BORDERWIDTH];
+            if (value != null) {
+                rect.BorderWidth = float.Parse(value, System.Globalization.NumberFormatInfo.InvariantInfo);
+            }
+            int border = 0;
+            if (Utilities.CheckTrueOrFalse(attributes, ElementTags.LEFT)) {
+                border |= Rectangle.LEFT_BORDER;
+            }
+            if (Utilities.CheckTrueOrFalse(attributes, ElementTags.RIGHT)) {
+                border |= Rectangle.RIGHT_BORDER;
+            }
+            if (Utilities.CheckTrueOrFalse(attributes, ElementTags.TOP)) {
+                border |= Rectangle.TOP_BORDER;
+            }
+            if (Utilities.CheckTrueOrFalse(attributes, ElementTags.BOTTOM)) {
+                border |= Rectangle.BOTTOM_BORDER;
+            }
+            rect.Border = border;
+            
+            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);
+                rect.BorderColor = new Color(red, green, blue);
+            }
+            else {
+                rect.BorderColor = Markup.DecodeColor(attributes[ElementTags.BORDERCOLOR]);
+            }
+            r = (String)attributes.Remove(ElementTags.BGRED);
+            g = (String)attributes.Remove(ElementTags.BGGREEN);
+            b = (String)attributes.Remove(ElementTags.BGBLUE);
+            value = attributes[ElementTags.BACKGROUNDCOLOR];
+            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);
+                rect.BackgroundColor = new Color(red, green, blue);
+            }
+            else if (value != null) {
+                rect.BackgroundColor = Markup.DecodeColor(value);
+            }
+            else {
+                value = attributes[ElementTags.GRAYFILL];
+                if (value != null) {
+                    rect.GrayFill = float.Parse(value, System.Globalization.NumberFormatInfo.InvariantInfo);
+                }
+            }
+        }
+        
+        public static ChapterAutoNumber GetChapter(Properties attributes) {
+            ChapterAutoNumber chapter = new ChapterAutoNumber("");
+            SetSectionParameters(chapter, attributes);
+            return chapter;
+        }
+        
+        public static Section GetSection(Section parent, Properties attributes) {
+            Section section = parent.AddSection("");
+            SetSectionParameters(section, attributes);
+            return section;
+        }
+        
+        private static void SetSectionParameters(Section section, Properties attributes) {
+            String value;
+            value = attributes[ElementTags.NUMBERDEPTH];
+            if (value != null) {
+                section.NumberDepth = int.Parse(value);
+            }
+            value = attributes[ElementTags.INDENT];
+            if (value != null) {
+                section.Indentation = float.Parse(value, System.Globalization.NumberFormatInfo.InvariantInfo);
+            }
+            value = attributes[ElementTags.INDENTATIONLEFT];
+            if (value != null) {
+                section.IndentationLeft = float.Parse(value, System.Globalization.NumberFormatInfo.InvariantInfo);
+            }
+            value = attributes[ElementTags.INDENTATIONRIGHT];
+            if (value != null) {
+                section.IndentationRight = float.Parse(value, System.Globalization.NumberFormatInfo.InvariantInfo);
+            }
+        }
+
+        /// <summary>
+        /// Returns an Image that has been constructed taking in account
+        /// the value of some attributes.
+        /// </summary>
+        /// <param name="attributes">Some attributes</param>
+        /// <returns>an Image</returns>
+        public static Image GetImage(Properties attributes) {
+            String value;
+            
+            value = attributes[ElementTags.URL];
+            if (value == null)
+                throw new ArgumentException("The URL of the image is missing.");
+            Image image = Image.GetInstance(value);
+            
+            value = attributes[ElementTags.ALIGN];
+            int align = 0;
+            if (value != null) {
+                if (Util.EqualsIgnoreCase(ElementTags.ALIGN_LEFT, value))
+                    align |= Image.ALIGN_LEFT;
+                else if (Util.EqualsIgnoreCase(ElementTags.ALIGN_RIGHT, value))
+                    align |= Image.ALIGN_RIGHT;
+                else if (Util.EqualsIgnoreCase(ElementTags.ALIGN_MIDDLE, value))
+                    align |= Image.ALIGN_MIDDLE;
+            }
+            if (Util.EqualsIgnoreCase("true", attributes[ElementTags.UNDERLYING]))
+                align |= Image.UNDERLYING;
+            if (Util.EqualsIgnoreCase("true", attributes[ElementTags.TEXTWRAP]))
+                align |= Image.TEXTWRAP;
+            image.Alignment = align;
+            
+            value = attributes[ElementTags.ALT];
+            if (value != null) {
+                image.Alt = value;
+            }
+            
+            String x = attributes[ElementTags.ABSOLUTEX];
+            String y = attributes[ElementTags.ABSOLUTEY];
+            if ((x != null) && (y != null)) {
+                image.SetAbsolutePosition(float.Parse(x, System.Globalization.NumberFormatInfo.InvariantInfo),
+                        float.Parse(y, System.Globalization.NumberFormatInfo.InvariantInfo));
+            }
+            value = attributes[ElementTags.PLAINWIDTH];
+            if (value != null) {
+                image.ScaleAbsoluteWidth(float.Parse(value, System.Globalization.NumberFormatInfo.InvariantInfo));
+            }
+            value = attributes[ElementTags.PLAINHEIGHT];
+            if (value != null) {
+                image.ScaleAbsoluteHeight(float.Parse(value, System.Globalization.NumberFormatInfo.InvariantInfo));
+            }
+            value = attributes[ElementTags.ROTATION];
+            if (value != null) {
+                image.Rotation = float.Parse(value, System.Globalization.NumberFormatInfo.InvariantInfo);
+            }
+            return image;
+        }
+
+        /**
+        * Creates an Annotation object based on a list of properties.
+        * @param attributes
+        * @return an Annotation
+        */
+        public static Annotation GetAnnotation(Properties attributes) {
+            float llx = 0, lly = 0, urx = 0, ury = 0;
+            String value;
+            
+            value = attributes[ElementTags.LLX];
+            if (value != null) {
+                llx = float.Parse(value, System.Globalization.NumberFormatInfo.InvariantInfo);
+            }
+            value = attributes[ElementTags.LLY];
+            if (value != null) {
+                lly = float.Parse(value, System.Globalization.NumberFormatInfo.InvariantInfo);
+            }
+            value = attributes[ElementTags.URX];
+            if (value != null) {
+                urx = float.Parse(value, System.Globalization.NumberFormatInfo.InvariantInfo);
+            }
+            value = attributes[ElementTags.URY];
+            if (value != null) {
+                ury = float.Parse(value, System.Globalization.NumberFormatInfo.InvariantInfo);
+            }
+            
+            String title = attributes[ElementTags.TITLE];
+            String text = attributes[ElementTags.CONTENT];
+            if (title != null || text != null) {
+                return new Annotation(title, text, llx, lly, urx, ury);
+            }
+            value = attributes[ElementTags.URL];
+            if (value != null) {
+                return new Annotation(llx, lly, urx, ury, value);
+            }
+            value = attributes[ElementTags.NAMED];
+            if (value != null) {
+                return new Annotation(llx, lly, urx, ury, int.Parse(value));
+            }
+            String file = attributes[ElementTags.FILE];
+            String destination = attributes[ElementTags.DESTINATION];
+            String page = (String) attributes.Remove(ElementTags.PAGE);
+            if (file != null) {
+                if (destination != null) {
+                    return new Annotation(llx, lly, urx, ury, file, destination);
+                }
+                if (page != null) {
+                    return new Annotation(llx, lly, urx, ury, file, int.Parse(page));
+                }
+            }
+            if (title == null)
+                title = "";
+            if (text == null)
+                text = "";
+            return new Annotation(title, text, llx, lly, urx, ury);
+        }
+    }
+}

src/core/iTextSharp/text/factories/GreekAlphabetFactory.cs

@@ -0,0 +1,122 @@
+using System;
+using iTextSharp.text;
+/*
+ * $Id: GreekAlphabetFactory.cs,v 1.2 2008/05/13 11:25:14 psoares33 Exp $
+ * 
+ *
+ * Copyright 2007 by Bruno Lowagie.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+namespace iTextSharp.text.factories {
+
+    /**
+    * This class can produce String combinations representing a number built with
+    * Greek letters (from alpha to omega, then alpha alpha, alpha beta, alpha gamma).
+    * We are aware of the fact that the original Greek numbering is different;
+    * See http://www.cogsci.indiana.edu/farg/harry/lan/grknum.htm#ancient
+    * but this isn't implemented yet; the main reason being the fact that we
+    * need a font that has the obsolete Greek characters qoppa and sampi.
+    */
+    public class GreekAlphabetFactory {
+        /** 
+        * Changes an int into a lower case Greek letter combination.
+        * @param index the original number
+        * @return the letter combination
+        */
+        public static String GetString(int index) {
+            return GetString(index, true);
+        }
+        
+        /** 
+        * Changes an int into a lower case Greek letter combination.
+        * @param index the original number
+        * @return the letter combination
+        */
+        public static String GetLowerCaseString(int index) {
+            return GetString(index);        
+        }
+        
+        /** 
+        * Changes an int into a upper case Greek letter combination.
+        * @param index the original number
+        * @return the letter combination
+        */
+        public static String GetUpperCaseString(int index) {
+            return GetString(index).ToUpper(System.Globalization.CultureInfo.InvariantCulture);
+        }
+
+        /** 
+        * Changes an int into a Greek letter combination.
+        * @param index the original number
+        * @return the letter combination
+        */
+        public static String GetString(int index, bool lowercase) {
+            if (index < 1) return "";
+            index--;
+                
+            int bytes = 1;
+            int start = 0;
+            int symbols = 24;  
+            while (index >= symbols + start) {
+                bytes++;
+                start += symbols;
+                symbols *= 24;
+            }
+                  
+            int c = index - start;
+            char[] value = new char[bytes];
+            while (bytes > 0) {
+                bytes--;
+                value[bytes] = (char)(c % 24);
+                if (value[bytes] > 16) value[bytes]++;
+                value[bytes] += (char)(lowercase ? 945 : 913);
+                value[bytes] = SpecialSymbol.GetCorrespondingSymbol(value[bytes]);
+                c /= 24;
+            }
+            
+            return new String(value);
+        }
+    }
+}

src/core/iTextSharp/text/factories/RomanAlphabetFactory.cs

@@ -0,0 +1,122 @@
+using System;
+/*
+ * $Id: RomanAlphabetFactory.cs,v 1.2 2008/05/13 11:25:14 psoares33 Exp $
+ * 
+ *
+ * Copyright 2007 by Bruno Lowagie.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+
+namespace iTextSharp.text.factories {
+
+    /**
+    * This class can produce String combinations representing a number.
+    * "a" to "z" represent 1 to 26, "AA" represents 27, "AB" represents 28,
+    * and so on; "ZZ" is followed by "AAA".
+    */
+    public class RomanAlphabetFactory {
+
+        /**
+        * Translates a positive integer (not equal to zero)
+        * into a String using the letters 'a' to 'z';
+        * 1 = a, 2 = b, ..., 26 = z, 27 = aa, 28 = ab,...
+        */
+        public static String GetString(int index) {
+            if (index < 1) throw new FormatException("You can't translate a negative number into an alphabetical value.");
+            
+            index--;
+            int bytes = 1;
+            int start = 0;
+            int symbols = 26;  
+            while (index >= symbols + start) {
+                bytes++;
+                start += symbols;
+                symbols *= 26;
+            }
+                  
+            int c = index - start;
+            char[] value = new char[bytes];
+            while (bytes > 0) {
+                value[--bytes] = (char)( 'a' + (c % 26));
+                c /= 26;
+            }
+            
+            return new String(value);
+        }
+        
+        /**
+        * Translates a positive integer (not equal to zero)
+        * into a String using the letters 'a' to 'z';
+        * 1 = a, 2 = b, ..., 26 = z, 27 = aa, 28 = ab,...
+        */
+        public static String GetLowerCaseString(int index) {
+            return GetString(index);        
+        }
+        
+        /**
+        * Translates a positive integer (not equal to zero)
+        * into a String using the letters 'A' to 'Z';
+        * 1 = A, 2 = B, ..., 26 = Z, 27 = AA, 28 = AB,...
+        */
+        public static String GetUpperCaseString(int index) {
+            return GetString(index).ToUpper(System.Globalization.CultureInfo.InvariantCulture);
+        }
+
+        
+        /**
+        * Translates a positive integer (not equal to zero)
+        * into a String using the letters 'a' to 'z'
+        * (a = 1, b = 2, ..., z = 26, aa = 27, ab = 28,...).
+        */
+        public static String GetString(int index, bool lowercase) {
+            if (lowercase) {
+                return GetLowerCaseString(index);
+            }
+            else {
+                return GetUpperCaseString(index);
+            }
+        }
+    }
+}

src/core/iTextSharp/text/factories/RomanNumberFactory.cs

@@ -0,0 +1,180 @@
+using System;
+using System.Text;
+/*
+ * $Id: RomanNumberFactory.cs,v 1.2 2008/05/13 11:25:14 psoares33 Exp $
+ * 
+ *
+ * Copyright 2007 by Bruno Lowagie.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+namespace iTextSharp.text.factories {
+    /**
+    * This class can produce String combinations representing a roman number.
+    */
+    public class RomanNumberFactory {
+        /**
+        * Helper class for Roman Digits
+        */
+        internal class RomanDigit {
+
+            /** part of a roman number */
+            public char digit;
+
+            /** value of the roman digit */
+            public int value;
+
+            /** can the digit be used as a prefix */
+            public bool pre;
+
+            /**
+            * Constructs a roman digit
+            * @param digit the roman digit
+            * @param value the value
+            * @param pre can it be used as a prefix
+            */
+            internal RomanDigit(char digit, int value, bool pre) {
+                this.digit = digit;
+                this.value = value;
+                this.pre = pre;
+            }
+        }
+        
+        /**
+        * Array with Roman digits.
+        */
+        private static RomanDigit[] roman = {
+            new RomanDigit('m', 1000, false),
+            new RomanDigit('d', 500, false),
+            new RomanDigit('c', 100, true),
+            new RomanDigit('l', 50, false),
+            new RomanDigit('x', 10, true),
+            new RomanDigit('v', 5, false),
+            new RomanDigit('i', 1, true)
+        };
+        
+        /** 
+        * Changes an int into a lower case roman number.
+        * @param index the original number
+        * @return the roman number (lower case)
+        */
+        public static String GetString(int index) {
+            StringBuilder buf = new StringBuilder();
+
+            // lower than 0 ? Add minus
+            if (index < 0) {
+                buf.Append('-');
+                index = -index;
+            }
+
+            // greater than 3000
+            if (index > 3000) {
+                buf.Append('|');
+                buf.Append(GetString(index / 1000));
+                buf.Append('|');
+                // remainder
+                index = index - (index / 1000) * 1000;
+            }
+
+            // number between 1 and 3000
+            int pos = 0;
+            while (true) {
+                // loop over the array with values for m-d-c-l-x-v-i
+                RomanDigit dig = roman[pos];
+                // adding as many digits as we can
+                while (index >= dig.value) {
+                    buf.Append(dig.digit);
+                    index -= dig.value;
+                }
+                // we have the complete number
+                if (index <= 0) {
+                    break;
+                }
+                // look for the next digit that can be used in a special way
+                int j = pos;
+                while (!roman[++j].pre);
+
+                // does the special notation apply?
+                if (index + roman[j].value >= dig.value) {
+                    buf.Append(roman[j].digit).Append(dig.digit);
+                    index -= dig.value - roman[j].value;
+                }
+                pos++;
+            }
+            return buf.ToString();
+        }
+        
+        /** 
+        * Changes an int into a lower case roman number.
+        * @param index the original number
+        * @return the roman number (lower case)
+        */
+        public static String GetLowerCaseString(int index) {
+            return GetString(index);        
+        }
+        
+        /** 
+        * Changes an int into an upper case roman number.
+        * @param index the original number
+        * @return the roman number (lower case)
+        */
+        public static String GetUpperCaseString(int index) {
+            return GetString(index).ToUpper(System.Globalization.CultureInfo.InvariantCulture);      
+        }
+
+        /** 
+        * Changes an int into a roman number.
+        * @param index the original number
+        * @return the roman number (lower case)
+        */
+        public static String GetString(int index, bool lowercase) {
+            if (lowercase) {
+                return GetLowerCaseString(index);
+            }
+            else {
+                return GetUpperCaseString(index);
+            }
+        }
+    }
+}

src/core/iTextSharp/text/html/HtmlEncoder.cs

@@ -0,0 +1,213 @@
+using System;
+using System.Text;
+using System.Drawing;
+
+using iTextSharp.text;
+
+/*
+ * $Id: HtmlEncoder.cs,v 1.6 2008/05/13 11:25:15 psoares33 Exp $
+ * 
+ *
+ * Copyright 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+
+namespace iTextSharp.text.html {
+    /**
+     * This class converts a <CODE>String</CODE> to the HTML-format of a String.
+     * <P>
+     * To convert the <CODE>String</CODE>, each character is examined:
+     * <UL>
+     * <LI>ASCII-characters from 000 till 031 are represented as &amp;#xxx;<BR>
+     *     (with xxx = the value of the character)
+     * <LI>ASCII-characters from 032 t/m 127 are represented by the character itself, except for:
+     *     <UL>
+     *     <LI>'\n' becomes &lt;BR&gt;\n
+     *     <LI>&quot; becomes &amp;quot;
+     *     <LI>&amp; becomes &amp;amp;
+     *     <LI>&lt; becomes &amp;lt;
+     *     <LI>&gt; becomes &amp;gt;
+     *     </UL>
+     * <LI>ASCII-characters from 128 till 255 are represented as &amp;#xxx;<BR>
+     *     (with xxx = the value of the character)
+     * </UL>
+     * <P>
+     * Example:
+     * <P><BLOCKQUOTE><PRE>
+     *    String htmlPresentation = HtmlEncoder.Encode("Marie-Th&#233;r&#232;se S&#248;rensen");
+     * </PRE></BLOCKQUOTE><P>
+     * for more info: see O'Reilly; "HTML: The Definitive Guide" (page 164)
+     *
+     * @author  mario.maccarini@rug.ac.be
+     */
+
+    public sealed class HtmlEncoder {
+    
+        // membervariables
+    
+        /** List with the HTML translation of all the characters. */
+        private static String[] htmlCode = new String[256];
+    
+        static HtmlEncoder() {
+            for (int i = 0; i < 10; i++) {
+                htmlCode[i] = "&#00" + i + ";";
+            }
+        
+            for (int i = 10; i < 32; i++) {
+                htmlCode[i] = "&#0" + i + ";";
+            }
+        
+            for (int i = 32; i < 128; i++) {
+                htmlCode[i] = ((char)i).ToString();
+            }
+        
+            // Special characters
+            htmlCode['\t'] = "\t";
+            htmlCode['\n'] = "<" + HtmlTags.NEWLINE + " />\n";
+            htmlCode['\"'] = "&quot;"; // double quote
+            htmlCode['&'] = "&amp;"; // ampersand
+            htmlCode['<'] = "&lt;"; // lower than
+            htmlCode['>'] = "&gt;"; // greater than
+        
+            for (int i = 128; i < 256; i++) {
+                htmlCode[i] = "&#" + i + ";";
+            }
+        }
+    
+    
+        // constructors
+    
+        /**
+         * This class will never be constructed.
+         * <P>
+         * HtmlEncoder only contains static methods.
+         */
+    
+        private HtmlEncoder () { }
+    
+        // methods
+    
+        /**
+         * Converts a <CODE>String</CODE> to the HTML-format of this <CODE>String</CODE>.
+         *
+         * @param   string  The <CODE>String</CODE> to convert
+         * @return  a <CODE>String</CODE>
+         */
+    
+        public static String Encode(String str) {
+            int n = str.Length;
+            char character;
+            StringBuilder buffer = new StringBuilder();
+            // loop over all the characters of the String.
+            for (int i = 0; i < n; i++) {
+                character = str[i];
+                // the Htmlcode of these characters are added to a StringBuilder one by one
+                if (character < 256) {
+                    buffer.Append(htmlCode[character]);
+                }
+                else {
+                    // Improvement posted by Joachim Eyrich
+                    buffer.Append("&#").Append((int)character).Append(';');
+                }
+            }
+            return buffer.ToString();
+        }
+    
+        /**
+         * Converts a <CODE>Color</CODE> into a HTML representation of this <CODE>Color</CODE>.
+         *
+         * @param   color   the <CODE>Color</CODE> that has to be converted.
+         * @return  the HTML representation of this <COLOR>Color</COLOR>
+         */
+    
+        public static String Encode(Color color) {
+            StringBuilder buffer = new StringBuilder("#");
+            if (color.R < 16) {
+                buffer.Append('0');
+            }
+            buffer.Append(System.Convert.ToString(color.R, 16));
+            if (color.G < 16) {
+                buffer.Append('0');
+            }
+            buffer.Append(System.Convert.ToString(color.G, 16));
+            if (color.B < 16) {
+                buffer.Append('0');
+            }
+            buffer.Append(System.Convert.ToString(color.B, 16));
+            return buffer.ToString();
+        }
+    
+        /**
+         * Translates the alignment value.
+         *
+         * @param   alignment   the alignment value
+         * @return  the translated value
+         */
+    
+        public static String GetAlignment(int alignment) {
+            switch (alignment) {
+                case Element.ALIGN_LEFT:
+                    return HtmlTags.ALIGN_LEFT;
+                case Element.ALIGN_CENTER:
+                    return HtmlTags.ALIGN_CENTER;
+                case Element.ALIGN_RIGHT:
+                    return HtmlTags.ALIGN_RIGHT;
+                case Element.ALIGN_JUSTIFIED:
+                case Element.ALIGN_JUSTIFIED_ALL:
+                    return HtmlTags.ALIGN_JUSTIFIED;
+                case Element.ALIGN_TOP:
+                    return HtmlTags.ALIGN_TOP;
+                case Element.ALIGN_MIDDLE:
+                    return HtmlTags.ALIGN_MIDDLE;
+                case Element.ALIGN_BOTTOM:
+                    return HtmlTags.ALIGN_BOTTOM;
+                case Element.ALIGN_BASELINE:
+                    return HtmlTags.ALIGN_BASELINE;
+                default:
+                    return "";
+            }
+        }
+    }
+}

src/core/iTextSharp/text/html/HtmlParser.cs

@@ -0,0 +1,239 @@
+using System;
+using System.IO;
+using System.Xml;
+using System.Collections;
+
+using iTextSharp.text;
+using iTextSharp.text.xml;
+
+/*
+ * Copyright 2001, 2002 by Bruno Lowagie.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+
+namespace iTextSharp.text.html {
+
+    /// <summary>
+    /// This class can be used to parse an XML file.
+    /// </summary>
+    public class HtmlParser : XmlParser{
+    
+        /// <summary>
+        /// Constructs an XmlParser.
+        /// </summary>
+        public HtmlParser() {
+        }
+    
+        /// <summary>
+        /// Parses a given file.
+        /// </summary>
+        /// <param name="document"></param>
+        /// <param name="file"></param>
+        public override void Go(IDocListener document, XmlDocument xDoc) {
+            parser = new ITextmyHtmlHandler(document);
+            parser.Parse(xDoc);
+        }
+    
+        /// <summary>
+        /// Parses a given file.
+        /// </summary>
+        /// <param name="document"></param>
+        /// <param name="file"></param>
+        public override void Go(IDocListener document, String file) {
+            parser = new ITextmyHtmlHandler(document);
+            parser.Parse(file);
+        }
+    
+        /// <summary>
+        /// Parses a given XmlTextReader.
+        /// </summary>
+        /// <param name="document"></param>
+        /// <param name="reader"></param>
+        public override void Go(IDocListener document, XmlTextReader reader) {
+            parser = new ITextmyHtmlHandler(document);
+            parser.Parse(reader);
+        }
+    
+        /// <summary>
+        /// Parses a given file.
+        /// </summary>
+        /// <param name="document"></param>
+        /// <param name="file"></param>
+        /// <param name="tagmap"></param>
+        public override void Go(IDocListener document, XmlDocument xDoc, XmlDocument xTagmap) {
+            parser = new ITextmyHtmlHandler(document, new TagMap(xTagmap));
+            parser.Parse(xDoc);
+        }
+    
+        /// <summary>
+        /// Parses a given XmlTextReader.
+        /// </summary>
+        /// <param name="document"></param>
+        /// <param name="reader"></param>
+        /// <param name="tagmap"></param>
+        public override void Go(IDocListener document, XmlTextReader reader, String tagmap) {
+            parser = new ITextmyHtmlHandler(document, new TagMap(tagmap));
+            parser.Parse(reader);
+        }
+    
+        /// <summary>
+        /// Parses a given file.
+        /// </summary>
+        /// <param name="document"></param>
+        /// <param name="file"></param>
+        /// <param name="tagmap"></param>
+        public override void Go(IDocListener document, String file, String tagmap) {
+            parser = new ITextmyHtmlHandler(document, new TagMap(tagmap));
+            parser.Parse(file);
+        }
+    
+        /// <summary>
+        /// Parses a given file.
+        /// </summary>
+        /// <param name="document"></param>
+        /// <param name="file"></param>
+        /// <param name="tagmap"></param>
+        public override void Go(IDocListener document, String file, Hashtable tagmap) {
+            parser = new ITextmyHtmlHandler(document, tagmap);
+            parser.Parse(file);
+        }
+    
+        /// <summary>
+        /// Parses a given XmlTextReader.
+        /// </summary>
+        /// <param name="document"></param>
+        /// <param name="reader"></param>
+        /// <param name="tagmap"></param>
+        public override void Go(IDocListener document, XmlTextReader reader, Hashtable tagmap) {
+            parser = new ITextmyHtmlHandler(document, tagmap);
+            parser.Parse(reader);
+        }
+    
+        /// <summary>
+        /// Parses a given file.
+        /// </summary>
+        /// <param name="document"></param>
+        /// <param name="file"></param>
+        public new static void Parse(IDocListener document, XmlDocument xDoc) {
+            HtmlParser p = new HtmlParser();
+            p.Go(document, xDoc);
+        }
+    
+        /// <summary>
+        /// Parses a given file.
+        /// </summary>
+        /// <param name="document"></param>
+        /// <param name="file"></param>
+        public new static void Parse(IDocListener document, String file) {
+            HtmlParser p = new HtmlParser();
+            p.Go(document, file);
+        }
+    
+        /// <summary>
+        /// Parses a given XmlTextReader.
+        /// </summary>
+        /// <param name="document"></param>
+        /// <param name="reader"></param>
+        public new static void Parse(IDocListener document, XmlTextReader reader) {
+            HtmlParser p = new HtmlParser();
+            p.Go(document, reader);
+        }
+    
+        /// <summary>
+        /// Parses a given file.
+        /// </summary>
+        /// <param name="document"></param>
+        /// <param name="file"></param>
+        /// <param name="tagmap"></param>
+        public new static void Parse(IDocListener document, XmlDocument xDoc, XmlDocument xTagmap) {
+            HtmlParser p = new HtmlParser();
+            p.Go(document, xDoc, xTagmap);
+        }
+    
+        /// <summary>
+        /// Parses a given file.
+        /// </summary>
+        /// <param name="document"></param>
+        /// <param name="file"></param>
+        /// <param name="tagmap"></param>
+        public new static void Parse(IDocListener document, String file, String tagmap) {
+            HtmlParser p = new HtmlParser();
+            p.Go(document, file, tagmap);
+        }
+    
+        /// <summary>
+        /// Parses a given file.
+        /// </summary>
+        /// <param name="document"></param>
+        /// <param name="file"></param>
+        /// <param name="tagmap"></param>
+        public new static void Parse(IDocListener document, String file, Hashtable tagmap) {
+            HtmlParser p = new HtmlParser();
+            p.Go(document, file, tagmap);
+        }
+    
+        /// <summary>
+        /// Parses a given XmlTextReader.
+        /// </summary>
+        /// <param name="document"></param>
+        /// <param name="reader"></param>
+        /// <param name="tagmap"></param>
+        public new static void Parse(IDocListener document, XmlTextReader reader, String tagmap) {
+            HtmlParser p = new HtmlParser();
+            p.Go(document, reader, tagmap);
+        }
+    
+        /// <summary>
+        /// Parses a given XmlTextReader.
+        /// </summary>
+        /// <param name="document"></param>
+        /// <param name="reader"></param>
+        /// <param name="tagmap"></param>
+        public new static void Parse(IDocListener document, XmlTextReader reader, Hashtable tagmap) {
+            HtmlParser p = new HtmlParser();
+            p.Go(document, reader, tagmap);
+        }
+    }
+}

src/core/iTextSharp/text/html/HtmlPeer.cs

@@ -0,0 +1,102 @@
+using System;
+using System.Globalization;
+using System.Collections;
+using iTextSharp.text.xml;
+using System.util;
+
+/*
+ * $Id: HtmlPeer.cs,v 1.4 2008/05/13 11:25:15 psoares33 Exp $
+ * 
+ *
+ * Copyright 2001, 2002 by Bruno Lowagie.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+
+namespace iTextSharp.text.html {
+
+    /**
+    * This interface is implemented by the peer of all the iText objects.
+    */
+
+    public class HtmlPeer : XmlPeer {
+        
+    /**
+    * Creates a XmlPeer.
+    * @param name the iText name of the tag
+    * @param alias the Html name of the tag
+    */
+        
+        public HtmlPeer(String name, String alias) : base(name, alias.ToLower(CultureInfo.InvariantCulture)) {
+        }
+        
+    /**
+    * Sets an alias for an attribute.
+    *
+    * @param   name    the iText tagname
+    * @param   alias   the custom tagname
+    */
+        
+        public override void AddAlias(String name, String alias) {
+            attributeAliases.Add(alias.ToLower(CultureInfo.InvariantCulture), name);
+        }
+
+        /**
+        * @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;
+        }
+    }
+}

src/core/iTextSharp/text/html/HtmlTagMap.cs

@@ -0,0 +1,289 @@
+using System;
+using System.util;
+using System.Collections;
+using iTextSharp.text;
+
+/*
+ * $Id: HtmlTagMap.cs,v 1.4 2008/05/13 11:25:15 psoares33 Exp $
+ * 
+ *
+ * Copyright 2001, 2002 by Bruno Lowagie.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+
+namespace iTextSharp.text.html {
+
+    /**
+    * The <CODE>Tags</CODE>-class maps several XHTML-tags to iText-objects.
+    */
+
+    public class HtmlTagMap : Hashtable {
+        
+    /**
+    * Constructs an HtmlTagMap.
+    */
+        
+        public HtmlTagMap() {
+            HtmlPeer peer;
+            
+            peer = new HtmlPeer(ElementTags.ITEXT, HtmlTags.HTML);
+            this[peer.Alias] = peer;
+            
+            peer = new HtmlPeer(ElementTags.PHRASE, HtmlTags.SPAN);
+            this[peer.Alias] = peer;
+            
+            peer = new HtmlPeer(ElementTags.CHUNK, HtmlTags.CHUNK);
+            peer.AddAlias(ElementTags.FONT, HtmlTags.FONT);
+            peer.AddAlias(ElementTags.SIZE, HtmlTags.SIZE);
+            peer.AddAlias(ElementTags.COLOR, HtmlTags.COLOR);
+            this[peer.Alias] = peer;
+            
+            peer = new HtmlPeer(ElementTags.ANCHOR, HtmlTags.ANCHOR);
+            peer.AddAlias(ElementTags.NAME, HtmlTags.NAME);
+            peer.AddAlias(ElementTags.REFERENCE, HtmlTags.REFERENCE);
+            this[peer.Alias] = peer;
+            
+            peer = new HtmlPeer(ElementTags.PARAGRAPH, HtmlTags.PARAGRAPH);
+            peer.AddAlias(ElementTags.ALIGN, HtmlTags.ALIGN);
+            this[peer.Alias] = peer;
+            
+            peer = new HtmlPeer(ElementTags.PARAGRAPH, HtmlTags.DIV);
+            peer.AddAlias(ElementTags.ALIGN, HtmlTags.ALIGN);
+            this[peer.Alias] = peer;
+            
+            peer = new HtmlPeer(ElementTags.PARAGRAPH, HtmlTags.H[0]);
+            peer.AddValue(ElementTags.SIZE, "20");
+            this[peer.Alias] = peer;
+            
+            peer = new HtmlPeer(ElementTags.PARAGRAPH, HtmlTags.H[1]);
+            peer.AddValue(ElementTags.SIZE, "18");
+            this[peer.Alias] = peer;
+            
+            peer = new HtmlPeer(ElementTags.PARAGRAPH, HtmlTags.H[2]);
+            peer.AddValue(ElementTags.SIZE, "16");
+            this[peer.Alias] = peer;
+            
+            peer = new HtmlPeer(ElementTags.PARAGRAPH, HtmlTags.H[3]);
+            peer.AddValue(ElementTags.SIZE, "14");
+            this[peer.Alias] = peer;
+            
+            peer = new HtmlPeer(ElementTags.PARAGRAPH, HtmlTags.H[4]);
+            peer.AddValue(ElementTags.SIZE, "12");
+            this[peer.Alias] = peer;
+            
+            peer = new HtmlPeer(ElementTags.PARAGRAPH, HtmlTags.H[5]);
+            peer.AddValue(ElementTags.SIZE, "10");
+            this[peer.Alias] = peer;
+            
+            peer = new HtmlPeer(ElementTags.LIST, HtmlTags.ORDEREDLIST);
+            peer.AddValue(ElementTags.NUMBERED, "true");
+            peer.AddValue(ElementTags.SYMBOLINDENT, "20");
+            this[peer.Alias] = peer;
+            
+            peer = new HtmlPeer(ElementTags.LIST, HtmlTags.UNORDEREDLIST);
+            peer.AddValue(ElementTags.NUMBERED, "false");
+            peer.AddValue(ElementTags.SYMBOLINDENT, "20");
+            this[peer.Alias] = peer;
+            
+            peer = new HtmlPeer(ElementTags.LISTITEM, HtmlTags.LISTITEM);
+            this[peer.Alias] = peer;
+            
+            peer = new HtmlPeer(ElementTags.PHRASE, HtmlTags.I);
+            peer.AddValue(ElementTags.STYLE, Markup.CSS_VALUE_ITALIC);
+            this[peer.Alias] = peer;
+            
+            peer = new HtmlPeer(ElementTags.PHRASE, HtmlTags.EM);
+            peer.AddValue(ElementTags.STYLE, Markup.CSS_VALUE_ITALIC);
+            this[peer.Alias] = peer;
+            
+            peer = new HtmlPeer(ElementTags.PHRASE, HtmlTags.B);
+            peer.AddValue(ElementTags.STYLE, Markup.CSS_VALUE_BOLD);
+            this[peer.Alias] = peer;
+            
+            peer = new HtmlPeer(ElementTags.PHRASE, HtmlTags.STRONG);
+            peer.AddValue(ElementTags.STYLE, Markup.CSS_VALUE_BOLD);
+            this[peer.Alias] = peer;
+            
+            peer = new HtmlPeer(ElementTags.PHRASE, HtmlTags.S);
+            peer.AddValue(ElementTags.STYLE, Markup.CSS_VALUE_LINETHROUGH);
+            this[peer.Alias] = peer;
+            
+            peer = new HtmlPeer(ElementTags.PHRASE, HtmlTags.CODE);
+            peer.AddValue(ElementTags.FONT, FontFactory.COURIER);
+            this[peer.Alias] = peer;
+            
+            peer = new HtmlPeer(ElementTags.PHRASE, HtmlTags.VAR);
+            peer.AddValue(ElementTags.FONT, FontFactory.COURIER);
+            peer.AddValue(ElementTags.STYLE, Markup.CSS_VALUE_ITALIC);
+            this[peer.Alias] = peer;
+            
+            peer = new HtmlPeer(ElementTags.PHRASE, HtmlTags.U);
+            peer.AddValue(ElementTags.STYLE, Markup.CSS_VALUE_UNDERLINE);
+            this[peer.Alias] = peer;
+            
+            peer = new HtmlPeer(ElementTags.CHUNK, HtmlTags.SUP);
+            peer.AddValue(ElementTags.SUBSUPSCRIPT, "6.0");
+            this[peer.Alias] = peer;
+            
+            peer = new HtmlPeer(ElementTags.CHUNK, HtmlTags.SUB);
+            peer.AddValue(ElementTags.SUBSUPSCRIPT, "-6.0");
+            this[peer.Alias] = peer;
+            
+            peer = new HtmlPeer(ElementTags.HORIZONTALRULE, HtmlTags.HORIZONTALRULE);
+            this[peer.Alias] = peer;
+            
+            peer = new HtmlPeer(ElementTags.TABLE, HtmlTags.TABLE);
+            peer.AddAlias(ElementTags.WIDTH, HtmlTags.WIDTH);
+            peer.AddAlias(ElementTags.BACKGROUNDCOLOR, HtmlTags.BACKGROUNDCOLOR);
+            peer.AddAlias(ElementTags.BORDERCOLOR, HtmlTags.BORDERCOLOR);
+            peer.AddAlias(ElementTags.COLUMNS, HtmlTags.COLUMNS);
+            peer.AddAlias(ElementTags.CELLPADDING, HtmlTags.CELLPADDING);
+            peer.AddAlias(ElementTags.CELLSPACING, HtmlTags.CELLSPACING);
+            peer.AddAlias(ElementTags.BORDERWIDTH, HtmlTags.BORDERWIDTH);
+            peer.AddAlias(ElementTags.ALIGN, HtmlTags.ALIGN);
+            this[peer.Alias] = peer;
+            
+            peer = new HtmlPeer(ElementTags.ROW, HtmlTags.ROW);
+            this[peer.Alias] = peer;
+            
+            peer = new HtmlPeer(ElementTags.CELL, HtmlTags.CELL);
+            peer.AddAlias(ElementTags.WIDTH, HtmlTags.WIDTH);
+            peer.AddAlias(ElementTags.BACKGROUNDCOLOR, HtmlTags.BACKGROUNDCOLOR);
+            peer.AddAlias(ElementTags.BORDERCOLOR, HtmlTags.BORDERCOLOR);
+            peer.AddAlias(ElementTags.COLSPAN, HtmlTags.COLSPAN);
+            peer.AddAlias(ElementTags.ROWSPAN, HtmlTags.ROWSPAN);
+            peer.AddAlias(ElementTags.NOWRAP, HtmlTags.NOWRAP);
+            peer.AddAlias(ElementTags.HORIZONTALALIGN, HtmlTags.HORIZONTALALIGN);
+            peer.AddAlias(ElementTags.VERTICALALIGN, HtmlTags.VERTICALALIGN);
+            peer.AddValue(ElementTags.HEADER, "false");
+            this[peer.Alias] = peer;
+            
+            peer = new HtmlPeer(ElementTags.CELL, HtmlTags.HEADERCELL);
+            peer.AddAlias(ElementTags.WIDTH, HtmlTags.WIDTH);
+            peer.AddAlias(ElementTags.BACKGROUNDCOLOR, HtmlTags.BACKGROUNDCOLOR);
+            peer.AddAlias(ElementTags.BORDERCOLOR, HtmlTags.BORDERCOLOR);
+            peer.AddAlias(ElementTags.COLSPAN, HtmlTags.COLSPAN);
+            peer.AddAlias(ElementTags.ROWSPAN, HtmlTags.ROWSPAN);
+            peer.AddAlias(ElementTags.NOWRAP, HtmlTags.NOWRAP);
+            peer.AddAlias(ElementTags.HORIZONTALALIGN, HtmlTags.HORIZONTALALIGN);
+            peer.AddAlias(ElementTags.VERTICALALIGN, HtmlTags.VERTICALALIGN);
+            peer.AddValue(ElementTags.HEADER, "true");
+            this[peer.Alias] = peer;
+            
+            peer = new HtmlPeer(ElementTags.IMAGE, HtmlTags.IMAGE);
+            peer.AddAlias(ElementTags.URL, HtmlTags.URL);
+            peer.AddAlias(ElementTags.ALT, HtmlTags.ALT);
+            peer.AddAlias(ElementTags.PLAINWIDTH, HtmlTags.PLAINWIDTH);
+            peer.AddAlias(ElementTags.PLAINHEIGHT, HtmlTags.PLAINHEIGHT);
+            this[peer.Alias] = peer;
+            
+            peer = new HtmlPeer(ElementTags.NEWLINE, HtmlTags.NEWLINE);
+            this[peer.Alias] = peer;
+        }
+        
+        /**
+        * Checks if this is the root tag.
+        * @param tag a tagvalue
+        * @return true if tag is HTML or html
+        */
+        public static bool IsHtml(String tag) {
+            return Util.EqualsIgnoreCase(HtmlTags.HTML, tag);
+        }
+
+        /**
+        * Checks if this is the head tag.
+        * @param tag a tagvalue
+        * @return true if tag is HEAD or head
+        */
+        public static bool IsHead(String tag) {
+            return Util.EqualsIgnoreCase(HtmlTags.HEAD, tag);
+        }
+
+        /**
+        * Checks if this is the meta tag.
+        * @param tag a tagvalue
+        * @return true if tag is META or meta
+        */
+        public static bool IsMeta(String tag) {
+            return Util.EqualsIgnoreCase(HtmlTags.META, tag);
+        }
+
+        /**
+        * Checks if this is the linl tag.
+        * @param tag a tagvalue
+        * @return true if tag is LINK or link
+        */
+        public static bool IsLink(String tag) {
+            return Util.EqualsIgnoreCase(HtmlTags.LINK, tag);
+        }
+
+        /**
+        * Checks if this is the title tag.
+        * @param tag a tagvalue
+        * @return true if tag is TITLE or title
+        */
+        public static bool IsTitle(String tag) {
+            return Util.EqualsIgnoreCase(HtmlTags.TITLE, tag);
+        }
+
+        /**
+        * Checks if this is the root tag.
+        * @param tag a tagvalue
+        * @return true if tag is BODY or body
+        */
+        public static bool IsBody(String tag) {
+            return Util.EqualsIgnoreCase(HtmlTags.BODY, tag);
+        }
+
+        /**
+        * Checks if this is a special tag.
+        * @param tag a tagvalue
+        * @return true if tag is a HTML, HEAD, META, LINK or BODY tag (case insensitive)
+        */
+        public static bool IsSpecialTag(String tag) {
+            return IsHtml(tag) || IsHead(tag) || IsMeta(tag) || IsLink(tag) || IsBody(tag);
+        }
+    }
+}

src/core/iTextSharp/text/html/HtmlTags.cs

@@ -0,0 +1,325 @@
+using System;
+
+/*
+ * $Id: HtmlTags.cs,v 1.4 2008/05/13 11:25:15 psoares33 Exp $
+ * 
+ *
+ * Copyright 2001, 2002 by Bruno Lowagie.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+
+namespace iTextSharp.text.html {
+
+    /**
+     * A class that contains all the possible tagnames and their attributes.
+     */
+
+    public class HtmlTags {
+    
+        /** the root tag. */
+        public const string HTML = "html";
+    
+        /** the head tag */
+        public const string HEAD = "head";
+    
+        /** This is a possible HTML attribute for the HEAD tag. */
+        public const string CONTENT = "content";
+    
+        /** the meta tag */
+        public const string META = "meta";
+    
+        /** attribute of the root tag */
+        public const string SUBJECT = "subject";
+    
+        /** attribute of the root tag */
+        public const string KEYWORDS = "keywords";
+    
+        /** attribute of the root tag */
+        public const string AUTHOR = "author";
+    
+        /** the title tag. */
+        public const string TITLE = "title";
+    
+        /** the script tag. */
+        public const string SCRIPT = "script";
+
+        /** This is a possible HTML attribute for the SCRIPT tag. */
+        public const string LANGUAGE = "language";
+
+        /** This is a possible value for the LANGUAGE attribute. */
+        public const string JAVASCRIPT = "JavaScript";
+
+        /** the body tag. */
+        public const string BODY = "body";
+    
+        /** This is a possible HTML attribute for the BODY tag */
+        public const string JAVASCRIPT_ONLOAD = "onLoad";
+
+        /** This is a possible HTML attribute for the BODY tag */
+        public const string JAVASCRIPT_ONUNLOAD = "onUnLoad";
+
+        /** This is a possible HTML attribute for the BODY tag. */
+        public const string TOPMARGIN = "topmargin";
+    
+        /** This is a possible HTML attribute for the BODY tag. */
+        public const string BOTTOMMARGIN = "bottommargin";
+    
+        /** This is a possible HTML attribute for the BODY tag. */
+        public const string LEFTMARGIN = "leftmargin";
+    
+        /** This is a possible HTML attribute for the BODY tag. */
+        public const string RIGHTMARGIN = "rightmargin";
+    
+        // Phrases, Anchors, Lists and Paragraphs
+    
+        /** the chunk tag */
+        public const string CHUNK = "font";
+    
+        /** the phrase tag */
+        public const string CODE = "code";
+    
+        /** the phrase tag */
+        public const string VAR = "var";
+    
+        /** the anchor tag */
+        public const string ANCHOR = "a";
+    
+        /** the list tag */
+        public const string ORDEREDLIST = "ol";
+    
+        /** the list tag */
+        public const string UNORDEREDLIST = "ul";
+    
+        /** the listitem tag */
+        public const string LISTITEM = "li";
+    
+        /** the paragraph tag */
+        public const string PARAGRAPH = "p";
+    
+        /** attribute of anchor tag */
+        public const string NAME = "name";
+    
+        /** attribute of anchor tag */
+        public const string REFERENCE = "href";
+    
+        /** attribute of anchor tag */
+        public static string[] H = {"h1", "h2", "h3", "h4", "h5", "h6"};
+    
+        // Chunks
+    
+        /** attribute of the chunk tag */
+        public const string FONT = "face";
+    
+        /** attribute of the chunk tag */
+        public const string SIZE = "point-size";
+    
+        /** attribute of the chunk/table/cell tag */
+        public const string COLOR = "color";
+    
+        /** some phrase tag */
+        public const string EM = "em";
+    
+        /** some phrase tag */
+        public const string I = "i";
+    
+        /** some phrase tag */
+        public const string STRONG = "strong";
+    
+        /** some phrase tag */
+        public const string B = "b";
+    
+        /** some phrase tag */
+        public const string S = "s";
+    
+        /** some phrase tag */
+        public const string U = "u";
+    
+        /** some phrase tag */
+        public const string SUB = "sub";
+    
+        /** some phrase tag */
+        public const string SUP = "sup";
+    
+        /** the possible value of a tag */
+        public const string HORIZONTALRULE = "hr";
+    
+        // tables/cells
+    
+        /** the table tag */
+        public const string TABLE = "table";
+    
+        /** the cell tag */
+        public const string ROW = "tr";
+    
+        /** the cell tag */
+        public const string CELL = "td";
+    
+        /** attribute of the cell tag */
+        public const string HEADERCELL = "th";
+    
+        /** attribute of the table tag */
+        public const string COLUMNS = "cols";
+    
+        /** attribute of the table tag */
+        public const string CELLPADDING = "cellpadding";
+    
+        /** attribute of the table tag */
+        public const string CELLSPACING = "cellspacing";
+    
+        /** attribute of the cell tag */
+        public const string COLSPAN = "colspan";
+    
+        /** attribute of the cell tag */
+        public const string ROWSPAN = "rowspan";
+    
+        /** attribute of the cell tag */
+        public const string NOWRAP = "nowrap";
+    
+        /** attribute of the table/cell tag */
+        public const string BORDERWIDTH = "border";
+    
+        /** attribute of the table/cell tag */
+        public const string WIDTH = "width";
+    
+        /** attribute of the table/cell tag */
+        public const string BACKGROUNDCOLOR = "bgcolor";
+    
+        /** attribute of the table/cell tag */
+        public const string BORDERCOLOR = "bordercolor";
+    
+        /** attribute of paragraph/image/table tag */
+        public const string ALIGN = "align";
+    
+        /** attribute of chapter/section/paragraph/table/cell tag */
+        public const string LEFT = "left";
+    
+        /** attribute of chapter/section/paragraph/table/cell tag */
+        public const string RIGHT = "right";
+    
+        /** attribute of the cell tag */
+        public const string HORIZONTALALIGN = "align";
+    
+        /** attribute of the cell tag */
+        public const string VERTICALALIGN = "valign";
+    
+        /** attribute of the table/cell tag */
+        public const string TOP = "top";
+    
+        /** attribute of the table/cell tag */
+        public const string BOTTOM = "bottom";
+    
+        // Misc
+    
+        /** the image tag */
+        public const string IMAGE = "img";
+    
+        /** attribute of the image tag */
+        public const string URL = "src";
+    
+        /** attribute of the image tag */
+        public const string ALT = "alt";
+    
+        /** attribute of the image tag */
+        public const string PLAINWIDTH = "width";
+    
+        /** attribute of the image tag */
+        public const string PLAINHEIGHT = "height";
+    
+        /** the newpage tag */
+        public const string NEWLINE = "br";
+    
+        // alignment attribute values
+    
+        /** the possible value of an alignment attribute */
+        public const string ALIGN_LEFT = "Left";
+    
+        /** the possible value of an alignment attribute */
+        public const string ALIGN_CENTER = "Center";
+    
+        /** the possible value of an alignment attribute */
+        public const string ALIGN_RIGHT = "Right";
+    
+        /** the possible value of an alignment attribute */
+        public const string ALIGN_JUSTIFIED = "Justify";
+    
+        /** the possible value of an alignment attribute */
+        public const string ALIGN_TOP = "Top";
+    
+        /** the possible value of an alignment attribute */
+        public const string ALIGN_MIDDLE = "Middle";
+    
+        /** the possible value of an alignment attribute */
+        public const string ALIGN_BOTTOM = "Bottom";
+    
+        /** the possible value of an alignment attribute */
+        public const string ALIGN_BASELINE = "Baseline";
+    
+        /** the possible value of an alignment attribute */
+        public const string DEFAULT = "Default";
+
+        /** The DIV tag. */
+        public const string DIV = "div";
+
+        /** The SPAN tag. */
+        public const string SPAN = "span";
+        /** The LINK tag. */
+        public const string LINK = "link";
+        
+        /** This is a possible HTML attribute for the LINK tag. */
+        public const string TEXT_CSS = "text/css";
+
+        /** This is a possible HTML attribute for the LINK tag. */
+        public const string REL = "rel";
+
+        /** This is used for inline css style information */
+        public const string STYLE = "style";
+
+        /** This is a possible HTML attribute for the LINK tag. */
+        public const string TYPE = "type";
+
+        /** This is a possible HTML attribute. */
+        public const string STYLESHEET = "stylesheet";
+    }
+}

src/core/iTextSharp/text/html/ITextmyHtmlHandler.cs

@@ -0,0 +1,239 @@
+using System;
+using System.Collections;
+using System.Globalization;
+using System.util;
+using iTextSharp.text;
+using iTextSharp.text.xml;
+using iTextSharp.text.pdf;
+using iTextSharp.text.factories;
+
+/*
+ * $Id: ITextmyHtmlHandler.cs,v 1.9 2008/05/13 11:25:15 psoares33 Exp $
+ * 
+ *
+ * Copyright 2001, 2002 by Bruno Lowagie.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+
+namespace iTextSharp.text.html {
+
+    /**
+    * The <CODE>Tags</CODE>-class maps several XHTML-tags to iText-objects.
+    */
+
+    public class ITextmyHtmlHandler : ITextHandler {
+        
+    /** These are the properties of the body section. */
+        private Properties bodyAttributes = new Properties();
+        
+    /** This is the status of the table border. */
+        private bool tableBorder = false;
+        
+    /**
+    * Constructs a new SAXiTextHandler that will translate all the events
+    * triggered by the parser to actions on the <CODE>Document</CODE>-object.
+    *
+    * @param   document    this is the document on which events must be triggered
+    */
+        
+        public ITextmyHtmlHandler(IDocListener document) : base(document, new HtmlTagMap()) {
+        }
+        
+        public ITextmyHtmlHandler(IDocListener document, BaseFont bf) : base(document, new HtmlTagMap(), bf) {
+        }
+
+    /**
+    * Constructs a new SAXiTextHandler that will translate all the events
+    * triggered by the parser to actions on the <CODE>Document</CODE>-object.
+    *
+    * @param   document    this is the document on which events must be triggered
+    * @param htmlTags a tagmap translating HTML tags to iText tags
+    */
+        
+        public ITextmyHtmlHandler(IDocListener document, Hashtable htmlTags) : base(document, htmlTags) {
+        }
+        
+    /**
+    * 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.IsHtml(name)) {
+                // we do nothing
+                return;
+            }
+            if (HtmlTagMap.IsHead(name)) {
+                // we do nothing
+                return;
+            }
+            if (HtmlTagMap.IsTitle(name)) {
+                // we do nothing
+                return;
+            }
+            if (HtmlTagMap.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.IsLink(name)) {
+                // we do nothing for the moment, in a later version we could extract the style sheet
+                return;
+            }
+            if (HtmlTagMap.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 (ElementTags.TABLE.Equals(peer.Tag) || ElementTags.CELL.Equals(peer.Tag)) {
+                    Properties p = peer.GetAttributes(attrs);
+                    String value;
+                    if (ElementTags.TABLE.Equals(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);
+        }
+        
+    /**
+    * This method gets called when an end 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 ends
+    */
+        
+        public override void EndElement(String uri, String lname, String name) {
+            //System.err.Println("End: " + name);
+            name = name.ToLower(CultureInfo.InvariantCulture);
+            if (ElementTags.PARAGRAPH.Equals(name)) {
+                document.Add((IElement) stack.Pop());
+                return;
+            }        
+            if (HtmlTagMap.IsHead(name)) {
+                // we do nothing
+                return;
+            }
+            if (HtmlTagMap.IsTitle(name)) {
+                if (currentChunk != null) {
+                    bodyAttributes.Add(ElementTags.TITLE, currentChunk.Content);
+                }
+                return;
+            }
+            if (HtmlTagMap.IsMeta(name)) {
+                // we do nothing
+                return;
+            }
+            if (HtmlTagMap.IsLink(name)) {
+                // we do nothing
+                return;
+            }
+            if (HtmlTagMap.IsBody(name)) {
+                // we do nothing
+                return;
+            }
+            if (myTags.ContainsKey(name)) {
+                XmlPeer peer = (XmlPeer) myTags[name];
+                if (ElementTags.TABLE.Equals(peer.Tag)) {
+                    tableBorder = false;
+                }
+                base.HandleEndingTags(peer.Tag);
+                return;
+            }
+            // super.handleEndingTags is replaced with handleEndingTags
+            // suggestion by Ken Auer
+            HandleEndingTags(name);
+        }
+    }
+}

src/core/iTextSharp/text/html/Markup.cs

@@ -0,0 +1,427 @@
+using System;
+using System.util;
+using System.IO;
+using System.Text;
+using System.Collections;
+using System.Globalization;
+using iTextSharp.text;
+
+/*
+ * $Id: Markup.cs,v 1.2 2008/05/13 11:25:16 psoares33 Exp $
+ * 
+ *
+ * Copyright 2001, 2002 by Bruno Lowagie.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+
+namespace iTextSharp.text.html {
+    /// <summary>
+    /// A class that contains all the possible tagnames and their attributes.
+    /// </summary>
+    public class Markup {
+        // iText specific
+        
+        /** the key for any tag */
+        public const string ITEXT_TAG = "tag";
+
+        // HTML tags
+
+        /** the markup for the body part of a file */
+        public const string HTML_TAG_BODY = "body";
+        
+        /** The DIV tag. */
+        public const string HTML_TAG_DIV = "div";
+
+        /** This is a possible HTML-tag. */
+        public const string HTML_TAG_LINK = "link";
+
+        /** The SPAN tag. */
+        public const string HTML_TAG_SPAN = "span";
+
+        // HTML attributes
+
+        /** the height attribute. */
+        public const string HTML_ATTR_HEIGHT = "height";
+
+        /** the hyperlink reference attribute. */
+        public const string HTML_ATTR_HREF = "href";
+
+        /** This is a possible HTML attribute for the LINK tag. */
+        public const string HTML_ATTR_REL = "rel";
+
+        /** This is used for inline css style information */
+        public const string HTML_ATTR_STYLE = "style";
+
+        /** This is a possible HTML attribute for the LINK tag. */
+        public const string HTML_ATTR_TYPE = "type";
+
+        /** This is a possible HTML attribute. */
+        public const string HTML_ATTR_STYLESHEET = "stylesheet";
+
+        /** the width attribute. */
+        public const string HTML_ATTR_WIDTH = "width";
+
+        /** attribute for specifying externally defined CSS class */
+        public const string HTML_ATTR_CSS_CLASS = "class";
+
+        /** The ID attribute. */
+        public const string HTML_ATTR_CSS_ID = "id";
+
+        // HTML values
+        
+        /** This is a possible value for the language attribute (SCRIPT tag). */
+        public const string HTML_VALUE_JAVASCRIPT = "text/javascript";
+        
+        /** This is a possible HTML attribute for the LINK tag. */
+        public const string HTML_VALUE_CSS = "text/css";
+
+        // CSS keys
+
+        /** the CSS tag for background color */
+        public const string CSS_KEY_BGCOLOR = "background-color";
+
+        /** the CSS tag for text color */
+        public const string CSS_KEY_COLOR = "color";
+
+        /** CSS key that indicate the way something has to be displayed */
+        public const string CSS_KEY_DISPLAY = "display";
+
+        /** the CSS tag for the font family */
+        public const string CSS_KEY_FONTFAMILY = "font-family";
+
+        /** the CSS tag for the font size */
+        public const string CSS_KEY_FONTSIZE = "font-size";
+
+        /** the CSS tag for the font style */
+        public const string CSS_KEY_FONTSTYLE = "font-style";
+
+        /** the CSS tag for the font weight */
+        public const string CSS_KEY_FONTWEIGHT = "font-weight";
+
+        /** the CSS tag for text decorations */
+        public const string CSS_KEY_LINEHEIGHT = "line-height";
+
+        /** the CSS tag for the margin of an object */
+        public const string CSS_KEY_MARGIN = "margin";
+
+        /** the CSS tag for the margin of an object */
+        public const string CSS_KEY_MARGINLEFT = "margin-left";
+
+        /** the CSS tag for the margin of an object */
+        public const string CSS_KEY_MARGINRIGHT = "margin-right";
+
+        /** the CSS tag for the margin of an object */
+        public const string CSS_KEY_MARGINTOP = "margin-top";
+
+        /** the CSS tag for the margin of an object */
+        public const string CSS_KEY_MARGINBOTTOM = "margin-bottom";
+
+        /** the CSS tag for the margin of an object */
+        public const String CSS_KEY_PADDING = "padding";
+
+        /** the CSS tag for the margin of an object */
+        public const String CSS_KEY_PADDINGLEFT = "padding-left";
+
+        /** the CSS tag for the margin of an object */
+        public const String CSS_KEY_PADDINGRIGHT = "padding-right";
+
+        /** the CSS tag for the margin of an object */
+        public const String CSS_KEY_PADDINGTOP = "padding-top";
+
+        /** the CSS tag for the margin of an object */
+        public const String CSS_KEY_PADDINGBOTTOM = "padding-bottom";
+
+        /** the CSS tag for the margin of an object */
+        public const String CSS_KEY_BORDERCOLOR = "border-color";
+
+        /** the CSS tag for the margin of an object */
+        public const String CSS_KEY_BORDERWIDTH = "border-width";
+
+        /** the CSS tag for the margin of an object */
+        public const String CSS_KEY_BORDERWIDTHLEFT = "border-left-width";
+
+        /** the CSS tag for the margin of an object */
+        public const String CSS_KEY_BORDERWIDTHRIGHT = "border-right-width";
+
+        /** the CSS tag for the margin of an object */
+        public const String CSS_KEY_BORDERWIDTHTOP = "border-top-width";
+
+        /** the CSS tag for the margin of an object */
+        public const String CSS_KEY_BORDERWIDTHBOTTOM = "border-bottom-width";
+
+        /** the CSS tag for adding a page break when the document is printed */
+        public const string CSS_KEY_PAGE_BREAK_AFTER = "page-break-after";
+
+        /** the CSS tag for adding a page break when the document is printed */
+        public const string CSS_KEY_PAGE_BREAK_BEFORE = "page-break-before";
+
+        /** the CSS tag for the horizontal alignment of an object */
+        public const string CSS_KEY_TEXTALIGN = "text-align";
+
+        /** the CSS tag for text decorations */
+        public const string CSS_KEY_TEXTDECORATION = "text-decoration";
+
+        /** the CSS tag for text decorations */
+        public const string CSS_KEY_VERTICALALIGN = "vertical-align";
+
+        /** the CSS tag for the visibility of objects */
+        public const string CSS_KEY_VISIBILITY = "visibility";
+
+        // CSS values
+
+        /** value for the CSS tag for adding a page break when the document is printed */
+        public const string CSS_VALUE_ALWAYS = "always";
+
+        /** A possible value for the DISPLAY key */
+        public const string CSS_VALUE_BLOCK = "block";
+
+        /** a CSS value for text font weight */
+        public const string CSS_VALUE_BOLD = "bold";
+
+        /** the value if you want to hide objects. */
+        public const string CSS_VALUE_HIDDEN = "hidden";
+
+        /** A possible value for the DISPLAY key */
+        public const string CSS_VALUE_INLINE = "inline";
+        
+        /** a CSS value for text font style */
+        public const string CSS_VALUE_ITALIC = "italic";
+
+        /** a CSS value for text decoration */
+        public const string CSS_VALUE_LINETHROUGH = "line-through";
+
+        /** A possible value for the DISPLAY key */
+        public const string CSS_VALUE_LISTITEM = "list-item";
+        
+        /** a CSS value */
+        public const string CSS_VALUE_NONE = "none";
+
+        /** a CSS value */
+        public const string CSS_VALUE_NORMAL = "normal";
+
+        /** a CSS value for text font style */
+        public const string CSS_VALUE_OBLIQUE = "oblique";
+
+        /** A possible value for the DISPLAY key */
+        public const string CSS_VALUE_TABLE = "table";
+
+        /** A possible value for the DISPLAY key */
+        public const string CSS_VALUE_TABLEROW = "table-row";
+
+        /** A possible value for the DISPLAY key */
+        public const string CSS_VALUE_TABLECELL = "table-cell";
+
+        /** the CSS value for a horizontal alignment of an object */
+        public const string CSS_VALUE_TEXTALIGNLEFT = "left";
+
+        /** the CSS value for a horizontal alignment of an object */
+        public const string CSS_VALUE_TEXTALIGNRIGHT = "right";
+
+        /** the CSS value for a horizontal alignment of an object */
+        public const string CSS_VALUE_TEXTALIGNCENTER = "center";
+
+        /** the CSS value for a horizontal alignment of an object */
+        public const string CSS_VALUE_TEXTALIGNJUSTIFY = "justify";
+
+        /** a CSS value for text decoration */
+        public const string CSS_VALUE_UNDERLINE = "underline";
+
+        /// <summary>
+        /// Parses a length.
+        /// </summary>
+        /// <param name="str">a length in the form of an optional + or -, followed by a number and a unit.</param>
+        /// <returns>a float</returns>
+        public static float ParseLength(string str) {
+            int pos = 0;
+            int length = str.Length;
+            bool ok = true;
+            while (ok && pos < length) {
+                switch (str[pos]) {
+                    case '+':
+                    case '-':
+                    case '0':
+                    case '1':
+                    case '2':
+                    case '3':
+                    case '4':
+                    case '5':
+                    case '6':
+                    case '7':
+                    case '8':
+                    case '9':
+                    case '.':
+                        pos++;
+                        break;
+                    default:
+                        ok = false;
+                        break;
+                }
+            }
+            if (pos == 0) return 0f;
+            if (pos == length) return float.Parse(str, System.Globalization.NumberFormatInfo.InvariantInfo);
+            float f = float.Parse(str.Substring(0, pos), System.Globalization.NumberFormatInfo.InvariantInfo);
+            str = str.Substring(pos);
+            // inches
+            if (str.StartsWith("in")) {
+                return f * 72f;
+            }
+            // centimeters
+            if (str.StartsWith("cm")) {
+                return (f / 2.54f) * 72f;
+            }
+            // millimeters
+            if (str.StartsWith("mm")) {
+                return (f / 25.4f) * 72f;
+            }
+            // picas
+            if (str.StartsWith("pc")) {
+                return f * 12f;
+            }
+            // default: we assume the length was measured in points
+            return f;
+        }
+    
+        /// <summary>
+        /// Converts a <CODE>Color</CODE> into a HTML representation of this <CODE>Color</CODE>.
+        /// </summary>
+        /// <param name="color">the <CODE>Color</CODE> that has to be converted.</param>
+        /// <returns>the HTML representation of this <CODE>Color</CODE></returns>
+        public static Color DecodeColor(String s) {
+            if (s == null)
+                return null;
+            s = s.ToLower(CultureInfo.InvariantCulture).Trim();
+            Color c = (Color)WebColors.GetRGBColor(s);
+            if (c != null)
+                return c;
+            try {
+                if (s.StartsWith("#")) {
+                    if (s.Length == 4)
+                        s = "#" + s.Substring(1, 1) + s.Substring(1, 1)
+                            + s.Substring(2, 1) + s.Substring(2, 1) 
+                            + s.Substring(3, 1) + s.Substring(3, 1);
+                    if (s.Length == 7)
+                        return new Color(int.Parse(s.Substring(1), NumberStyles.HexNumber));
+                }
+                else if (s.StartsWith("rgb")) {
+                    StringTokenizer tk = new StringTokenizer(s.Substring(3), " \t\r\n\f(),");
+                    int[] cc = new int [3];
+                    for (int k = 0; k < 3; ++k) {
+                        if (!tk.HasMoreTokens())
+                            return null;
+                        String t = tk.NextToken();
+                        float n;
+                        if (t.EndsWith("%")) {
+                            n = float.Parse(t.Substring(0, t.Length - 1), System.Globalization.NumberFormatInfo.InvariantInfo);
+                            n = n * 255f / 100f;
+                        }
+                        else
+                            n = float.Parse(t, System.Globalization.NumberFormatInfo.InvariantInfo);
+                        int ni = (int)n;
+                        if (ni > 255)
+                            ni = 255;
+                        else if (ni < 0)
+                            ni = 0;
+                        cc[k] = ni;
+                    }
+                    return new Color(cc[0], cc[1], cc[2]);
+                }
+            }
+            catch {
+            }
+            return null;
+        }
+
+        /// <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;
+        }
+
+        /**
+        * Removes the comments sections of a String.
+        * 
+        * @param string
+        *            the original String
+        * @param startComment
+        *            the String that marks the start of a Comment section
+        * @param endComment
+        *            the String that marks the end of a Comment section.
+        * @return the String stripped of its comment section
+        */
+        public static string RemoveComment(String str, String startComment,
+                String endComment) {
+            StringBuilder result = new StringBuilder();
+            int pos = 0;
+            int end = endComment.Length;
+            int start = str.IndexOf(startComment, pos);
+            while (start > -1) {
+                result.Append(str.Substring(pos, start - pos));
+                pos = str.IndexOf(endComment, start) + end;
+                start = str.IndexOf(startComment, pos);
+            }
+            result.Append(str.Substring(pos));
+            return result.ToString();
+        }
+    }
+}

src/core/iTextSharp/text/html/WebColors.cs

@@ -0,0 +1,263 @@
+using System;
+using System.Collections;
+using System.Globalization;
+using iTextSharp.text;
+using System.util;
+/*
+ * $Id: WebColors.cs,v 1.3 2008/05/13 11:25:16 psoares33 Exp $
+ * 
+ *
+ * Copyright 2001, 2002 by Bruno Lowagie.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+
+namespace iTextSharp.text.html {
+
+    /**
+    * This class is a HashMap that contains the names of colors as a key and the
+    * corresponding Color as value. (Source: Wikipedia
+    * http://en.wikipedia.org/wiki/Web_colors )
+    * 
+    * @author blowagie
+    */
+    public class WebColors : Hashtable {
+
+        public static WebColors NAMES = new WebColors();
+        static WebColors() {
+            NAMES["aliceblue"] = new int[] { 0xf0, 0xf8, 0xff, 0x00 };
+            NAMES["antiquewhite"] = new int[] { 0xfa, 0xeb, 0xd7, 0x00 };
+            NAMES["aqua"] = new int[] { 0x00, 0xff, 0xff, 0x00 };
+            NAMES["aquamarine"] = new int[] { 0x7f, 0xff, 0xd4, 0x00 };
+            NAMES["azure"] = new int[] { 0xf0, 0xff, 0xff, 0x00 };
+            NAMES["beige"] = new int[] { 0xf5, 0xf5, 0xdc, 0x00 };
+            NAMES["bisque"] = new int[] { 0xff, 0xe4, 0xc4, 0x00 };
+            NAMES["black"] = new int[] { 0x00, 0x00, 0x00, 0x00 };
+            NAMES["blanchedalmond"] = new int[] { 0xff, 0xeb, 0xcd, 0x00 };
+            NAMES["blue"] = new int[] { 0x00, 0x00, 0xff, 0x00 };
+            NAMES["blueviolet"] = new int[] { 0x8a, 0x2b, 0xe2, 0x00 };
+            NAMES["brown"] = new int[] { 0xa5, 0x2a, 0x2a, 0x00 };
+            NAMES["burlywood"] = new int[] { 0xde, 0xb8, 0x87, 0x00 };
+            NAMES["cadetblue"] = new int[] { 0x5f, 0x9e, 0xa0, 0x00 };
+            NAMES["chartreuse"] = new int[] { 0x7f, 0xff, 0x00, 0x00 };
+            NAMES["chocolate"] = new int[] { 0xd2, 0x69, 0x1e, 0x00 };
+            NAMES["coral"] = new int[] { 0xff, 0x7f, 0x50, 0x00 };
+            NAMES["cornflowerblue"] = new int[] { 0x64, 0x95, 0xed, 0x00 };
+            NAMES["cornsilk"] = new int[] { 0xff, 0xf8, 0xdc, 0x00 };
+            NAMES["crimson"] = new int[] { 0xdc, 0x14, 0x3c, 0x00 };
+            NAMES["cyan"] = new int[] { 0x00, 0xff, 0xff, 0x00 };
+            NAMES["darkblue"] = new int[] { 0x00, 0x00, 0x8b, 0x00 };
+            NAMES["darkcyan"] = new int[] { 0x00, 0x8b, 0x8b, 0x00 };
+            NAMES["darkgoldenrod"] = new int[] { 0xb8, 0x86, 0x0b, 0x00 };
+            NAMES["darkgray"] = new int[] { 0xa9, 0xa9, 0xa9, 0x00 };
+            NAMES["darkgreen"] = new int[] { 0x00, 0x64, 0x00, 0x00 };
+            NAMES["darkkhaki"] = new int[] { 0xbd, 0xb7, 0x6b, 0x00 };
+            NAMES["darkmagenta"] = new int[] { 0x8b, 0x00, 0x8b, 0x00 };
+            NAMES["darkolivegreen"] = new int[] { 0x55, 0x6b, 0x2f, 0x00 };
+            NAMES["darkorange"] = new int[] { 0xff, 0x8c, 0x00, 0x00 };
+            NAMES["darkorchid"] = new int[] { 0x99, 0x32, 0xcc, 0x00 };
+            NAMES["darkred"] = new int[] { 0x8b, 0x00, 0x00, 0x00 };
+            NAMES["darksalmon"] = new int[] { 0xe9, 0x96, 0x7a, 0x00 };
+            NAMES["darkseagreen"] = new int[] { 0x8f, 0xbc, 0x8f, 0x00 };
+            NAMES["darkslateblue"] = new int[] { 0x48, 0x3d, 0x8b, 0x00 };
+            NAMES["darkslategray"] = new int[] { 0x2f, 0x4f, 0x4f, 0x00 };
+            NAMES["darkturquoise"] = new int[] { 0x00, 0xce, 0xd1, 0x00 };
+            NAMES["darkviolet"] = new int[] { 0x94, 0x00, 0xd3, 0x00 };
+            NAMES["deeppink"] = new int[] { 0xff, 0x14, 0x93, 0x00 };
+            NAMES["deepskyblue"] = new int[] { 0x00, 0xbf, 0xff, 0x00 };
+            NAMES["dimgray"] = new int[] { 0x69, 0x69, 0x69, 0x00 };
+            NAMES["dodgerblue"] = new int[] { 0x1e, 0x90, 0xff, 0x00 };
+            NAMES["firebrick"] = new int[] { 0xb2, 0x22, 0x22, 0x00 };
+            NAMES["floralwhite"] = new int[] { 0xff, 0xfa, 0xf0, 0x00 };
+            NAMES["forestgreen"] = new int[] { 0x22, 0x8b, 0x22, 0x00 };
+            NAMES["fuchsia"] = new int[] { 0xff, 0x00, 0xff, 0x00 };
+            NAMES["gainsboro"] = new int[] { 0xdc, 0xdc, 0xdc, 0x00 };
+            NAMES["ghostwhite"] = new int[] { 0xf8, 0xf8, 0xff, 0x00 };
+            NAMES["gold"] = new int[] { 0xff, 0xd7, 0x00, 0x00 };
+            NAMES["goldenrod"] = new int[] { 0xda, 0xa5, 0x20, 0x00 };
+            NAMES["gray"] = new int[] { 0x80, 0x80, 0x80, 0x00 };
+            NAMES["green"] = new int[] { 0x00, 0x80, 0x00, 0x00 };
+            NAMES["greenyellow"] = new int[] { 0xad, 0xff, 0x2f, 0x00 };
+            NAMES["honeydew"] = new int[] { 0xf0, 0xff, 0xf0, 0x00 };
+            NAMES["hotpink"] = new int[] { 0xff, 0x69, 0xb4, 0x00 };
+            NAMES["indianred"] = new int[] { 0xcd, 0x5c, 0x5c, 0x00 };
+            NAMES["indigo"] = new int[] { 0x4b, 0x00, 0x82, 0x00 };
+            NAMES["ivory"] = new int[] { 0xff, 0xff, 0xf0, 0x00 };
+            NAMES["khaki"] = new int[] { 0xf0, 0xe6, 0x8c, 0x00 };
+            NAMES["lavender"] = new int[] { 0xe6, 0xe6, 0xfa, 0x00 };
+            NAMES["lavenderblush"] = new int[] { 0xff, 0xf0, 0xf5, 0x00 };
+            NAMES["lawngreen"] = new int[] { 0x7c, 0xfc, 0x00, 0x00 };
+            NAMES["lemonchiffon"] = new int[] { 0xff, 0xfa, 0xcd, 0x00 };
+            NAMES["lightblue"] = new int[] { 0xad, 0xd8, 0xe6, 0x00 };
+            NAMES["lightcoral"] = new int[] { 0xf0, 0x80, 0x80, 0x00 };
+            NAMES["lightcyan"] = new int[] { 0xe0, 0xff, 0xff, 0x00 };
+            NAMES["lightgoldenrodyellow"] = new int[] { 0xfa, 0xfa, 0xd2, 0x00 };
+            NAMES["lightgreen"] = new int[] { 0x90, 0xee, 0x90, 0x00 };
+            NAMES["lightgrey"] = new int[] { 0xd3, 0xd3, 0xd3, 0x00 };
+            NAMES["lightpink"] = new int[] { 0xff, 0xb6, 0xc1, 0x00 };
+            NAMES["lightsalmon"] = new int[] { 0xff, 0xa0, 0x7a, 0x00 };
+            NAMES["lightseagreen"] = new int[] { 0x20, 0xb2, 0xaa, 0x00 };
+            NAMES["lightskyblue"] = new int[] { 0x87, 0xce, 0xfa, 0x00 };
+            NAMES["lightslategray"] = new int[] { 0x77, 0x88, 0x99, 0x00 };
+            NAMES["lightsteelblue"] = new int[] { 0xb0, 0xc4, 0xde, 0x00 };
+            NAMES["lightyellow"] = new int[] { 0xff, 0xff, 0xe0, 0x00 };
+            NAMES["lime"] = new int[] { 0x00, 0xff, 0x00, 0x00 };
+            NAMES["limegreen"] = new int[] { 0x32, 0xcd, 0x32, 0x00 };
+            NAMES["linen"] = new int[] { 0xfa, 0xf0, 0xe6, 0x00 };
+            NAMES["magenta"] = new int[] { 0xff, 0x00, 0xff, 0x00 };
+            NAMES["maroon"] = new int[] { 0x80, 0x00, 0x00, 0x00 };
+            NAMES["mediumaquamarine"] = new int[] { 0x66, 0xcd, 0xaa, 0x00 };
+            NAMES["mediumblue"] = new int[] { 0x00, 0x00, 0xcd, 0x00 };
+            NAMES["mediumorchid"] = new int[] { 0xba, 0x55, 0xd3, 0x00 };
+            NAMES["mediumpurple"] = new int[] { 0x93, 0x70, 0xdb, 0x00 };
+            NAMES["mediumseagreen"] = new int[] { 0x3c, 0xb3, 0x71, 0x00 };
+            NAMES["mediumslateblue"] = new int[] { 0x7b, 0x68, 0xee, 0x00 };
+            NAMES["mediumspringgreen"] = new int[] { 0x00, 0xfa, 0x9a, 0x00 };
+            NAMES["mediumturquoise"] = new int[] { 0x48, 0xd1, 0xcc, 0x00 };
+            NAMES["mediumvioletred"] = new int[] { 0xc7, 0x15, 0x85, 0x00 };
+            NAMES["midnightblue"] = new int[] { 0x19, 0x19, 0x70, 0x00 };
+            NAMES["mintcream"] = new int[] { 0xf5, 0xff, 0xfa, 0x00 };
+            NAMES["mistyrose"] = new int[] { 0xff, 0xe4, 0xe1, 0x00 };
+            NAMES["moccasin"] = new int[] { 0xff, 0xe4, 0xb5, 0x00 };
+            NAMES["navajowhite"] = new int[] { 0xff, 0xde, 0xad, 0x00 };
+            NAMES["navy"] = new int[] { 0x00, 0x00, 0x80, 0x00 };
+            NAMES["oldlace"] = new int[] { 0xfd, 0xf5, 0xe6, 0x00 };
+            NAMES["olive"] = new int[] { 0x80, 0x80, 0x00, 0x00 };
+            NAMES["olivedrab"] = new int[] { 0x6b, 0x8e, 0x23, 0x00 };
+            NAMES["orange"] = new int[] { 0xff, 0xa5, 0x00, 0x00 };
+            NAMES["orangered"] = new int[] { 0xff, 0x45, 0x00, 0x00 };
+            NAMES["orchid"] = new int[] { 0xda, 0x70, 0xd6, 0x00 };
+            NAMES["palegoldenrod"] = new int[] { 0xee, 0xe8, 0xaa, 0x00 };
+            NAMES["palegreen"] = new int[] { 0x98, 0xfb, 0x98, 0x00 };
+            NAMES["paleturquoise"] = new int[] { 0xaf, 0xee, 0xee, 0x00 };
+            NAMES["palevioletred"] = new int[] { 0xdb, 0x70, 0x93, 0x00 };
+            NAMES["papayawhip"] = new int[] { 0xff, 0xef, 0xd5, 0x00 };
+            NAMES["peachpuff"] = new int[] { 0xff, 0xda, 0xb9, 0x00 };
+            NAMES["peru"] = new int[] { 0xcd, 0x85, 0x3f, 0x00 };
+            NAMES["pink"] = new int[] { 0xff, 0xc0, 0xcb, 0x00 };
+            NAMES["plum"] = new int[] { 0xdd, 0xa0, 0xdd, 0x00 };
+            NAMES["powderblue"] = new int[] { 0xb0, 0xe0, 0xe6, 0x00 };
+            NAMES["purple"] = new int[] { 0x80, 0x00, 0x80, 0x00 };
+            NAMES["red"] = new int[] { 0xff, 0x00, 0x00, 0x00 };
+            NAMES["rosybrown"] = new int[] { 0xbc, 0x8f, 0x8f, 0x00 };
+            NAMES["royalblue"] = new int[] { 0x41, 0x69, 0xe1, 0x00 };
+            NAMES["saddlebrown"] = new int[] { 0x8b, 0x45, 0x13, 0x00 };
+            NAMES["salmon"] = new int[] { 0xfa, 0x80, 0x72, 0x00 };
+            NAMES["sandybrown"] = new int[] { 0xf4, 0xa4, 0x60, 0x00 };
+            NAMES["seagreen"] = new int[] { 0x2e, 0x8b, 0x57, 0x00 };
+            NAMES["seashell"] = new int[] { 0xff, 0xf5, 0xee, 0x00 };
+            NAMES["sienna"] = new int[] { 0xa0, 0x52, 0x2d, 0x00 };
+            NAMES["silver"] = new int[] { 0xc0, 0xc0, 0xc0, 0x00 };
+            NAMES["skyblue"] = new int[] { 0x87, 0xce, 0xeb, 0x00 };
+            NAMES["slateblue"] = new int[] { 0x6a, 0x5a, 0xcd, 0x00 };
+            NAMES["slategray"] = new int[] { 0x70, 0x80, 0x90, 0x00 };
+            NAMES["snow"] = new int[] { 0xff, 0xfa, 0xfa, 0x00 };
+            NAMES["springgreen"] = new int[] { 0x00, 0xff, 0x7f, 0x00 };
+            NAMES["steelblue"] = new int[] { 0x46, 0x82, 0xb4, 0x00 };
+            NAMES["tan"] = new int[] { 0xd2, 0xb4, 0x8c, 0x00 };
+            NAMES["transparent"] = new int[] { 0x00, 0x00, 0x00, 0xff };
+            NAMES["teal"] = new int[] { 0x00, 0x80, 0x80, 0x00 };
+            NAMES["thistle"] = new int[] { 0xd8, 0xbf, 0xd8, 0x00 };
+            NAMES["tomato"] = new int[] { 0xff, 0x63, 0x47, 0x00 };
+            NAMES["turquoise"] = new int[] { 0x40, 0xe0, 0xd0, 0x00 };
+            NAMES["violet"] = new int[] { 0xee, 0x82, 0xee, 0x00 };
+            NAMES["wheat"] = new int[] { 0xf5, 0xde, 0xb3, 0x00 };
+            NAMES["white"] = new int[] { 0xff, 0xff, 0xff, 0x00 };
+            NAMES["whitesmoke"] = new int[] { 0xf5, 0xf5, 0xf5, 0x00 };
+            NAMES["yellow"] = new int[] { 0xff, 0xff, 0x00, 0x00 };
+            NAMES["yellowgreen"] = new int[] { 0x9, 0xacd, 0x32, 0x00 };
+        }
+        
+        /**
+        * Gives you a Color based on a name.
+        * 
+        * @param name
+        *            a name such as black, violet, cornflowerblue or #RGB or #RRGGBB
+        *            or rgb(R,G,B)
+        * @return the corresponding Color object
+        * @throws IllegalArgumentException
+        *             if the String isn't a know representation of a color.
+        */
+        public static Color GetRGBColor(String name) {
+            int[] c = { 0, 0, 0, 0 };
+            if (name.StartsWith("#")) {
+                if (name.Length == 4) {
+                    c[0] = int.Parse(name.Substring(1, 1), NumberStyles.HexNumber) * 16;
+                    c[1] = int.Parse(name.Substring(2, 1), NumberStyles.HexNumber) * 16;
+                    c[2] = int.Parse(name.Substring(3), NumberStyles.HexNumber) * 16;
+                    return new Color(c[0], c[1], c[2], c[3]);
+                }
+                if (name.Length == 7) {
+                    c[0] = int.Parse(name.Substring(1, 2), NumberStyles.HexNumber);
+                    c[1] = int.Parse(name.Substring(3, 2), NumberStyles.HexNumber);
+                    c[2] = int.Parse(name.Substring(5), NumberStyles.HexNumber);
+                    return new Color(c[0], c[1], c[2], c[3]);
+                }
+                throw new ArgumentException(
+                        "Unknown color format. Must be #RGB or #RRGGBB");
+            }
+            else if (name.StartsWith("rgb(")) {
+                StringTokenizer tok = new StringTokenizer(name, "rgb(), \t\r\n\f");
+                for (int k = 0; k < 3; ++k) {
+                    String v = tok.NextToken();
+                    if (v.EndsWith("%"))
+                        c[k] = int.Parse(v.Substring(0, v.Length - 1)) * 255 / 100;
+                    else
+                        c[k] = int.Parse(v);
+                    if (c[k] < 0)
+                        c[k] = 0;
+                    else if (c[k] > 255)
+                        c[k] = 255;
+                }
+                return new Color(c[0], c[1], c[2], c[3]);
+            }
+            name = name.ToLower(CultureInfo.InvariantCulture);
+            if (!NAMES.ContainsKey(name))
+                throw new ArgumentException("Color '" + name
+                        + "' not found.");
+            c = (int[]) NAMES[name];
+            return new Color(c[0], c[1], c[2], c[3]);
+        }
+    }
+}

src/core/iTextSharp/text/html/simpleparser/ChainedProperties.cs

@@ -0,0 +1,135 @@
+using System;
+using System.Collections;
+/*
+ * Copyright 2004 Paulo Soares
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+
+namespace iTextSharp.text.html.simpleparser {
+
+public class ChainedProperties {
+    
+        public static int[] fontSizes = {8, 10, 12, 14, 18, 24, 36};
+        public ArrayList chain = new ArrayList();
+        
+        /** Creates a new instance of ChainedProperties */
+        public ChainedProperties() {
+        }
+        
+        public String this[String key] {
+            get {
+                for (int k = chain.Count - 1; k >= 0; --k) {
+                    Object[] obj = (Object[])chain[k];
+                    Hashtable prop = (Hashtable)obj[1];
+                    String ret = (String)prop[key];
+                    if (ret != null)
+                        return ret;
+                }
+                return null;
+            }
+        }
+        
+        public bool HasProperty(String key) {
+            for (int k = chain.Count - 1; k >= 0; --k) {
+                Object[] obj = (Object[])chain[k];
+                Hashtable prop = (Hashtable)obj[1];
+                if (prop.ContainsKey(key))
+                    return true;
+            }
+            return false;
+        }
+        
+        public void AddToChain(String key, Hashtable prop) {
+            // adjust the font size
+            String value = (String)prop["size"];
+            if (value != null) {
+                if (value.EndsWith("px")) {
+                    prop["size"] = value.Substring(0, value.Length - 2);
+                }
+                else {
+                    int s = 0;
+                    if (value.StartsWith("+") || value.StartsWith("-")) {
+                        String old = this["basefontsize"];
+                        if (old == null)
+                            old = "12";
+                        float f = float.Parse(old, System.Globalization.NumberFormatInfo.InvariantInfo);
+                        int c = (int)f;
+                        for (int k = fontSizes.Length - 1; k >= 0; --k) {
+                            if (c >= fontSizes[k]) {
+                                s = k;
+                                break;
+                            }
+                        }
+                        int inc = int.Parse(value.StartsWith("+") ? value.Substring(1) : value);
+                        s += inc;
+                    }
+                    else {
+                        try {
+                            s = int.Parse(value) - 1;
+                        }
+                        catch {
+                            s = 0;
+                        }
+                    }
+                    if (s < 0)
+                        s = 0;
+                    else if (s >= fontSizes.Length)
+                        s = fontSizes.Length - 1;
+                    prop["size"] = fontSizes[s].ToString();
+                }
+            }
+            chain.Add(new Object[]{key, prop});
+        }
+        
+        public void RemoveChain(String key) {
+            for (int k = chain.Count - 1; k >= 0; --k) {
+                if (key.Equals(((Object[])chain[k])[0])) {
+                    chain.RemoveAt(k);
+                    return;
+                }
+            }
+        }
+    }
+}

src/core/iTextSharp/text/html/simpleparser/FactoryProperties.cs

@@ -0,0 +1,338 @@
+using System;
+using System.Collections;
+using System.Globalization;
+using System.util;
+using iTextSharp.text;
+using iTextSharp.text.pdf;
+using iTextSharp.text.html;
+/*
+ * Copyright 2004 Paulo Soares
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+
+namespace iTextSharp.text.html.simpleparser {
+
+    /**
+    *
+    * @author  psoares
+    */
+    public class FactoryProperties {
+        
+        private FontFactoryImp fontImp = FontFactory.FontImp;
+
+        /** Creates a new instance of FactoryProperties */
+        public FactoryProperties() {
+        }
+        
+        public Chunk CreateChunk(String text, ChainedProperties props) {
+            Font font = GetFont(props);
+            float size = font.Size;
+            size /= 2;
+            Chunk ck = new Chunk(text, font);
+            if (props.HasProperty("sub"))
+                ck.SetTextRise(-size);
+            else if (props.HasProperty("sup"))
+                ck.SetTextRise(size);
+            ck.SetHyphenation(GetHyphenation(props));
+            return ck;
+        }
+        
+        private static void SetParagraphLeading(Paragraph p, String leading) {
+            if (leading == null) {
+                p.SetLeading(0, 1.5f);
+                return;
+            }
+            try {
+                StringTokenizer tk = new StringTokenizer(leading, " ,");
+                String v = tk.NextToken();
+                float v1 = float.Parse(v, System.Globalization.NumberFormatInfo.InvariantInfo);
+                if (!tk.HasMoreTokens()) {
+                    p.SetLeading(v1, 0);
+                    return;
+                }
+                v = tk.NextToken();
+                float v2 = float.Parse(v, System.Globalization.NumberFormatInfo.InvariantInfo);
+                p.SetLeading(v1, v2);
+            }
+            catch {
+                p.SetLeading(0, 1.5f);
+            }
+
+        }
+
+        public static Paragraph CreateParagraph(Hashtable props) {
+            Paragraph p = new Paragraph();
+            String value = (String)props["align"];
+            if (value != null) {
+                if (Util.EqualsIgnoreCase(value, "center"))
+                    p.Alignment = Element.ALIGN_CENTER;
+                else if (Util.EqualsIgnoreCase(value, "right"))
+                    p.Alignment = Element.ALIGN_RIGHT;
+                else if (Util.EqualsIgnoreCase(value, "justify"))
+                    p.Alignment = Element.ALIGN_JUSTIFIED;
+            }
+            SetParagraphLeading(p, (String)props["leading"]);
+            p.Hyphenation = GetHyphenation(props);
+            return p;
+        }
+
+        public static void CreateParagraph(Paragraph p, ChainedProperties props) {
+            String value = props["align"];
+            if (value != null) {
+                if (Util.EqualsIgnoreCase(value, "center"))
+                    p.Alignment = Element.ALIGN_CENTER;
+                else if (Util.EqualsIgnoreCase(value, "right"))
+                    p.Alignment = Element.ALIGN_RIGHT;
+                else if (Util.EqualsIgnoreCase(value, "justify"))
+                    p.Alignment = Element.ALIGN_JUSTIFIED;
+            }
+            p.Hyphenation = GetHyphenation(props);
+            SetParagraphLeading(p, props["leading"]);
+            value = props["before"];
+            if (value != null) {
+                try {
+                    p.SpacingBefore = float.Parse(value, System.Globalization.NumberFormatInfo.InvariantInfo);
+                }
+                catch {}
+            }
+            value = props["after"];
+            if (value != null) {
+                try {
+                    p.SpacingAfter = float.Parse(value, System.Globalization.NumberFormatInfo.InvariantInfo);
+                }
+                catch {}
+            }
+            value = props["extraparaspace"];
+            if (value != null) {
+                try {
+                    p.ExtraParagraphSpace = float.Parse(value, System.Globalization.NumberFormatInfo.InvariantInfo);
+                }
+                catch {}
+            }
+        }
+
+        public static Paragraph CreateParagraph(ChainedProperties props) {
+            Paragraph p = new Paragraph();
+            CreateParagraph(p, props);
+            return p;
+        }
+
+        public static ListItem CreateListItem(ChainedProperties props) {
+            ListItem p = new ListItem();
+            CreateParagraph(p, props);
+            return p;
+        }
+
+        public Font GetFont(ChainedProperties props) {
+            String face = props["face"];
+            if (face != null) {
+                StringTokenizer tok = new StringTokenizer(face, ",");
+                while (tok.HasMoreTokens()) {
+                    face = tok.NextToken().Trim();
+                    if (face.StartsWith("\""))
+                        face = face.Substring(1);
+                    if (face.EndsWith("\""))
+                        face = face.Substring(0, face.Length - 1);
+                    if (fontImp.IsRegistered(face))
+                        break;
+                }
+            }
+            int style = 0;
+            if (props.HasProperty("i"))
+                style |= Font.ITALIC;
+            if (props.HasProperty("b"))
+                style |= Font.BOLD;
+            if (props.HasProperty("u"))
+                style |= Font.UNDERLINE;
+            if (props.HasProperty("s"))
+                style |= Font.STRIKETHRU ;
+
+            String value = props["size"];
+            float size = 12;
+            if (value != null)
+                size = float.Parse(value, System.Globalization.NumberFormatInfo.InvariantInfo);
+            Color color = Markup.DecodeColor(props["color"]);
+            String encoding = props["encoding"];
+            if (encoding == null)
+                encoding = BaseFont.WINANSI;
+            return fontImp.GetFont(face, encoding, true, size, style, color);
+        }
+        
+        /**
+        * Gets a HyphenationEvent based on the hyphenation entry in ChainedProperties.
+        * @param    props   ChainedProperties
+        * @return   a HyphenationEvent
+        * @since    2.1.2
+        */
+        public static IHyphenationEvent GetHyphenation(ChainedProperties props) {
+            return GetHyphenation(props["hyphenation"]);
+        }
+
+        /**
+        * Gets a HyphenationEvent based on the hyphenation entry in a HashMap.
+        * @param    props   a HashMap with properties
+        * @return   a HyphenationEvent
+        * @since    2.1.2
+        */
+        public static IHyphenationEvent GetHyphenation(Hashtable props) {
+            return GetHyphenation((String)props["hyphenation"]);
+        }
+        
+        /**
+        * Gets a HyphenationEvent based on a String.
+        * For instance "en_UK,3,2" returns new HyphenationAuto("en", "UK", 3, 2);
+        * @param    a String, for instance "en_UK,2,2"
+        * @return   a HyphenationEvent
+        * @since    2.1.2
+        */
+        public static IHyphenationEvent GetHyphenation(String s) {
+            if (s == null || s.Length == 0) {
+                return null;
+            }
+            String lang = s;
+            String country = null;
+            int leftMin = 2;
+            int rightMin = 2;
+            
+            int pos = s.IndexOf('_');
+            if (pos == -1) {
+                return new HyphenationAuto(lang, country, leftMin, rightMin);
+            }
+            lang = s.Substring(0, pos);
+            country = s.Substring(pos + 1);
+            pos = country.IndexOf(',');
+            if (pos == -1) {
+                return new HyphenationAuto(lang, country, leftMin, rightMin);
+            }
+            s = country.Substring(pos + 1);
+            country = country.Substring(0, pos);
+            pos = s.IndexOf(',');
+            if (pos == -1) {
+                leftMin = int.Parse(s);
+            }
+            else {
+                leftMin = int.Parse(s.Substring(0, pos));
+                rightMin = int.Parse(s.Substring(pos + 1));
+            }   
+            return new HyphenationAuto(lang, country, leftMin, rightMin);
+        }
+        
+        public static void InsertStyle(Hashtable h) {
+            String style = (String)h["style"];
+            if (style == null)
+                return;
+            Properties prop = Markup.ParseAttributes(style);
+            foreach (String key in prop.Keys) {
+                if (key.Equals(Markup.CSS_KEY_FONTFAMILY)) {
+                    h["face"] = prop[key];
+                }
+                else if (key.Equals(Markup.CSS_KEY_FONTSIZE)) {
+                    h["size"] = Markup.ParseLength(prop[key]).ToString(NumberFormatInfo.InvariantInfo) + "px";
+                }
+                else if (key.Equals(Markup.CSS_KEY_FONTSTYLE)) {
+                    String ss = prop[key].Trim().ToLower(CultureInfo.InvariantCulture);
+                    if (ss.Equals("italic") || ss.Equals("oblique"))
+                        h["i"] = null;
+                }
+                else if (key.Equals(Markup.CSS_KEY_FONTWEIGHT)) {
+                    String ss = prop[key].Trim().ToLower(CultureInfo.InvariantCulture);
+                    if (ss.Equals("bold") || ss.Equals("700") || ss.Equals("800") || ss.Equals("900"))
+                        h["b"] = null;
+                }
+                else if (key.Equals(Markup.CSS_KEY_FONTWEIGHT)) {
+                    String ss = prop[key].Trim().ToLower(CultureInfo.InvariantCulture);
+                    if (ss.Equals("underline"))
+                        h["u"] = null;
+                }
+                else if (key.Equals(Markup.CSS_KEY_COLOR)) {
+                    Color c = Markup.DecodeColor(prop[key]);
+                    if (c != null) {
+                        int hh = c.ToArgb() & 0xffffff;
+                        String hs = "#" + hh.ToString("X06", NumberFormatInfo.InvariantInfo);
+                        h["color"] = hs;
+                    }
+                }
+                else if (key.Equals(Markup.CSS_KEY_LINEHEIGHT)) {
+                    String ss = prop[key].Trim();
+                    float v = Markup.ParseLength(prop[key]);
+                    if (ss.EndsWith("%")) {
+                        v /= 100;
+                        h["leading"] = "0," + v.ToString(NumberFormatInfo.InvariantInfo);
+                    }
+                    else {
+                        h["leading"] = v.ToString(NumberFormatInfo.InvariantInfo) + ",0";
+                    }
+                }
+                else if (key.Equals(Markup.CSS_KEY_TEXTALIGN)) {
+                    String ss = prop[key].Trim().ToLower(System.Globalization.CultureInfo.InvariantCulture);
+                    h["align"] = ss;
+                }
+            }
+        }
+        
+        public FontFactoryImp FontImp {
+            get {
+                return fontImp;
+            }
+            set {
+                fontImp = value;
+            }
+        }
+
+        public static Hashtable followTags = new Hashtable();
+
+        static FactoryProperties() {
+            followTags["i"] = "i";
+            followTags["b"] = "b";
+            followTags["u"] = "u";
+            followTags["sub"] = "sub";
+            followTags["sup"] = "sup";
+            followTags["em"] = "i";
+            followTags["strong"] = "b";
+            followTags["s"] = "s";
+            followTags["strike"] = "s";
+        }
+    }
+}

src/core/iTextSharp/text/html/simpleparser/HTMLWorker.cs

@@ -0,0 +1,624 @@
+using System;
+using System.IO;
+using System.Text;
+using System.Collections;
+using System.Globalization;
+using System.util;
+using iTextSharp.text;
+using iTextSharp.text.pdf;
+using iTextSharp.text.xml.simpleparser;
+/*
+ * Copyright 2004 Paulo Soares
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+
+namespace iTextSharp.text.html.simpleparser {
+
+    public class HTMLWorker : ISimpleXMLDocHandler, IDocListener {
+        
+        protected ArrayList objectList;
+        protected IDocListener document;
+        private Paragraph currentParagraph;
+        private ChainedProperties cprops = new ChainedProperties();
+        private Stack stack = new Stack();
+        private bool pendingTR = false;
+        private bool pendingTD = false;
+        private bool pendingLI = false;
+        private StyleSheet style = new StyleSheet();
+        private bool isPRE = false;
+        private Stack tableState = new Stack();
+        private bool skipText = false;
+        private Hashtable interfaceProps;
+        private FactoryProperties factoryProperties = new FactoryProperties();
+        
+        /** Creates a new instance of HTMLWorker */
+        public HTMLWorker(IDocListener document) {
+            this.document = document;
+        }
+        
+        public StyleSheet Style {
+            set {
+                style = value;
+            }
+            get {
+                return style;
+            }
+        }
+        
+        public Hashtable InterfaceProps {
+            set {
+                interfaceProps = value;
+                FontFactoryImp ff = null;
+                if (interfaceProps != null)
+                    ff = (FontFactoryImp)interfaceProps["font_factory"];
+                if (ff != null)
+                    factoryProperties.FontImp = ff;
+            }
+            get {
+                return interfaceProps;
+            }
+        }
+
+        public void Parse(TextReader reader) {
+            SimpleXMLParser.Parse(this, null, reader, true);
+        }
+        
+        public static ArrayList ParseToList(TextReader reader, StyleSheet style) {
+            return ParseToList(reader, style, null);
+        }
+
+        public static ArrayList ParseToList(TextReader reader, StyleSheet style, Hashtable interfaceProps) {
+            HTMLWorker worker = new HTMLWorker(null);
+            if (style != null)
+                worker.Style = style;
+            worker.document = worker;
+            worker.InterfaceProps = interfaceProps;
+            worker.objectList = new ArrayList();
+            worker.Parse(reader);
+            return worker.objectList;
+        }
+        
+        public virtual void EndDocument() {
+            foreach (IElement e in stack)
+                document.Add(e);
+            if (currentParagraph != null)
+                document.Add(currentParagraph);
+            currentParagraph = null;
+        }
+        
+        public virtual void StartDocument() {
+            Hashtable h = new Hashtable();
+            style.ApplyStyle("body", h);
+            cprops.AddToChain("body", h);
+        }
+        
+        public virtual void StartElement(String tag, Hashtable h) {
+            if (!tagsSupported.ContainsKey(tag))
+                return;
+            style.ApplyStyle(tag, h);
+            String follow = (String)FactoryProperties.followTags[tag];
+            if (follow != null) {
+                Hashtable prop = new Hashtable();
+                prop[follow] = null;
+                cprops.AddToChain(follow, prop);
+                return;
+            }
+            FactoryProperties.InsertStyle(h);
+            if (tag.Equals("a")) {
+                cprops.AddToChain(tag, h);
+                if (currentParagraph == null)
+                    currentParagraph = new Paragraph();
+                stack.Push(currentParagraph);
+                currentParagraph = new Paragraph();
+                return;
+            }
+            if (tag.Equals("br")) {
+                if (currentParagraph == null)
+                    currentParagraph = new Paragraph();
+                currentParagraph.Add(factoryProperties.CreateChunk("\n", cprops));
+                return;
+            }
+            if (tag.Equals("font") || tag.Equals("span")) {
+                cprops.AddToChain(tag, h);
+                return;
+            }
+            if (tag.Equals("img")) {
+                String src = (String)h["src"];
+                if (src == null)
+                    return;
+                cprops.AddToChain(tag, h);
+                Image img = null;
+                if (interfaceProps != null) {
+                    IImageProvider ip = (IImageProvider)interfaceProps["img_provider"];
+                    if (ip != null)
+                        img = ip.GetImage(src, h, cprops, document);
+                    if (img == null) {
+                        Hashtable images = (Hashtable)interfaceProps["img_static"];
+                        if (images != null) {
+                            Image tim = (Image)images[src];
+                            if (tim != null)
+                                img = Image.GetInstance(tim);
+                        } else {
+                            if (!src.StartsWith("http")) { // relative src references only
+                                String baseurl = (String)interfaceProps["img_baseurl"];
+                                if (baseurl != null) {
+                                    src = baseurl + src;
+                                    img = Image.GetInstance(src);
+                                }
+                            }
+                        }
+                    }
+                }
+                if (img == null) {
+                    if (!src.StartsWith("http")) {
+                        String path = cprops["image_path"];
+                        if (path == null)
+                            path = "";
+                        src = Path.Combine(path, src);
+                    }
+                    img = Image.GetInstance(src);
+                }
+                String align = (String)h["align"];
+                String width = (String)h["width"];
+                String height = (String)h["height"];
+                String before = cprops["before"];
+                String after = cprops["after"];
+                if (before != null)
+                    img.SpacingBefore = float.Parse(before, System.Globalization.NumberFormatInfo.InvariantInfo);
+                if (after != null)
+                    img.SpacingAfter = float.Parse(after, System.Globalization.NumberFormatInfo.InvariantInfo);
+                float wp = LengthParse(width, (int)img.Width);
+                float lp = LengthParse(height, (int)img.Height);
+                if (wp > 0 && lp > 0)
+                    img.ScalePercent(wp > lp ? lp : wp);
+                else if (wp > 0)
+                    img.ScalePercent(wp);
+                else if (lp > 0)
+                    img.ScalePercent(lp);
+                img.WidthPercentage = 0;
+                if (align != null) {
+                    EndElement("p");
+                    int ralign = Image.MIDDLE_ALIGN;
+                    if (Util.EqualsIgnoreCase(align, "left"))
+                        ralign = Image.LEFT_ALIGN;
+                    else if (Util.EqualsIgnoreCase(align, "right"))
+                        ralign = Image.RIGHT_ALIGN;
+                    img.Alignment = ralign;
+                    IImg i = null;
+                    bool skip = false;
+                    if (interfaceProps != null) {
+                        i = (IImg)interfaceProps["img_interface"];
+                        if (i != null)
+                            skip = i.Process(img, h, cprops, document);
+                    }
+                    if (!skip)
+                        document.Add(img);
+                    cprops.RemoveChain(tag);
+                }
+                else {
+                    cprops.RemoveChain(tag);
+                    if (currentParagraph == null)
+                        currentParagraph = FactoryProperties.CreateParagraph(cprops);
+                    currentParagraph.Add(new Chunk(img, 0, 0));
+                }
+                return;
+            }
+
+            EndElement("p");
+            if (tag.Equals("h1") || tag.Equals("h2") || tag.Equals("h3") || tag.Equals("h4") || tag.Equals("h5") || tag.Equals("h6")) {
+                if (!h.ContainsKey("size")) {
+                    int v = 7 - int.Parse(tag.Substring(1));
+                    h["size"] = v.ToString();
+                }
+                cprops.AddToChain(tag, h);
+                return;
+            }
+            if (tag.Equals("ul")) {
+                if (pendingLI)
+                    EndElement("li");
+                skipText = true;
+                cprops.AddToChain(tag, h);
+                List list = new List(false, 10);
+                list.SetListSymbol("\u2022");
+                stack.Push(list);
+                return;
+            }
+            if (tag.Equals("ol")) {
+                if (pendingLI)
+                    EndElement("li");
+                skipText = true;
+                cprops.AddToChain(tag, h);
+                List list = new List(true, 10);
+                stack.Push(list);
+                return;
+            }
+            if (tag.Equals("li")) {
+                if (pendingLI)
+                    EndElement("li");
+                skipText = false;
+                pendingLI = true;
+                cprops.AddToChain(tag, h);
+                stack.Push(FactoryProperties.CreateListItem(cprops));
+                return;
+            }
+            if (tag.Equals("div") || tag.Equals("body")) {
+                cprops.AddToChain(tag, h);
+                return;
+            }
+            if (tag.Equals("pre")) {
+                if (!h.ContainsKey("face")) {
+                    h["face"] = "Courier";
+                }
+                cprops.AddToChain(tag, h);
+                isPRE = true;
+                return;
+            }
+            if (tag.Equals("p")) {
+                cprops.AddToChain(tag, h);
+                currentParagraph = FactoryProperties.CreateParagraph(h);
+                return;
+            }
+            if (tag.Equals("tr")) {
+                if (pendingTR)
+                    EndElement("tr");
+                skipText = true;
+                pendingTR = true;
+                cprops.AddToChain("tr", h);
+                return;
+            }
+            if (tag.Equals("td") || tag.Equals("th")) {
+                if (pendingTD)
+                    EndElement(tag);
+                skipText = false;
+                pendingTD = true;
+                cprops.AddToChain("td", h);
+                stack.Push(new IncCell(tag, cprops));
+                return;
+            }
+            if (tag.Equals("table")) {
+                cprops.AddToChain("table", h);
+                IncTable table = new IncTable(h);
+                stack.Push(table);
+                tableState.Push(new bool[]{pendingTR, pendingTD});
+                pendingTR = pendingTD = false;
+                skipText = true;
+                return;
+            }
+        }
+        
+        public virtual void EndElement(String tag) {
+            if (!tagsSupported.ContainsKey(tag))
+                return;
+            String follow = (String)FactoryProperties.followTags[tag];
+            if (follow != null) {
+                cprops.RemoveChain(follow);
+                return;
+            }
+            if (tag.Equals("font") || tag.Equals("span")) {
+                cprops.RemoveChain(tag);
+                return;
+            }
+            if (tag.Equals("a")) {
+                if (currentParagraph == null)
+                    currentParagraph = new Paragraph();
+                IALink i = null;
+                bool skip = false;
+                if (interfaceProps != null) {
+                    i = (IALink)interfaceProps["alink_interface"];
+                    if (i != null)
+                        skip = i.Process(currentParagraph, cprops);
+                }
+                if (!skip) {
+                    String href = cprops["href"];
+                    if (href != null) {
+                        ArrayList chunks = currentParagraph.Chunks;
+                        for (int k = 0; k < chunks.Count; ++k) {
+                            Chunk ck = (Chunk)chunks[k];
+                            ck.SetAnchor(href);
+                        }
+                    }
+                }
+                Paragraph tmp = (Paragraph)stack.Pop();
+                Phrase tmp2 = new Phrase();
+                tmp2.Add(currentParagraph);
+                tmp.Add(tmp2);
+                currentParagraph = tmp;
+                cprops.RemoveChain("a");
+                return;
+            }
+            if (tag.Equals("br")) {
+                return;
+            }
+            if (currentParagraph != null) {
+                if (stack.Count == 0)
+                    document.Add(currentParagraph);
+                else {
+                    Object obj = stack.Pop();
+                    if (obj is ITextElementArray) {
+                        ITextElementArray current = (ITextElementArray)obj;
+                        current.Add(currentParagraph);
+                    }
+                    stack.Push(obj);
+                }
+            }
+            currentParagraph = null;
+            if (tag.Equals("ul") || tag.Equals("ol")) {
+                if (pendingLI)
+                    EndElement("li");
+                skipText = false;
+                cprops.RemoveChain(tag);
+                if (stack.Count == 0)
+                    return;
+                Object obj = stack.Pop();
+                if (!(obj is List)) {
+                    stack.Push(obj);
+                    return;
+                }
+                if (stack.Count == 0)
+                    document.Add((IElement)obj);
+                else
+                    ((ITextElementArray)stack.Peek()).Add(obj);
+                return;
+            }
+            if (tag.Equals("li")) {
+                pendingLI = false;
+                skipText = true;
+                cprops.RemoveChain(tag);
+                if (stack.Count == 0)
+                    return;
+                Object obj = stack.Pop();
+                if (!(obj is ListItem)) {
+                    stack.Push(obj);
+                    return;
+                }
+                if (stack.Count == 0) {
+                    document.Add((IElement)obj);
+                    return;
+                }
+                Object list = stack.Pop();
+                if (!(list is List)) {
+                    stack.Push(list);
+                    return;
+                }
+                ListItem item = (ListItem)obj;
+                ((List)list).Add(item);
+                ArrayList cks = item.Chunks;
+                if (cks.Count > 0)
+                    item.ListSymbol.Font = ((Chunk)cks[0]).Font;
+                stack.Push(list);
+                return;
+            }
+            if (tag.Equals("div") || tag.Equals("body")) {
+                cprops.RemoveChain(tag);
+                return;
+            }
+            if (tag.Equals("pre")) {
+                cprops.RemoveChain(tag);
+                isPRE = false;
+                return;
+            }
+            if (tag.Equals("p")) {
+                cprops.RemoveChain(tag);
+                return;
+            }
+            if (tag.Equals("h1") || tag.Equals("h2") || tag.Equals("h3") || tag.Equals("h4") || tag.Equals("h5") || tag.Equals("h6")) {
+                cprops.RemoveChain(tag);
+                return;
+            }
+            if (tag.Equals("table")) {
+                if (pendingTR)
+                    EndElement("tr");
+                cprops.RemoveChain("table");
+                IncTable table = (IncTable) stack.Pop();
+                PdfPTable tb = table.BuildTable();
+                tb.SplitRows = true;
+                if (stack.Count == 0)
+                    document.Add(tb);
+                else
+                    ((ITextElementArray)stack.Peek()).Add(tb);
+                bool[] state = (bool[])tableState.Pop();
+                pendingTR = state[0];
+                pendingTD = state[1];
+                skipText = false;
+                return;
+            }
+            if (tag.Equals("tr")) {
+                if (pendingTD)
+                    EndElement("td");
+                pendingTR = false;
+                cprops.RemoveChain("tr");
+                ArrayList cells = new ArrayList();
+                IncTable table = null;
+                while (true) {
+                    Object obj = stack.Pop();
+                    if (obj is IncCell) {
+                        cells.Add(((IncCell)obj).Cell);
+                    }
+                    if (obj is IncTable) {
+                        table = (IncTable)obj;
+                        break;
+                    }
+                }
+                table.AddCols(cells);
+                table.EndRow();
+                stack.Push(table);
+                skipText = true;
+                return;
+            }
+            if (tag.Equals("td") || tag.Equals("th")) {
+                pendingTD = false;
+                cprops.RemoveChain("td");
+                skipText = true;
+                return;
+            }
+        }
+        
+        public virtual void Text(String str) {
+            if (skipText)
+                return;
+            String content = str;
+            if (isPRE) {
+                if (currentParagraph == null)
+                    currentParagraph = FactoryProperties.CreateParagraph(cprops);
+                currentParagraph.Add(factoryProperties.CreateChunk(content, cprops));
+                return;
+            }
+            if (content.Trim().Length == 0 && content.IndexOf(' ') < 0) {
+                return;
+            }
+            
+            StringBuilder buf = new StringBuilder();
+            int len = content.Length;
+            char character;
+            bool newline = false;
+            for (int i = 0; i < len; i++) {
+                switch (character = content[i]) {
+                    case ' ':
+                        if (!newline) {
+                            buf.Append(character);
+                        }
+                        break;
+                    case '\n':
+                        if (i > 0) {
+                            newline = true;
+                            buf.Append(' ');
+                        }
+                        break;
+                    case '\r':
+                        break;
+                    case '\t':
+                        break;
+                    default:
+                        newline = false;
+                        buf.Append(character);
+                        break;
+                }
+            }
+            if (currentParagraph == null)
+                currentParagraph = FactoryProperties.CreateParagraph(cprops);
+            currentParagraph.Add(factoryProperties.CreateChunk(buf.ToString(), cprops));
+        }
+        
+        public bool Add(IElement element) {
+            objectList.Add(element);
+            return true;
+        }
+        
+        public void ClearTextWrap() {
+        }
+        
+        public void Close() {
+        }
+        
+        public bool NewPage() {
+            return true;
+        }
+        
+        public void Open() {
+        }
+        
+        public void ResetFooter() {
+        }
+        
+        public void ResetHeader() {
+        }
+        
+        public void ResetPageCount() {
+        }
+        
+        public bool SetMarginMirroring(bool marginMirroring) {
+            return true;
+        }
+        
+        public bool SetMargins(float marginLeft, float marginRight, float marginTop, float marginBottom) {
+            return true;
+        }
+        
+        public bool SetPageSize(Rectangle pageSize) {
+            return true;
+        }
+        
+        public const String tagsSupportedString = "ol ul li a pre font span br p div body table td th tr i b u sub sup em strong s strike"
+            + " h1 h2 h3 h4 h5 h6 img";
+        
+        public static Hashtable tagsSupported = new Hashtable();
+        
+        static HTMLWorker() {
+            StringTokenizer tok = new StringTokenizer(tagsSupportedString);
+            while (tok.HasMoreTokens())
+                tagsSupported[tok.NextToken()] = null;
+        }
+    
+        public HeaderFooter Footer {
+            set {
+            }
+        }
+    
+        public HeaderFooter Header {
+            set {
+            }
+        }
+    
+        public int PageCount {
+            set {
+            }
+        }
+
+        private static float LengthParse(String txt, int c) {
+            if (txt == null)
+                return -1;
+            if (txt.EndsWith("%")) {
+                float vf = float.Parse(txt.Substring(0, txt.Length - 1), System.Globalization.NumberFormatInfo.InvariantInfo);
+                return vf;
+            }
+            if (txt.EndsWith("px")) {
+                float vf = float.Parse(txt.Substring(0, txt.Length - 2), System.Globalization.NumberFormatInfo.InvariantInfo);
+                return vf;
+            }
+            int v = int.Parse(txt);
+            return (float)v / c * 100f;
+        }
+    }
+}

src/core/iTextSharp/text/html/simpleparser/IALink.cs

@@ -0,0 +1,54 @@
+using System;
+using iTextSharp.text;
+/*
+ * Copyright 2005 Paulo Soares
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the License.
+ *
+ * The Original Code is 'iText, a free JAVA-PDF library'.
+ *
+ * The Initial Developer of the Original Code is Bruno Lowagie. Portions created by
+ * the Initial Developer are Copyright (C) 1999, 2000, 2001, 2002 by Bruno Lowagie.
+ * All Rights Reserved.
+ * Co-Developer of the code is Paulo Soares. Portions created by the Co-Developer
+ * are Copyright (C) 2000, 2001, 2002 by Paulo Soares. All Rights Reserved.
+ *
+ * Contributor(s): all the names of the contributors are added in the source code
+ * where applicable.
+ *
+ * Alternatively, the contents of this file may be used under the terms of the
+ * LGPL license (the "GNU LIBRARY GENERAL PUBLIC LICENSE"), in which case the
+ * provisions of LGPL are applicable instead of those above.  If you wish to
+ * allow use of your version of this file only under the terms of the LGPL
+ * License and not to allow others to use your version of this file under
+ * the MPL, indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by the LGPL.
+ * If you do not delete the provisions above, a recipient may use your version
+ * of this file under either the MPL or the GNU LIBRARY GENERAL PUBLIC LICENSE.
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MPL as stated above or under the terms of the GNU
+ * Library General Public License as published by the Free Software Foundation;
+ * either version 2 of the License, or any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Library general Public License for more
+ * details.
+ *
+ * If you didn't download this code from the following link, you should check if
+ * you aren't using an obsolete version:
+ * http://www.lowagie.com/iText/
+ */
+
+namespace iTextSharp.text.html.simpleparser {
+    public interface IALink {
+        bool Process(Paragraph current, ChainedProperties cprops);
+    }
+}