/// <summary>Processes counters.</summary>
        /// <param name="cssProps">the CSS properties</param>
        /// <param name="context">the processor context</param>
        public static void ProcessCounters(IDictionary <String, String> cssProps, CssContext context)
        {
            String counterReset = cssProps.Get(CssConstants.COUNTER_RESET);

            ProcessReset(counterReset, context);
            String counterIncrement = cssProps.Get(CssConstants.COUNTER_INCREMENT);

            ProcessIncrement(counterIncrement, context);
        }
 /// <summary>Resets the context.</summary>
 public virtual void Reset()
 {
     this.pdfDocument = null;
     this.state       = new State();
     this.resourceResolver.ResetCache();
     this.cssContext  = new CssContext();
     this.linkContext = new LinkContext();
     this.formFieldNameResolver.Reset();
     //Reset font provider. PdfFonts shall be reseted.
     this.fontProvider.Reset();
     this.tempFonts = null;
     this.outlineHandler.Reset();
     this.processingInlineSvg = false;
 }
 /// <summary>
 /// Instantiates a new
 /// <see cref="ProcessorContext"/>
 /// instance.
 /// </summary>
 /// <param name="converterProperties">
 /// a
 /// <see cref="iText.Html2pdf.ConverterProperties"/>
 /// instance
 /// </param>
 public ProcessorContext(ConverterProperties converterProperties)
 {
     if (converterProperties == null)
     {
         converterProperties = new ConverterProperties();
     }
     state             = new State();
     deviceDescription = converterProperties.GetMediaDeviceDescription();
     if (deviceDescription == null)
     {
         deviceDescription = MediaDeviceDescription.GetDefault();
     }
     fontProvider = converterProperties.GetFontProvider();
     if (fontProvider == null)
     {
         fontProvider = new DefaultFontProvider();
     }
     tagWorkerFactory = converterProperties.GetTagWorkerFactory();
     if (tagWorkerFactory == null)
     {
         tagWorkerFactory = DefaultTagWorkerFactory.GetInstance();
     }
     cssApplierFactory = converterProperties.GetCssApplierFactory();
     if (cssApplierFactory == null)
     {
         cssApplierFactory = DefaultCssApplierFactory.GetInstance();
     }
     baseUri = converterProperties.GetBaseUri();
     if (baseUri == null)
     {
         baseUri = "";
     }
     outlineHandler = converterProperties.GetOutlineHandler();
     if (outlineHandler == null)
     {
         outlineHandler = new OutlineHandler();
     }
     resourceResolver      = new HtmlResourceResolver(baseUri, this, converterProperties.GetResourceRetriever());
     limitOfLayouts        = converterProperties.GetLimitOfLayouts();
     cssContext            = new CssContext();
     linkContext           = new LinkContext();
     createAcroForm        = converterProperties.IsCreateAcroForm();
     formFieldNameResolver = new FormFieldNameResolver();
     radioCheckResolver    = new RadioCheckResolver();
     immediateFlush        = converterProperties.IsImmediateFlush();
     metaInfo            = converterProperties.GetEventCountingMetaInfo();
     processingInlineSvg = false;
 }
Beispiel #4
0
 private void ResolveStylesForTree(INode node, ICssResolver cssResolver, CssContext context)
 {
     if (node is IElementNode)
     {
         IElementNode element = (IElementNode)node;
         element.SetStyles(cssResolver.ResolveStyles((IElementNode)node, context));
         if (TagConstants.HTML.Equals(element.Name()))
         {
             context.SetRootFontSize(element.GetStyles().Get(CssConstants.FONT_SIZE));
         }
     }
     foreach (INode child in node.ChildNodes())
     {
         ResolveStylesForTree(child, cssResolver, context);
     }
 }
Beispiel #5
0
        /// <summary>Processes counters.</summary>
        /// <param name="cssProps">the CSS properties</param>
        /// <param name="context">the processor context</param>
        /// <param name="scope">the scope</param>
        public static void ProcessCounters(IDictionary <String, String> cssProps, CssContext context, INode scope)
        {
            String counterReset = cssProps.Get(CssConstants.COUNTER_RESET);

            if (counterReset != null)
            {
                CssCounterManager counterManager = context.GetCounterManager();
                String[]          @params        = iText.IO.Util.StringUtil.Split(counterReset, " ");
                for (int i = 0; i < @params.Length; i++)
                {
                    String counterName = @params[i];
                    int?   possibleCounterValue;
                    if (i + 1 < @params.Length && (possibleCounterValue = CssUtils.ParseInteger(@params[i + 1])) != null)
                    {
                        counterManager.ResetCounter(counterName, (int)possibleCounterValue, scope);
                        i++;
                    }
                    else
                    {
                        counterManager.ResetCounter(counterName, scope);
                    }
                }
            }
            String counterIncrement = cssProps.Get(CssConstants.COUNTER_INCREMENT);

            if (counterIncrement != null)
            {
                CssCounterManager counterManager = context.GetCounterManager();
                String[]          @params        = iText.IO.Util.StringUtil.Split(counterIncrement, " ");
                for (int i = 0; i < @params.Length; i++)
                {
                    String counterName = @params[i];
                    int?   possibleIncrementValue;
                    if (i + 1 < @params.Length && (possibleIncrementValue = CssUtils.ParseInteger(@params[i + 1])) != null)
                    {
                        counterManager.IncrementCounter(counterName, (int)possibleIncrementValue, scope);
                        i++;
                    }
                    else
                    {
                        counterManager.IncrementCounter(counterName, scope);
                    }
                }
            }
        }
 private static void ProcessIncrement(String counterIncrement, CssContext context)
 {
     if (counterIncrement != null)
     {
         CssCounterManager counterManager = context.GetCounterManager();
         String[]          @params        = iText.IO.Util.StringUtil.Split(counterIncrement, " ");
         for (int i = 0; i < @params.Length; i++)
         {
             String counterName = @params[i];
             int?   possibleIncrementValue;
             if (i + 1 < @params.Length && (possibleIncrementValue = CssDimensionParsingUtils.ParseInteger(@params[i +
                                                                                                                   1])) != null)
             {
                 counterManager.IncrementCounter(counterName, (int)possibleIncrementValue);
                 i++;
             }
             else
             {
                 counterManager.IncrementCounter(counterName);
             }
         }
     }
 }
Beispiel #7
0
        private void Test(String fileName, String elementPath, params String[] expectedStyles)
        {
            String        filePath    = sourceFolder + fileName;
            IXmlParser    parser      = new JsoupHtmlParser();
            IDocumentNode document    = parser.Parse(new FileStream(filePath, FileMode.Open, FileAccess.Read), "UTF-8");
            ICssResolver  cssResolver = new DefaultCssResolver(document, MediaDeviceDescription.CreateDefault(), new ResourceResolver
                                                                   (""));
            CssContext context = new CssContext();

            ResolveStylesForTree(document, cssResolver, context);
            IElementNode element = FindElement(document, elementPath);

            if (element == null)
            {
                NUnit.Framework.Assert.Fail(MessageFormatUtil.Format("Element at path \"{0}\" was not found.", elementPath
                                                                     ));
            }
            IDictionary <String, String> elementStyles     = element.GetStyles();
            ICollection <String>         expectedStylesSet = new HashSet <String>(JavaUtil.ArraysAsList(expectedStyles));
            ICollection <String>         actualStylesSet   = StylesMapToHashSet(elementStyles);

            NUnit.Framework.Assert.IsTrue(SetsAreEqual(expectedStylesSet, actualStylesSet), GetDifferencesMessage(expectedStylesSet
                                                                                                                  , actualStylesSet));
        }
        /// <summary>Starts processing counters.</summary>
        /// <remarks>
        /// Starts processing counters. Pushes current counter values to counters if necessary.
        /// Usually it is expected that this method should be called before processing children of the element.
        /// </remarks>
        /// <param name="context">the processor context</param>
        /// <param name="element">the element which counters shall be processed</param>
        public static void StartProcessingCounters(CssContext context, IElementNode element)
        {
            CssCounterManager counterManager = context.GetCounterManager();

            counterManager.PushEveryCounterToCounters(element);
        }
 public static void ProcessCounters(IDictionary <String, String> cssProps, CssContext context, INode scope)
 {
     ProcessCounters(cssProps, context);
 }
Beispiel #10
0
 public CssToken(TokenType tokenType, char ch, CssContext context)
     : this(tokenType, new string(ch, 1), context)
 {
 }
Beispiel #11
0
 public CssToken(TokenType tokenType, string text, CssContext context)
 {
     m_tokenType = tokenType;
     m_text = text;
     m_context = context.Clone();
 }
Beispiel #12
0
        /// <summary>Gets the resolved page class node.</summary>
        /// <param name="rootNode">the root node</param>
        /// <param name="cssResolver">the CSS resolver</param>
        /// <param name="context">the CSS context</param>
        /// <param name="pageClasses">the page classes</param>
        /// <returns>the resolved page class node</returns>
        private static PageContextNode GetResolvedPageClassNode(INode rootNode, ICssResolver cssResolver, CssContext
                                                                context, params String[] pageClasses)
        {
            PageContextNode pagesClassNode = new PageContextNode(rootNode);

            foreach (String pageClass in pageClasses)
            {
                pagesClassNode.AddPageClass(pageClass);
            }
            IDictionary <String, String> pageClassStyles = cssResolver.ResolveStyles(pagesClassNode, context);

            pagesClassNode.SetStyles(pageClassStyles);
            return(pagesClassNode);
        }
Beispiel #13
0
        /// <summary>Gets the resolved margin boxes.</summary>
        /// <param name="pageClassNode">the page contex node</param>
        /// <param name="cssResolver">the CSS resolver</param>
        /// <param name="context">the CSS context</param>
        /// <returns>the resolved margin boxes</returns>
        private static IList <PageMarginBoxContextNode> GetResolvedMarginBoxes(PageContextNode pageClassNode, ICssResolver
                                                                               cssResolver, CssContext context)
        {
            IList <PageMarginBoxContextNode> resolvedMarginBoxes = new List <PageMarginBoxContextNode>();

            foreach (String pageMarginBoxName in pageMarginBoxNames)
            {
                PageMarginBoxContextNode     marginBoxNode   = new PageMarginBoxContextNode(pageClassNode, pageMarginBoxName);
                IDictionary <String, String> marginBoxStyles = cssResolver.ResolveStyles(marginBoxNode, context);
                if (!marginBoxNode.ChildNodes().IsEmpty())
                {
                    marginBoxNode.SetStyles(marginBoxStyles);
                    resolvedMarginBoxes.Add(marginBoxNode);
                }
                context.SetQuotesDepth(0);
            }
            return(resolvedMarginBoxes);
        }
Beispiel #14
0
 public CssToken(TokenType tokenType, char ch, CssContext context)
     : this(tokenType, new string(ch, 1), context)
 {
 }
Beispiel #15
0
 public CssToken(TokenType tokenType, string text, CssContext context)
 {
     m_tokenType = tokenType;
     m_text      = text;
     m_context   = context.Clone();
 }
        /// <summary>Ends processing counters.</summary>
        /// <remarks>
        /// Ends processing counters. Pops values of given counter list from counters if necessary.
        /// Usually it is expected that this method should be called after processing cheldren of the element.
        /// </remarks>
        /// <param name="context">the processor context</param>
        /// <param name="element">the element which counters shall be processed</param>
        public static void EndProcessingCounters(CssContext context, IElementNode element)
        {
            CssCounterManager counterManager = context.GetCounterManager();

            counterManager.PopEveryCounterFromCounters(element);
        }
Beispiel #17
0
        /// <summary>
        /// Resolves a node with a
        /// <see cref="PageContextProperties"/>
        /// instance as result.
        /// </summary>
        /// <param name="rootNode">the root node to resolve</param>
        /// <param name="cssResolver">the CSS resolver</param>
        /// <param name="context">the CSS context</param>
        /// <param name="pageClasses">the page classes</param>
        /// <returns>
        /// the
        /// <see cref="PageContextProperties"/>
        /// for a specific node
        /// </returns>
        public static iText.Html2pdf.Attach.Impl.Layout.PageContextProperties Resolve(INode rootNode, ICssResolver
                                                                                      cssResolver, CssContext context, params String[] pageClasses)
        {
            PageContextNode pageProps = GetResolvedPageClassNode(rootNode, cssResolver, context, pageClasses);
            IList <PageMarginBoxContextNode> pagesMarginBoxes = GetResolvedMarginBoxes(pageProps, cssResolver, context);

            return(new iText.Html2pdf.Attach.Impl.Layout.PageContextProperties(pageProps, pagesMarginBoxes));
        }
Beispiel #18
0
        private void ReadBuffer(Char[] buffer, Int32 length)
        {
            for (var i = 0; i < length; i++)
            {
                currentColumn++;

                if (buffer[i] == BreakLine)
                {
                    currentLine++;
                    currentColumn = 1;
                    continue;
                }

                var newIndex = commentary.Interpret(buffer, i, length, currentLine, currentColumn);

                if (newIndex > i)
                {
                    currentColumn += newIndex - i;
                    i = newIndex;
                }

                if (commentary.IsCommentary || commentary.IsOpen || commentary.IsClose)
                {
                    if (commentary.IsClose)
                        commentary.Reset();
                    continue;
                }

                if (i > length)
                    break;

                switch (buffer[i])
                {
                    case OpenScope:
                        var ctx = CreateInstanceCssContext(GetCurrentContent());

                        if (context != null)
                            context.SetGraph(ctx);

                        context = ctx;

                        context.Open(currentLine, currentColumn);
                        break;

                    case CloseScope:
                        context.Parse(GetCurrentContent());
                        context.Close(currentLine, currentColumn);
                        context = context.ParentContext;
                        break;

                    default:
                        sb.Append(buffer[i]);
                        break;
                }
            }
        }