public DocumentObject NodeHandler(HtmlNode node, DocumentObject parent, DocumentObject current = null)
        {
            var @class = node.Attributes["class"];

            if (!(parent is Section))
            {
                return parent;
            }

            var sec = (Section)parent;

            if (@class != null && @class.Value == "report")
            {
                var margins = node.Attributes["data-margin"];
                if (margins == null)
                {
                    sec.PageSetup.TopMargin = Unit.FromCentimeter(0.1);
                    sec.PageSetup.BottomMargin = Unit.FromCentimeter(0.1);
                    sec.PageSetup.LeftMargin = Unit.FromCentimeter(0.1);
                    sec.PageSetup.RightMargin = Unit.FromCentimeter(0.1);
                }
                else
                {
                    var marginValues = margins.Value.Split(' ');

                    sec.PageSetup.TopMargin = Unit.FromCentimeter(double.Parse(marginValues[0]));
                    sec.PageSetup.RightMargin = Unit.FromCentimeter(double.Parse(marginValues[1]));
                    sec.PageSetup.BottomMargin = Unit.FromCentimeter(double.Parse(marginValues[2]));
                    sec.PageSetup.LeftMargin = Unit.FromCentimeter(double.Parse(marginValues[3]));
                }
            }

            return parent;
        }

        protected override HtmlItem renderingHtmlImg(HtmlItem it, ref Paragraph par, HtmlItem parent, DocumentObject renderparent)
        {
            HtmlImg imagen = it as HtmlImg;
            MigraDoc.DocumentObjectModel.Shapes.Image img = null;
            MigraDoc.DocumentObjectModel.Shapes.TextFrame tf = null;
            if (imagen != null)
            {
                string route = AppDomain.CurrentDomain.BaseDirectory;
                string directorytem = Settings1.Default.routetem;
                string filename = RandomString(16, false) + "." + imagen.ImageType.ToString();
                string routecompleted = route + directorytem + "\\" + filename;
                imagen.Image.Save(routecompleted);

                MigraDoc.DocumentObjectModel.Tables.Cell cellparent = renderparent as MigraDoc.DocumentObjectModel.Tables.Cell;
                if (cellparent != null)
                {
                    tf = cellparent.AddTextFrame();
                    tf.WrapFormat.Style = MigraDoc.DocumentObjectModel.Shapes.WrapStyle.Through;
                }

                if (tf != null)
                    img = tf.AddImage(routecompleted);
                else
                    img = par.AddImage(routecompleted);

                RenderStyle.CreateRenderStyle(it, ref img).Render();
                listTempFiles.Add(routecompleted);
                imagen.SizeRenderItem = new RenderSizeItem() { Width = Convert.ToDecimal(img.Width), Height = Convert.ToDecimal(img.Height) };

            }

            return imagen;
        }

 internal ChartRenderer(DocumentObject domObj, RtfDocumentRenderer docRenderer)
   : base(domObj, docRenderer)
 {
   this.chart = (Chart)domObj;
   this.isInline = DocumentRelations.HasParentOfType(this.chart, typeof(Paragraph)) ||
     RenderInParagraph();
 }

        protected override HtmlItem renderingHtmltr(HtmlItem it, ref Paragraph par, HtmlItem parent, DocumentObject renderparent)
        {
            Htmltr tr = it as Htmltr;
            MigraDoc.DocumentObjectModel.Tables.Row rw = null;
            if (tr != null)
            {
                HtmlTable tb = parent as HtmlTable;
                if (tb != null)
                {
                    MigraDoc.DocumentObjectModel.Tables.Table tt = renderparent as MigraDoc.DocumentObjectModel.Tables.Table;
                    if (tt != null)
                    {
                        if (tt.Columns.Count > 0)
                            rw = tt.AddRow();

                        tr.SetTableParent(tb);
                    }

                }
                foreach (HtmlItem t in it.ListItem)
                {
                    FormattedText ff = new FormattedText();
                    RenderStyle.CreateRenderStyle(it, ref ff).Render();
                    HtmlItem itemrendered = renderingit(t, ref par, it, rw);
                }
            }
            return tr;
        }

    /// <summary>
    /// Gets the direct parent of the given document object.
    /// </summary>
    /// <param name="documentObject">The document object the parent is searched for.</param>
    public static DocumentObject GetParent(DocumentObject documentObject)
    {
      if (documentObject == null)
        throw new ArgumentNullException("documentObject");

      return documentObject.Parent;
    }

 internal Renderer(XGraphics gfx, RenderInfo renderInfo, FieldInfos fieldInfos)
 {
     this.documentObject = renderInfo.DocumentObject;
     this.gfx = gfx;
     this.renderInfo = renderInfo;
     this.fieldInfos = fieldInfos;
 }

 /// <summary>
 /// Add formatted text to the MigraDoc object.
 /// </summary>
 /// <param name="parentObject">The MigraDoc object to store the elements in.</param>
 /// <returns>The formatted text object.</returns>
 private static FormattedText AddFormattedText(DocumentObject parentObject)
 {
     FormattedText formattedText = parentObject as FormattedText;
     if (formattedText == null)
         return GetParagraph(parentObject).AddFormattedText();
     else
         return formattedText.AddFormattedText();
 }

    /// <summary>
    /// Determines whether the specified documentObject has a
    /// parent of the given type somewhere within the document hierarchy.
    /// </summary>
    /// <param name="documentObject">The document object to check.</param>
    /// <param name="type">The parent type to search for.</param>
    public static bool HasParentOfType(DocumentObject documentObject, Type type)
    {
      if (documentObject == null)
        throw new ArgumentNullException("documentObject");

      if (type == null)
        throw new ArgumentNullException("type");

      return GetParentOfType(documentObject, type) != null;
    }

        internal ImageRenderer(DocumentObject domObj, RtfDocumentRenderer docRenderer)
            : base(domObj, docRenderer)
        {
            this.image = domObj as Image;
              this.filePath = this.image.GetFilePath(this.docRenderer.WorkingDirectory);
              this.isInline = DocumentRelations.HasParentOfType(this.image, typeof(Paragraph)) ||
             RenderInParagraph();

              CalculateImageDimensions();
        }

 private static DocumentObject AddHyperlink(DocumentObject section, HtmlNode node)
 {
     string href = node.GetAttributeValue("href", "");
     Hyperlink link;
     if (href.StartsWith("#"))
         link = GetParagraph(section).AddHyperlink(href.Substring(1), HyperlinkType.Bookmark);
     else
         link = GetParagraph(section).AddHyperlink(href, HyperlinkType.Web);
     return link;
 }

        /// <summary>
        /// Initializes a new instance of the RendererBase class.
        /// </summary>
        internal RendererBase(DocumentObject domObj, RtfDocumentRenderer docRenderer)
        {
            if (enumTranslationTable == null)
            CreateEnumTranslationTable();

              this.docObject = domObj;
              this.docRenderer = docRenderer;
              if (docRenderer != null)
            this.rtfWriter = docRenderer.RtfWriter;
              this.useEffectiveValue = false;
        }

        /// <summary>
        /// Gets a parent of the document object with the given type somewhere within the document hierarchy.
        /// Returns null if none exists.
        /// </summary>
        /// <param name="documentObject">The document object the parent is searched for.</param>
        /// <param name="type">The parent type to search for.</param>
        public static DocumentObject GetParentOfType(DocumentObject documentObject, Type type)
        {
            if (documentObject == null)
                throw new ArgumentNullException("documentObject");

            if (type == null)
                throw new ArgumentNullException("type");

            if (documentObject._parent != null)
            {
                if (documentObject._parent.GetType() == type)
                    return documentObject._parent;
                return GetParentOfType(documentObject._parent, type);
            }
            return null;
        }

        public DocumentObject NodeHandler(HtmlNode node, ExCSS.Stylesheet sheet, DocumentObject parent, DocumentObject current = null)
        {
            if (!(parent is Section))
            {
                return parent;
            }

            var sec = (Section)parent;
            
            Unit margin;
            SetMargin(node, sheet, out margin, "margin-top");
            sec.PageSetup.TopMargin = margin;
            SetMargin(node, sheet, out margin, "margin-bottom");
            sec.PageSetup.BottomMargin = margin;
            SetMargin(node, sheet, out margin, "margin-left");
            sec.PageSetup.LeftMargin = margin;
            SetMargin(node, sheet, out margin, "margin-right");
            sec.PageSetup.LeftMargin = margin;
            return parent;
        }

        protected override HtmlItem renderingHtmlTable(HtmlItem it, ref Paragraph par, HtmlItem parent, DocumentObject renderparent)
        {
            HtmlTable tbl = it as HtmlTable;
            MigraDoc.DocumentObjectModel.Shapes.TextFrame tf = null;
            Paragraph partf = null;
            if (tbl != null)
            {
                MigraDoc.DocumentObjectModel.Tables.Table tt = null;
                MigraDoc.DocumentObjectModel.Tables.Cell cellparent = renderparent as MigraDoc.DocumentObjectModel.Tables.Cell;
                if (cellparent != null)
                {
                    tf = cellparent.AddTextFrame();
                    tt = tf.AddTable();
                    partf = tf.AddParagraph();

                }
                else
                    tt = par.Section.AddTable();

                tbl.SizeRenderItem.Width = 0;
                for (int i = 0; i < tbl.Cells; i++)
                {
                    MigraDoc.DocumentObjectModel.Tables.Column cc = tt.AddColumn();

                }

                foreach (HtmlItem t in it.ListItem)
                {
                    FormattedText ff = new FormattedText();
                    RenderStyle.CreateRenderStyle(it, ref ff).Render();
                    if (partf != null)
                        renderingit(t, ref partf, it, tt);
                    else
                        renderingit(t, ref par, it, tt);
                }
                RenderStyle.CreateRenderStyle(it, ref tt).Render();

            }
            return tbl;
        }

        private void ConvertHtmlNodes(HtmlNodeCollection nodes, ExCSS.Stylesheet sheet, DocumentObject section, DocumentObject current = null)
        {
            foreach (var node in nodes)
            {
                Func<HtmlNode, ExCSS.Stylesheet, DocumentObject, DocumentObject> nodeHandler;

                Type t;
                if (_mapping.TryGetValue(node.Name, out t))
                {
                    var instance = (INodeHandler)Activator.CreateInstance(t);
                    var result = instance.NodeHandler(node, sheet, section);

                    if (node.HasChildNodes)
                    {
                        ConvertHtmlNodes(node.ChildNodes, sheet, section, result);
                    }
                }
                else
                {
                    if (nodeHandlers.TryGetValue(node.Name, out nodeHandler))
                    {
                        // pass the current container or section
                        var result = nodeHandler(node, sheet, current ?? section);

                        if (node.HasChildNodes)
                        {
                            ConvertHtmlNodes(node.ChildNodes, sheet, section, result);
                        }
                    }
                    else
                    {
                        if (node.HasChildNodes)
                        {
                            ConvertHtmlNodes(node.ChildNodes, sheet, section, current);
                        }
                    }
                }
            }
        }

 private void ConvertHtmlNodes(HtmlNodeCollection nodes, DocumentObject section, DocumentObject current = null)
 {
     foreach (var node in nodes)
     {
         Func<HtmlNode, DocumentObject, DocumentObject> nodeHandler;
         if (nodeHandlers.TryGetValue(node.Name, out nodeHandler))
         {
             // pass the current container or section
             var result = nodeHandler(node, current ?? section);
             
             if (node.HasChildNodes)
             {
                 ConvertHtmlNodes(node.ChildNodes, section, result);
             }
         }
         else
         {
             if (node.HasChildNodes)
             {
                 ConvertHtmlNodes(node.ChildNodes, section, current);
             }
         }
     }
 }

 private static Paragraph AddParagraphWithStyle(DocumentObject parent, string style)
 {
     return ((Section)parent).AddParagraph().SetStyle(style);
 }

 private static Paragraph GetParagraph(DocumentObject parent)
 {
     return parent as Paragraph ?? ((Section)parent).AddParagraph();
 }

 private static DocumentObject AddHeading(HtmlNode node, ExCSS.Stylesheet sheet, DocumentObject parent)
 {
     return ((Section)parent).AddParagraph().SetStyle("Heading" + node.Name[1]);
 }

        private static DocumentObject AddFormattedText(HtmlNode node, ExCSS.Stylesheet sheet, DocumentObject parent, TextFormat format)
        {
            var formattedText = parent as FormattedText;
            if (formattedText != null)
            {
                return formattedText.Format(format);
            }

            // otherwise parent is paragraph or section
            return GetParagraph(parent).AddFormattedText(format);
        }