iText 5 itextpdf.jar Source Code
itextpdf.jar is a component in iText 5 Java library to provide core functionalities.
iText Java library allows you to generate and manage PDF documents.
The Source Code files are provided at iText GitHub site.
You can compile it to generate your JAR file, using pom.xml as the build configuration file.
The source code of itextpdf-5.5.14.jar is provided below:
✍: FYIcenter.com
⏎ com/itextpdf/text/html/simpleparser/HTMLWorker.java
/*
*
* This file is part of the iText (R) project.
Copyright (c) 1998-2020 iText Group NV
* Authors: Bruno Lowagie, Paulo Soares, et al.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License version 3
* as published by the Free Software Foundation with the addition of the
* following permission added to Section 15 as permitted in Section 7(a):
* FOR ANY PART OF THE COVERED WORK IN WHICH THE COPYRIGHT IS OWNED BY
* ITEXT GROUP. ITEXT GROUP DISCLAIMS THE WARRANTY OF NON INFRINGEMENT
* OF THIRD PARTY RIGHTS
*
* This program 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 Affero General Public License for more details.
* You should have received a copy of the GNU Affero General Public License
* along with this program; if not, see http://www.gnu.org/licenses or write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA, 02110-1301 USA, or download the license from the following URL:
* http://itextpdf.com/terms-of-use/
*
* The interactive user interfaces in modified source and object code versions
* of this program must display Appropriate Legal Notices, as required under
* Section 5 of the GNU Affero General Public License.
*
* In accordance with Section 7(b) of the GNU Affero General Public License,
* a covered work must retain the producer line in every PDF that is created
* or manipulated using iText.
*
* You can be released from the requirements of the license by purchasing
* a commercial license. Buying such a license is mandatory as soon as you
* develop commercial activities involving the iText software without
* disclosing the source code of your own applications.
* These activities include: offering paid services to customers as an ASP,
* serving PDFs on the fly in a web application, shipping iText with a closed
* source product.
*
* For more information, please contact iText Software Corp. at this
* address: sales@itextpdf.com
*/
package com.itextpdf.text.html.simpleparser;
import java.io.IOException;
import java.io.Reader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Stack;
import com.itextpdf.text.Chunk;
import com.itextpdf.text.DocListener;
import com.itextpdf.text.DocumentException;
import com.itextpdf.text.Element;
import com.itextpdf.text.ExceptionConverter;
import com.itextpdf.text.FontProvider;
import com.itextpdf.text.Image;
import com.itextpdf.text.ListItem;
import com.itextpdf.text.Paragraph;
import com.itextpdf.text.Phrase;
import com.itextpdf.text.Rectangle;
import com.itextpdf.text.TextElementArray;
import com.itextpdf.text.html.HtmlTags;
import com.itextpdf.text.html.HtmlUtilities;
import com.itextpdf.text.log.Logger;
import com.itextpdf.text.log.LoggerFactory;
import com.itextpdf.text.pdf.PdfPCell;
import com.itextpdf.text.pdf.PdfPTable;
import com.itextpdf.text.pdf.draw.LineSeparator;
import com.itextpdf.text.xml.simpleparser.SimpleXMLDocHandler;
import com.itextpdf.text.xml.simpleparser.SimpleXMLParser;
/**
* Old iText class that allows you to convert HTML to PDF.
* We've completely rewritten HTML to PDF conversion and we made it a separate project named XML Worker.
* @deprecated since 5.5.2; please switch to XML Worker instead (this is a separate project)
*/
@Deprecated
public class HTMLWorker implements SimpleXMLDocHandler, DocListener {
private static Logger LOGGER = LoggerFactory.getLogger(HTMLWorker.class);
/**
* DocListener that will listen to the Elements
* produced by parsing the HTML.
* This can be a com.lowagie.text.Document adding
* the elements to a Document directly, or an
* HTMLWorker instance strong the objects in a List
*/
protected DocListener document;
/**
* The map with all the supported tags.
* @since 5.0.6
*/
protected Map<String, HTMLTagProcessor> tags;
/** The object defining all the styles. */
private StyleSheet style = new StyleSheet();
/**
* Creates a new instance of HTMLWorker
* @param document A class that implements <CODE>DocListener</CODE>
*/
public HTMLWorker(final DocListener document) {
this(document, null, null);
}
/**
* Creates a new instance of HTMLWorker
* @param document A class that implements <CODE>DocListener</CODE>
* @param tags A map containing the supported tags
* @param style A StyleSheet
* @since 5.0.6
*/
public HTMLWorker(final DocListener document, final Map<String, HTMLTagProcessor> tags, final StyleSheet style) {
this.document = document;
setSupportedTags(tags);
setStyleSheet(style);
}
/**
* Sets the map with supported tags.
* @param tags
* @since 5.0.6
*/
public void setSupportedTags(Map<String, HTMLTagProcessor> tags) {
if (tags == null)
tags = new HTMLTagProcessors();
this.tags = tags;
}
/**
* Setter for the StyleSheet
* @param style the StyleSheet
*/
public void setStyleSheet(StyleSheet style) {
if (style == null)
style = new StyleSheet();
this.style = style;
}
/**
* Parses content read from a java.io.Reader object.
* @param reader the content
* @throws IOException
*/
public void parse(final Reader reader) throws IOException {
LOGGER.info("Please note, there is a more extended version of the HTMLWorker available in the iText XMLWorker");
SimpleXMLParser.parse(this, null, reader, true);
}
// state machine
/**
* Stack with the Elements that already have been processed.
* @since iText 5.0.6 (private => protected)
*/
protected Stack<Element> stack = new Stack<Element>();
/**
* Keeps the content of the current paragraph
* @since iText 5.0.6 (private => protected)
*/
protected Paragraph currentParagraph;
/**
* The current hierarchy chain of tags.
* @since 5.0.6
*/
private final ChainedProperties chain = new ChainedProperties();
/**
* @see com.itextpdf.text.xml.simpleparser.SimpleXMLDocHandler#startDocument()
*/
public void startDocument() {
HashMap<String, String> attrs = new HashMap<String, String>();
style.applyStyle(HtmlTags.BODY, attrs);
chain.addToChain(HtmlTags.BODY, attrs);
}
/**
* @see com.itextpdf.text.xml.simpleparser.SimpleXMLDocHandler#startElement(java.lang.String, java.util.Map)
*/
public void startElement(final String tag, final Map<String, String> attrs) {
HTMLTagProcessor htmlTag = tags.get(tag);
if (htmlTag == null) {
return;
}
// apply the styles to attrs
style.applyStyle(tag, attrs);
// deal with the style attribute
StyleSheet.resolveStyleAttribute(attrs, chain);
// process the tag
try {
htmlTag.startElement(this, tag, attrs);
} catch (DocumentException e) {
throw new ExceptionConverter(e);
} catch (IOException e) {
throw new ExceptionConverter(e);
}
}
/**
* @see com.itextpdf.text.xml.simpleparser.SimpleXMLDocHandler#text(java.lang.String)
*/
public void text(String content) {
if (skipText)
return;
if (currentParagraph == null) {
currentParagraph = createParagraph();
}
if (!insidePRE) {
// newlines and carriage returns are ignored
if (content.trim().length() == 0 && content.indexOf(' ') < 0) {
return;
}
content = HtmlUtilities.eliminateWhiteSpace(content);
}
Chunk chunk = createChunk(content);
currentParagraph.add(chunk);
}
/**
* @see com.itextpdf.text.xml.simpleparser.SimpleXMLDocHandler#endElement(java.lang.String)
*/
public void endElement(final String tag) {
HTMLTagProcessor htmlTag = tags.get(tag);
if (htmlTag == null) {
return;
}
// process the tag
try {
htmlTag.endElement(this, tag);
} catch (DocumentException e) {
throw new ExceptionConverter(e);
}
}
/**
* @see com.itextpdf.text.xml.simpleparser.SimpleXMLDocHandler#endDocument()
*/
public void endDocument() {
try {
// flush the stack
for (int k = 0; k < stack.size(); ++k)
document.add(stack.elementAt(k));
// add current paragraph
if (currentParagraph != null)
document.add(currentParagraph);
currentParagraph = null;
} catch (Exception e) {
throw new ExceptionConverter(e);
}
}
// stack and current paragraph operations
/**
* Adds a new line to the currentParagraph.
* @since 5.0.6
*/
public void newLine() {
if (currentParagraph == null) {
currentParagraph = new Paragraph();
}
currentParagraph.add(createChunk("\n"));
}
/**
* Flushes the current paragraph, indicating that we're starting
* a new block.
* If the stack is empty, the paragraph is added to the document.
* Otherwise the Paragraph is added to the stack.
* @since 5.0.6
*/
public void carriageReturn() throws DocumentException {
if (currentParagraph == null)
return;
if (stack.empty())
document.add(currentParagraph);
else {
Element obj = stack.pop();
if (obj instanceof TextElementArray) {
TextElementArray current = (TextElementArray) obj;
current.add(currentParagraph);
}
stack.push(obj);
}
currentParagraph = null;
}
/**
* Stacks the current paragraph, indicating that we're starting
* a new span.
* @since 5.0.6
*/
public void flushContent() {
pushToStack(currentParagraph);
currentParagraph = new Paragraph();
}
/**
* Pushes an element to the Stack.
* @param element
* @since 5.0.6
*/
public void pushToStack(final Element element) {
if (element != null)
stack.push(element);
}
/**
* Updates the chain with a new tag and new attributes.
* @param tag the new tag
* @param attrs the corresponding attributes
* @since 5.0.6
*/
public void updateChain(final String tag, final Map<String, String> attrs) {
chain.addToChain(tag, attrs);
}
/**
* Updates the chain by removing a tag.
* @param tag the new tag
* @since 5.0.6
*/
public void updateChain(final String tag) {
chain.removeChain(tag);
}
// providers that help find resources such as images and fonts
/**
* Key used to store the image provider in the providers map.
* @since 5.0.6
*/
public static final String IMG_PROVIDER = "img_provider";
/**
* Key used to store the image processor in the providers map.
* @since 5.0.6
*/
public static final String IMG_PROCESSOR = "img_interface";
/**
* Key used to store the image store in the providers map.
* @since 5.0.6
*/
public static final String IMG_STORE = "img_static";
/**
* Key used to store the image baseurl provider in the providers map.
* @since 5.0.6
*/
public static final String IMG_BASEURL = "img_baseurl";
/**
* Key used to store the font provider in the providers map.
* @since 5.0.6
*/
public static final String FONT_PROVIDER = "font_factory";
/**
* Key used to store the link provider in the providers map.
* @since 5.0.6
*/
public static final String LINK_PROVIDER = "alink_interface";
/**
* Map containing providers such as a FontProvider or ImageProvider.
* @since 5.0.6 (renamed from interfaceProps)
*/
private Map<String, Object> providers = new HashMap<String, Object>();
/**
* Setter for the providers.
* If a FontProvider is added, the ElementFactory is updated.
* @param providers a Map with different providers
* @since 5.0.6
*/
public void setProviders(final Map<String, Object> providers) {
if (providers == null)
return;
this.providers = providers;
FontProvider ff = null;
if (providers != null)
ff = (FontProvider) providers.get(FONT_PROVIDER);
if (ff != null)
factory.setFontProvider(ff);
}
// factory that helps create objects
/**
* Factory that is able to create iText Element objects.
* @since 5.0.6
*/
private final ElementFactory factory = new ElementFactory();
/**
* Creates a Chunk using the factory.
* @param content the content of the chunk
* @return a Chunk with content
* @since 5.0.6
*/
public Chunk createChunk(final String content) {
return factory.createChunk(content, chain);
}
/**
* Creates a Paragraph using the factory.
* @return a Paragraph without any content
* @since 5.0.6
*/
public Paragraph createParagraph() {
return factory.createParagraph(chain);
}
/**
* Creates a List object.
* @param tag should be "ol" or "ul"
* @return a List object
* @since 5.0.6
*/
public com.itextpdf.text.List createList(final String tag) {
return factory.createList(tag, chain);
}
/**
* Creates a ListItem object.
* @return a ListItem object
* @since 5.0.6
*/
public ListItem createListItem() {
return factory.createListItem(chain);
}
/**
* Creates a LineSeparator object.
* @param attrs properties of the LineSeparator
* @return a LineSeparator object
* @since 5.0.6
*/
public LineSeparator createLineSeparator(final Map<String, String> attrs) {
return factory.createLineSeparator(attrs, currentParagraph.getLeading()/2);
}
/**
* Creates an Image object.
* @param attrs properties of the Image
* @return an Image object (or null if the Image couldn't be found)
* @throws DocumentException
* @throws IOException
* @since 5.0.6
*/
public Image createImage(final Map<String, String> attrs) throws DocumentException, IOException {
String src = attrs.get(HtmlTags.SRC);
if (src == null)
return null;
Image img = factory.createImage(
src, attrs, chain, document,
(ImageProvider)providers.get(IMG_PROVIDER),
(ImageStore)providers.get(IMG_STORE),
(String)providers.get(IMG_BASEURL));
return img;
}
/**
* Creates a Cell.
* @param tag the tag
* @return a CellWrapper object
* @since 5.0.6
*/
public CellWrapper createCell(final String tag) {
return new CellWrapper(tag, chain);
}
// processing objects
/**
* Adds a link to the current paragraph.
* @since 5.0.6
*/
public void processLink() {
if (currentParagraph == null) {
currentParagraph = new Paragraph();
}
// The link provider allows you to do additional processing
LinkProcessor i = (LinkProcessor) providers.get(HTMLWorker.LINK_PROVIDER);
if (i == null || !i.process(currentParagraph, chain)) {
// sets an Anchor for all the Chunks in the current paragraph
String href = chain.getProperty(HtmlTags.HREF);
if (href != null) {
for (Chunk ck : currentParagraph.getChunks()) {
ck.setAnchor(href);
}
}
}
// a link should be added to the current paragraph as a phrase
if (stack.isEmpty()) {
// no paragraph to add too, 'a' tag is first element
Paragraph tmp = new Paragraph(new Phrase(currentParagraph));
currentParagraph = tmp;
} else {
Paragraph tmp = (Paragraph) stack.pop();
tmp.add(new Phrase(currentParagraph));
currentParagraph = tmp;
}
}
/**
* Fetches the List from the Stack and adds it to
* the TextElementArray on top of the Stack,
* or to the Document if the Stack is empty.
* @throws DocumentException
* @since 5.0.6
*/
public void processList() throws DocumentException {
if (stack.empty())
return;
Element obj = stack.pop();
if (!(obj instanceof com.itextpdf.text.List)) {
stack.push(obj);
return;
}
if (stack.empty())
document.add(obj);
else
((TextElementArray) stack.peek()).add(obj);
}
/**
* Looks for the List object on the Stack,
* and adds the ListItem to the List.
* @throws DocumentException
* @since 5.0.6
*/
public void processListItem() throws DocumentException {
if (stack.empty())
return;
Element obj = stack.pop();
if (!(obj instanceof ListItem)) {
stack.push(obj);
return;
}
if (stack.empty()) {
document.add(obj);
return;
}
ListItem item = (ListItem) obj;
Element list = stack.pop();
if (!(list instanceof com.itextpdf.text.List)) {
stack.push(list);
return;
}
((com.itextpdf.text.List) list).add(item);
item.adjustListSymbolFont();
stack.push(list);
}
/**
* Processes an Image.
* @param img
* @param attrs
* @throws DocumentException
* @since 5.0.6
*/
public void processImage(final Image img, final Map<String, String> attrs) throws DocumentException {
ImageProcessor processor = (ImageProcessor)providers.get(HTMLWorker.IMG_PROCESSOR);
if (processor == null || !processor.process(img, attrs, chain, document)) {
String align = attrs.get(HtmlTags.ALIGN);
if (align != null) {
carriageReturn();
}
if (currentParagraph == null) {
currentParagraph = createParagraph();
}
currentParagraph.add(new Chunk(img, 0, 0, true));
currentParagraph.setAlignment(HtmlUtilities.alignmentValue(align));
if (align != null) {
carriageReturn();
}
}
}
/**
* Processes the Table.
* @throws DocumentException
* @since 5.0.6
*/
public void processTable() throws DocumentException{
TableWrapper table = (TableWrapper) stack.pop();
PdfPTable tb = table.createTable();
tb.setSplitRows(true);
if (stack.empty())
document.add(tb);
else
((TextElementArray) stack.peek()).add(tb);
}
/**
* Gets the TableWrapper from the Stack and adds a new row.
* @since 5.0.6
*/
public void processRow() {
ArrayList<PdfPCell> row = new ArrayList<PdfPCell>();
ArrayList<Float> cellWidths = new ArrayList<Float>();
boolean percentage = false;
float width;
float totalWidth = 0;
int zeroWidth = 0;
TableWrapper table = null;
while (true) {
Element obj = stack.pop();
if (obj instanceof CellWrapper) {
CellWrapper cell = (CellWrapper)obj;
width = cell.getWidth();
cellWidths.add(new Float(width));
percentage |= cell.isPercentage();
if (width == 0) {
zeroWidth++;
}
else {
totalWidth += width;
}
row.add(cell.getCell());
}
if (obj instanceof TableWrapper) {
table = (TableWrapper) obj;
break;
}
}
table.addRow(row);
if (cellWidths.size() > 0) {
// cells come off the stack in reverse, naturally
totalWidth = 100 - totalWidth;
Collections.reverse(cellWidths);
float[] widths = new float[cellWidths.size()];
boolean hasZero = false;
for (int i = 0; i < widths.length; i++) {
widths[i] = cellWidths.get(i).floatValue();
if (widths[i] == 0 && percentage && zeroWidth > 0) {
widths[i] = totalWidth / zeroWidth;
}
if (widths[i] == 0) {
hasZero = true;
break;
}
}
if (!hasZero)
table.setColWidths(widths);
}
stack.push(table);
}
// state variables and methods
/** Stack to keep track of table tags. */
private final Stack<boolean[]> tableState = new Stack<boolean[]>();
/** Boolean to keep track of TR tags. */
private boolean pendingTR = false;
/** Boolean to keep track of TD and TH tags */
private boolean pendingTD = false;
/** Boolean to keep track of LI tags */
private boolean pendingLI = false;
/**
* Boolean to keep track of PRE tags
* @since 5.0.6 renamed from isPRE
*/
private boolean insidePRE = false;
/**
* Indicates if text needs to be skipped.
* @since iText 5.0.6 (private => protected)
*/
protected boolean skipText = false;
/**
* Pushes the values of pendingTR and pendingTD
* to a state stack.
* @since 5.0.6
*/
public void pushTableState() {
tableState.push(new boolean[] { pendingTR, pendingTD });
}
/**
* Pops the values of pendingTR and pendingTD
* from a state stack.
* @since 5.0.6
*/
public void popTableState() {
boolean[] state = tableState.pop();
pendingTR = state[0];
pendingTD = state[1];
}
/**
* @return the pendingTR
* @since 5.0.6
*/
public boolean isPendingTR() {
return pendingTR;
}
/**
* @param pendingTR the pendingTR to set
* @since 5.0.6
*/
public void setPendingTR(final boolean pendingTR) {
this.pendingTR = pendingTR;
}
/**
* @return the pendingTD
* @since 5.0.6
*/
public boolean isPendingTD() {
return pendingTD;
}
/**
* @param pendingTD the pendingTD to set
* @since 5.0.6
*/
public void setPendingTD(final boolean pendingTD) {
this.pendingTD = pendingTD;
}
/**
* @return the pendingLI
* @since 5.0.6
*/
public boolean isPendingLI() {
return pendingLI;
}
/**
* @param pendingLI the pendingLI to set
* @since 5.0.6
*/
public void setPendingLI(final boolean pendingLI) {
this.pendingLI = pendingLI;
}
/**
* @return the insidePRE
* @since 5.0.6
*/
public boolean isInsidePRE() {
return insidePRE;
}
/**
* @param insidePRE the insidePRE to set
* @since 5.0.6
*/
public void setInsidePRE(final boolean insidePRE) {
this.insidePRE = insidePRE;
}
/**
* @return the skipText
* @since 5.0.6
*/
public boolean isSkipText() {
return skipText;
}
/**
* @param skipText the skipText to set
* @since 5.0.6
*/
public void setSkipText(final boolean skipText) {
this.skipText = skipText;
}
// static methods to parse HTML to a List of Element objects.
/** The resulting list of elements. */
protected List<Element> objectList;
/**
* Parses an HTML source to a List of Element objects
* @param reader the HTML source
* @param style a StyleSheet object
* @return a List of Element objects
* @throws IOException
*/
public static List<Element> parseToList(final Reader reader, final StyleSheet style)
throws IOException {
return parseToList(reader, style, null);
}
/**
* Parses an HTML source to a List of Element objects
* @param reader the HTML source
* @param style a StyleSheet object
* @param providers map containing classes with extra info
* @return a List of Element objects
* @throws IOException
*/
public static List<Element> parseToList(final Reader reader, final StyleSheet style,
final HashMap<String, Object> providers) throws IOException {
return parseToList(reader, style, null, providers);
}
/**
* Parses an HTML source to a List of Element objects
* @param reader the HTML source
* @param style a StyleSheet object
* @param tags a map containing supported tags and their processors
* @param providers map containing classes with extra info
* @return a List of Element objects
* @throws IOException
* @since 5.0.6
*/
public static List<Element> parseToList(final Reader reader, final StyleSheet style,
final Map<String, HTMLTagProcessor> tags, final HashMap<String, Object> providers) throws IOException {
HTMLWorker worker = new HTMLWorker(null, tags, style);
worker.document = worker;
worker.setProviders(providers);
worker.objectList = new ArrayList<Element>();
worker.parse(reader);
return worker.objectList;
}
// DocListener interface
/**
* @see com.itextpdf.text.ElementListener#add(com.itextpdf.text.Element)
*/
public boolean add(final Element element) throws DocumentException {
objectList.add(element);
return true;
}
/**
* @see com.itextpdf.text.DocListener#close()
*/
public void close() {
}
/**
* @see com.itextpdf.text.DocListener#newPage()
*/
public boolean newPage() {
return true;
}
/**
* @see com.itextpdf.text.DocListener#open()
*/
public void open() {
}
/**
* @see com.itextpdf.text.DocListener#resetPageCount()
*/
public void resetPageCount() {
}
/**
* @see com.itextpdf.text.DocListener#setMarginMirroring(boolean)
*/
public boolean setMarginMirroring(final boolean marginMirroring) {
return false;
}
/**
* @see com.itextpdf.text.DocListener#setMarginMirroring(boolean)
* @since 2.1.6
*/
public boolean setMarginMirroringTopBottom(final boolean marginMirroring) {
return false;
}
/**
* @see com.itextpdf.text.DocListener#setMargins(float, float, float, float)
*/
public boolean setMargins(final float marginLeft, final float marginRight,
final float marginTop, final float marginBottom) {
return true;
}
/**
* @see com.itextpdf.text.DocListener#setPageCount(int)
*/
public void setPageCount(final int pageN) {
}
/**
* @see com.itextpdf.text.DocListener#setPageSize(com.itextpdf.text.Rectangle)
*/
public boolean setPageSize(final Rectangle pageSize) {
return true;
}
// deprecated methods
/**
* Sets the providers.
* @deprecated use setProviders() instead
*/
@Deprecated
public void setInterfaceProps(final HashMap<String, Object> providers) {
setProviders(providers);
}
/**
* Gets the providers
* @deprecated use getProviders() instead
*/
@Deprecated
public Map<String, Object> getInterfaceProps() {
return providers;
}
}
⏎ com/itextpdf/text/html/simpleparser/HTMLWorker.java
Or download all of them as a single archive file:
File name: itextpdf-5.5.14-fyi.zip File size: 2163839 bytes Release date: 2009-10-09 Download
⇒ iText-2.1.6.jar - iText, a JAVA-PDF library
⇐ iText layout.jar Source Code
2021-07-03, 144557👍, 0💬
