context: 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 void EndDocument() {
              foreach (IElement e in stack)
                  document.Add(e);
              if (currentParagraph != null)
                  document.Add(currentParagraph);
              currentParagraph = null;
          }
          
          public void StartDocument() {
              Hashtable h = new Hashtable();
              style.ApplyStyle("body", h);
              cprops.AddToChain("body", h);
          }
          
          public 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) {
                      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);
  
gt:                 if (after != null)