Java Code Examples for com.lowagie.text.Font#ITALIC

public void add( final String text ) {
  int style = Font.NORMAL;
  if ( bold ) {
    style |= Font.BOLD;
  }
  if ( italic ) {
    style |= Font.ITALIC;
  }
  if ( strikethrough ) {
    style |= Font.STRIKETHRU;
  }
  if ( underline ) {
    style |= Font.UNDERLINE;
  }

  final BaseFontFontMetrics fontMetrics =
      metaData.getBaseFontFontMetrics( fontName, fontSize, bold, italic, "utf-8", false, false );
  final BaseFont baseFont = fontMetrics.getBaseFont();
  final Font font = new Font( baseFont, (float) fontSize, style, textColor );
  final Chunk c = new Chunk( text, font );
  if ( backgroundColor != null ) {
    c.setBackground( backgroundColor );
  }
  target.add( c );
}
 

private int computeStyle( final TypedMapWrapper<Attribute, Object> attributes, final PdfTextSpec pdfTextSpec ) {
  final Float weight = attributes.get( TextAttribute.WEIGHT, TextAttribute.WEIGHT_REGULAR, Float.class );
  final Float italics = attributes.get( TextAttribute.POSTURE, TextAttribute.POSTURE_OBLIQUE, Float.class );
  final boolean underlined = attributes.exists( TextAttribute.UNDERLINE );
  final boolean strikethrough = attributes.exists( TextAttribute.STRIKETHROUGH );

  FontNativeContext nativeContext = pdfTextSpec.getFontMetrics().getNativeContext();

  int style = 0;
  if ( nativeContext.isNativeBold() == false && weight >= TextAttribute.WEIGHT_DEMIBOLD ) {
    style |= Font.BOLD;
  }
  if ( nativeContext.isNativeItalics() == false && italics >= TextAttribute.POSTURE_OBLIQUE ) {
    style |= Font.ITALIC;
  }
  if ( underlined ) {
    style |= Font.UNDERLINE;
  }
  if ( strikethrough ) {
    style |= Font.STRIKETHRU;
  }
  return style;
}
 

/**
 * Returns the PDF representation of this <CODE>PdfOutline</CODE>.
 *
 * @param writer the encryption information
 * @param os
 * @throws IOException
 */

public void toPdf(PdfWriter writer, OutputStream os) throws IOException {
    if (color != null && !color.equals(Color.black)) {
        put(PdfName.C, new PdfArray(new float[]{color.getRed()/255f,color.getGreen()/255f,color.getBlue()/255f}));
    }
    int flag = 0;
    if ((style & Font.BOLD) != 0)
        flag |= 2;
    if ((style & Font.ITALIC) != 0)
        flag |= 1;
    if (flag != 0)
        put(PdfName.F, new PdfNumber(flag));
    if (parent != null) {
        put(PdfName.PARENT, parent.indirectReference());
    }
    if (destination != null && destination.hasPage()) {
        put(PdfName.DEST, destination);
    }
    if (action != null)
        put(PdfName.A, action);
    if (count != 0) {
        put(PdfName.COUNT, new PdfNumber(count));
    }
    super.toPdf(writer, os);
}
 

public static int getFontStyle( String fontStyle, String fontWeight )
{
	int styleValue = Font.NORMAL;

	if ( CSSConstants.CSS_OBLIQUE_VALUE.equals( fontStyle )
			|| CSSConstants.CSS_ITALIC_VALUE.equals( fontStyle ) )
	{
		styleValue |= Font.ITALIC;
	}

	if ( CSSConstants.CSS_BOLD_VALUE.equals( fontWeight )
			|| CSSConstants.CSS_BOLDER_VALUE.equals( fontWeight )
			|| CSSConstants.CSS_600_VALUE.equals( fontWeight )
			|| CSSConstants.CSS_700_VALUE.equals( fontWeight )
			|| CSSConstants.CSS_800_VALUE.equals( fontWeight )
			|| CSSConstants.CSS_900_VALUE.equals( fontWeight ) )
	{
		styleValue |= Font.BOLD;
	}
	return styleValue;
}
 

/**
 * Returns the PDF representation of this <CODE>PdfOutline</CODE>.
 *
 * @param writer the encryption information
 * @param os
 * @throws IOException
 */

public void toPdf(PdfWriter writer, OutputStream os) throws IOException {
    if (color != null && !color.equals(Color.black)) {
        put(PdfName.C, new PdfArray(new float[]{color.getRed()/255f,color.getGreen()/255f,color.getBlue()/255f}));
    }
    int flag = 0;
    if ((style & Font.BOLD) != 0)
        flag |= 2;
    if ((style & Font.ITALIC) != 0)
        flag |= 1;
    if (flag != 0)
        put(PdfName.F, new PdfNumber(flag));
    if (parent != null) {
        put(PdfName.PARENT, parent.indirectReference());
    }
    if (destination != null && destination.hasPage()) {
        put(PdfName.DEST, destination);
    }
    if (action != null)
        put(PdfName.A, action);
    if (count != 0) {
        put(PdfName.COUNT, new PdfNumber(count));
    }
    super.toPdf(writer, os);
}
 

private void setTextProperty( String tag, TextStyle style)
{
	FontInfo info = style.getFontInfo( );

	writer.openTag( tag ); 
	//FIXME: retrieve language and not hard code values
	writer.attribute( "lang", "en-US" );
	writer.attribute( "altLang", "zh-CN" );
	writer.attribute( "dirty", "0" );
	writer.attribute( "smtClean", "0" );
	if ( style.isLinethrough( ) )
	{
		writer.attribute( "strike", "sngStrike" );
	}
	if ( style.isUnderline( ) )
	{
		writer.attribute( "u", "sng" );
	}
	writer.attribute( "sz",  canvas.getScaledValue( info.getFontSize( ) * 100 ) );
	
	boolean isItalic = ( info.getFontStyle( ) & Font.ITALIC ) != 0;
	boolean isBold = ( info.getFontStyle( ) & Font.BOLD ) != 0;
	if ( isItalic )
	{
		writer.attribute( "i", 1 );
	}
	if ( isBold )
	{
		writer.attribute( "b", 1 );
	}
	canvas.setBackgroundColor( style.getColor( ) );
	setTextFont( info.getFontName( ) );
	canvas.setHyperlink( link );
	canvas.setBookmark( bmk_relationshipid);
	writer.closeTag( tag );
}
 

public int getItalicAdjust( )
{
	// get width for text with simulated italic font.
	if ( simulation && ( Font.ITALIC == fontStyle
			|| Font.BOLDITALIC == fontStyle ) )
	{
		return (int) ( fontHeight
				* EmitterUtil.getItalicHorizontalCoefficient( ) );
	}
	return 0;
}
 

/**
 * If the BaseFont can NOT find the correct physical glyph, we need to
 * simulate the proper style for the font. The "simulate" flag will be set
 * if we need to simulate it.
 */
private boolean needSimulate( BaseFont font )
{
	if ( fontStyle == Font.NORMAL )
	{
		return false;
	}

	String[][] fullNames = bf.getFullFontName( );
	String fullName = getEnglishName( fullNames );
	String lcf = fullName.toLowerCase( );

	int fs = Font.NORMAL;
	if ( lcf.indexOf( "bold" ) != -1 )
	{
		fs |= Font.BOLD;
	}
	if ( lcf.indexOf( "italic" ) != -1 || lcf.indexOf( "oblique" ) != -1 )
	{
		fs |= Font.ITALIC;
	}
	if ( ( fontStyle & Font.BOLDITALIC ) == fs )
	{
		if ( fontWeight > 400 && fontWeight != 700 )
		{
			// not a regular bold font.
			return true;
		}
		else
		{
			return false;
		}
	}
	return true;
}
 

public int getWidth( )
{
	int fontStyle = fi.getFontStyle( );
	//get width for text with simulated italic font.
	if ( fi.getSimulation( )
			&& ( Font.ITALIC == fontStyle || Font.BOLDITALIC == fontStyle ) )
	{
		width = (int) ( width + height
				* EmitterUtil.getItalicHorizontalCoefficient( ) );
	}
	return width;
}
 

private void setTextProperty( String fontName, float fontSize,
		int fontStyle, Color color, boolean isUnderline,
		boolean isLineThrough, HyperlinkDef link )
{
	writer.openTag( "a:rPr" );
	writer.attribute( "lang", "en-US" );
	writer.attribute( "altLang", "zh-CN" );
	writer.attribute( "dirty", "0" );
	writer.attribute( "smtClean", "0" );
	if ( isLineThrough )
	{
		writer.attribute( "strike", "sngStrike" );
	}
	if ( isUnderline )
	{
		writer.attribute( "u", "sng" );
	}
	writer.attribute( "sz", (int) ( fontSize * 100 ) );
	boolean isItalic = ( fontStyle & Font.ITALIC ) != 0;
	boolean isBold = ( fontStyle & Font.BOLD ) != 0;
	if ( isItalic )
	{
		writer.attribute( "i", 1 );
	}
	if ( isBold )
	{
		writer.attribute( "b", 1 );
	}
	setBackgroundColor( color );
	setTextFont( fontName );
	setHyperlink( link );
	writer.closeTag( "a:rPr" );
}
 

/**
 * Returns the PDF representation of this <CODE>PdfOutline</CODE>.
 *
 * @param writer the encryption information
 * @param os
 * @throws IOException
 */

@Override
public void toPdf(PdfWriter writer, OutputStream os) throws IOException {
	if (color != null && !color.equals(Color.black)) {
		put(PdfName.C, new PdfArray(new float[] { color.getRed() / 255f, color.getGreen() / 255f, color.getBlue() / 255f }));
	}
	int flag = 0;
	if ((style & Font.BOLD) != 0) {
		flag |= 2;
	}
	if ((style & Font.ITALIC) != 0) {
		flag |= 1;
	}
	if (flag != 0) {
		put(PdfName.F, new PdfNumber(flag));
	}
	if (parent != null) {
		put(PdfName.PARENT, parent.indirectReference());
	}
	if (destination != null && destination.hasPage()) {
		put(PdfName.DEST, destination);
	}
	if (action != null) {
		put(PdfName.A, action);
	}
	if (count != 0) {
		put(PdfName.COUNT, new PdfNumber(count));
	}
	super.toPdf(writer, os);
}
 

/**
    * Extended font styles example.
    * 
    * 
    */
@Test
   public void main() throws Exception {
           Document document = new Document();
           RtfWriter2.getInstance(document, PdfTestBase.getOutputStream("ExtendedFontStyles.rtf"));
           document.open();
           
           // Use the RtfFont.STYLE_* instead of the Font styles.
           RtfFont doubleStrikethrough = new RtfFont("Arial", RtfFont.UNDEFINED,
                   RtfFont.STYLE_DOUBLE_STRIKETHROUGH);
           RtfFont shadow = new RtfFont("Arial", RtfFont.UNDEFINED,
                   RtfFont.STYLE_SHADOW);
           
           // Or combine them with Font styles.
           RtfFont engravedItalic = new RtfFont("Arial", RtfFont.UNDEFINED,
                   RtfFont.STYLE_ENGRAVED | Font.ITALIC);
           
           // The hidden style is special since it hides text.
           RtfFont hidden = new RtfFont("Arial", RtfFont.UNDEFINED,
                   RtfFont.STYLE_HIDDEN);
           
           Paragraph paragraph = new Paragraph("This text is ", new RtfFont("Arial", 12));
           
           // Use the RtfFonts when creating the text.
           paragraph.add(new Chunk("deleted,", doubleStrikethrough));
           paragraph.add(new Chunk(" shady,", shadow));
           paragraph.add(new Chunk(" engraved and italic", engravedItalic));
           paragraph.add(" and");
           paragraph.add(new Chunk(" you won't see this", hidden));
           paragraph.add(" nothing.");
           
           document.add(paragraph);
           document.close();
   }
 

/**
 * Generates a PDF file with the 14 standard Type 1 Fonts
 * 
 */
@Test
public void main() throws Exception {

	// step 1: creation of a document-object
	Document document = new Document();
	// step 2:
	// we create a writer that listens to the document
	PdfWriter.getInstance(document, PdfTestBase.getOutputStream("StandardType1Fonts.pdf"));

	// step 3: we open the document
	document.open();
	// step 4:

	// the 14 standard fonts in PDF: do not use this Font constructor!
	// this is for demonstration purposes only, use FontFactory!
	Font[] fonts = new Font[14];
	fonts[0] = new Font(Font.COURIER, Font.DEFAULTSIZE, Font.NORMAL);
	fonts[1] = new Font(Font.COURIER, Font.DEFAULTSIZE, Font.ITALIC);
	fonts[2] = new Font(Font.COURIER, Font.DEFAULTSIZE, Font.BOLD);
	fonts[3] = new Font(Font.COURIER, Font.DEFAULTSIZE, Font.BOLD | Font.ITALIC);
	fonts[4] = new Font(Font.HELVETICA, Font.DEFAULTSIZE, Font.NORMAL);
	fonts[5] = new Font(Font.HELVETICA, Font.DEFAULTSIZE, Font.ITALIC);
	fonts[6] = new Font(Font.HELVETICA, Font.DEFAULTSIZE, Font.BOLD);
	fonts[7] = new Font(Font.HELVETICA, Font.DEFAULTSIZE, Font.BOLDITALIC);
	fonts[8] = new Font(Font.TIMES_ROMAN, Font.DEFAULTSIZE, Font.NORMAL);
	fonts[9] = new Font(Font.TIMES_ROMAN, Font.DEFAULTSIZE, Font.ITALIC);
	fonts[10] = new Font(Font.TIMES_ROMAN, Font.DEFAULTSIZE, Font.BOLD);
	fonts[11] = new Font(Font.TIMES_ROMAN, Font.DEFAULTSIZE, Font.BOLDITALIC);
	fonts[12] = new Font(Font.SYMBOL);
	fonts[13] = new Font(Font.ZAPFDINGBATS);
	// add the content
	for (int i = 0; i < 14; i++) {
		document.add(new Paragraph("quick brown fox jumps over the lazy dog", fonts[i]));
	}

	// step 5: we close the document
	document.close();
}
 

public Font getFont(ChainedProperties props) {
	String face = props.getProperty(ElementTags.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(HtmlTags.I))
		style |= Font.ITALIC;
	if (props.hasProperty(HtmlTags.B))
		style |= Font.BOLD;
	if (props.hasProperty(HtmlTags.U))
		style |= Font.UNDERLINE;
	if (props.hasProperty(HtmlTags.S))
		style |= Font.STRIKETHRU;
	String value = props.getProperty(ElementTags.SIZE);
	float size = 12;
	if (value != null)
		size = Float.parseFloat(value);
	Color color = Markup.decodeColor(props.getProperty("color"));
	String encoding = props.getProperty("encoding");
	if (encoding == null)
		encoding = BaseFont.WINANSI;
	return fontImp.getFont(face, encoding, true, size, style, color);
}
 

public void drawString( String str, float x, float y, FontInfo fontInfo,
        float letterSpacing, float wordSpacing, Color color,
        boolean linethrough, boolean overline, boolean underline,
        CSSValue align )
{
	y = transformY( y );
	String text = str;
	boolean needSimulateItalic = false;
	boolean needSimulateBold = false;
	boolean hasSpace = wordSpacing != 0 || letterSpacing != 0;
	float offset = 0;
	if ( fontInfo != null )
	{
		float fontSize = fontInfo.getFontSize( );
		int fontStyle = fontInfo.getFontStyle( );
		if ( fontInfo.getSimulation( ) )
		{
			if ( fontStyle == Font.BOLD || fontStyle == Font.BOLDITALIC )
			{
				offset = (float) ( fontSize * Math.log10( fontSize ) / 100 );
				needSimulateBold = true;
			}
			if ( fontStyle == Font.ITALIC || fontStyle == Font.BOLDITALIC )
			{
				needSimulateItalic = true;
			}
		}
		BaseFont baseFont = fontInfo.getBaseFont( );
		String fontName = baseFont.getPostscriptFontName( );
		text = applyFont( fontName, fontStyle, fontSize, text );
	}
	outputColor( color );
	out.print( x + " " + y + " " );
	if ( hasSpace )
		out.print( wordSpacing + " " + letterSpacing + " " );
	out.print( text + " " );
	if ( needSimulateBold )
		out.print( offset + " " );
	String command = getCommand( hasSpace, needSimulateBold,
	                             needSimulateItalic );
	out.println( command );
}
 

protected void drawText( String text, float textX, float textY, float baseline,
		float width, float height, TextStyle textStyle )
{
	// width of text is enlarged by 1 point because the text will be
	// automatically wrapped if the width of textbox equals to the width of
	// text exactly.
	FontInfo fontInfo = textStyle.getFontInfo( );
	float descend = fontInfo.getBaseFont( ).getFontDescriptor(
			BaseFont.DESCENT, fontInfo.getFontSize( ) );
	
	StyleEntry style = StyleBuilder.createEmptyStyleEntry( StyleConstant.TYPE_TEXT );
	style.setProperty( StyleConstant.DIRECTION_PROP, textStyle.getDirection( ) );
	style.setProperty( StyleConstant.COLOR_PROP, OdpUtil.getColorString( textStyle.getColor( ) ) );
	style.setProperty( StyleConstant.LETTER_SPACING, new FloatValue(
			FloatValue.CSS_PT, textStyle.getLetterSpacing( )
					/ PDFConstants.LAYOUT_TO_PDF_RATIO ) );
	
	if ( fontInfo != null )
	{
		BaseFont baseFont = fontInfo.getBaseFont( );
		String fontName = OdpUtil.getFontName( baseFont );

		style.setProperty( StyleConstant.FONT_FAMILY_PROP, fontName );
		style.setProperty( StyleConstant.FONT_SIZE_PROP, Double.valueOf( fontInfo.getFontSize( ) ) );
		
		if (( fontInfo.getFontStyle( ) & Font.BOLD ) != 0 )
		{
			style.setProperty( StyleConstant.FONT_WEIGHT_PROP, "bold" );
		}
		
		if (( fontInfo.getFontStyle( ) & Font.ITALIC ) != 0)
		{
			style.setProperty( StyleConstant.FONT_STYLE_PROP, "italic" );
		}
		
		if ( textStyle.isLinethrough( ) )
		{
			style.setProperty( StyleConstant.TEXT_LINE_THROUGH_PROP, true );
		}
		
		if ( textStyle.isOverline( ) )
		{
			style.setProperty( StyleConstant.TEXT_OVERLINE_PROP, true );
		}
		
		if ( textStyle.isUnderline( ) )
		{
			style.setProperty( StyleConstant.TEXT_UNDERLINE_PROP, true );
		}
	}
	
	// TODO: hyperlink

	context.addStyle( style );
	writer.drawText( text, textX, textY, width, height + descend * 0.6f,
			textFrameStyle, style, link );
}
 

/**
 * Writes the representation of a <CODE>Font</CODE>.
 *
 * @param font              a <CODE>Font</CODE>
 * @param styleAttributes   the style of the font
 * @throws IOException
 */

protected void write(Font font, Properties styleAttributes) throws IOException {
    if (font == null || !isOtherFont(font) /* || styleAttributes == null*/) return;
    write(" ");
    write(HtmlTags.STYLE);
    write("=\"");
    if (styleAttributes != null) {
        String key;
        for (Enumeration e = styleAttributes.propertyNames(); e.hasMoreElements(); ) {
            key = (String)e.nextElement();
            writeCssProperty(key, styleAttributes.getProperty(key));
        }
    }
    if (isOtherFont(font)) {
        writeCssProperty(Markup.CSS_KEY_FONTFAMILY, font.getFamilyname());
        
        if (font.getSize() != Font.UNDEFINED) {
            writeCssProperty(Markup.CSS_KEY_FONTSIZE, font.getSize() + "pt");
        }
        if (font.getColor() != null) {
            writeCssProperty(Markup.CSS_KEY_COLOR, HtmlEncoder.encode(font.getColor()));
        }
        
        int fontstyle = font.getStyle();
        BaseFont bf = font.getBaseFont();
        if (bf != null) {
            String ps = bf.getPostscriptFontName().toLowerCase();
            if (ps.indexOf("bold") >= 0) {
                if (fontstyle == Font.UNDEFINED)
                    fontstyle = 0;
                fontstyle |= Font.BOLD;
            }
            if (ps.indexOf("italic") >= 0 || ps.indexOf("oblique") >= 0) {
                if (fontstyle == Font.UNDEFINED)
                    fontstyle = 0;
                fontstyle |= Font.ITALIC;
            }
        }
        if (fontstyle != Font.UNDEFINED && fontstyle != Font.NORMAL) {
            switch (fontstyle & Font.BOLDITALIC) {
                case Font.BOLD:
                    writeCssProperty(Markup.CSS_KEY_FONTWEIGHT, Markup.CSS_VALUE_BOLD);
                    break;
                case Font.ITALIC:
                    writeCssProperty(Markup.CSS_KEY_FONTSTYLE, Markup.CSS_VALUE_ITALIC);
                    break;
                case Font.BOLDITALIC:
                    writeCssProperty(Markup.CSS_KEY_FONTWEIGHT, Markup.CSS_VALUE_BOLD);
                    writeCssProperty(Markup.CSS_KEY_FONTSTYLE, Markup.CSS_VALUE_ITALIC);
                    break;
            }
            
            // CSS only supports one decoration tag so if both are specified
            // only one of the two will display
            if ((fontstyle & Font.UNDERLINE) > 0) {
                writeCssProperty(Markup.CSS_KEY_TEXTDECORATION, Markup.CSS_VALUE_UNDERLINE);
            }
            if ((fontstyle & Font.STRIKETHRU) > 0) {
                writeCssProperty(Markup.CSS_KEY_TEXTDECORATION, Markup.CSS_VALUE_LINETHROUGH);
            }
        }
    }
    write("\"");
}
 

public void beforePropertyChange(String propertyName) {
	// do we have any text to do anything with?
	// if not, then just return without action.
	if(this.buffer.length() == 0) return;
	
	if(propertyName.startsWith(RtfProperty.CHARACTER)) {
		// this is a character change,
		// add a new chunk to the current paragraph using current character settings.
		Chunk chunk = new Chunk();
		chunk.append(this.buffer.toString());
		this.buffer = new StringBuffer(255);
		HashMap charProperties = this.rtfParser.getState().properties.getProperties(RtfProperty.CHARACTER);
		String defFont = (String)charProperties.get(RtfProperty.CHARACTER_FONT);
		if(defFont == null) defFont = "0";
		RtfDestinationFontTable fontTable = (RtfDestinationFontTable)this.rtfParser.getDestination("fonttbl");
		Font currFont = fontTable.getFont(defFont);
		int fs = Font.NORMAL;
		if(charProperties.containsKey(RtfProperty.CHARACTER_BOLD)) fs |= Font.BOLD; 
		if(charProperties.containsKey(RtfProperty.CHARACTER_ITALIC)) fs |= Font.ITALIC;
		if(charProperties.containsKey(RtfProperty.CHARACTER_UNDERLINE)) fs |= Font.UNDERLINE;
		Font useFont = FontFactory.getFont(currFont.getFamilyname(), 12, fs, new Color(0,0,0));
		
		
		chunk.setFont(useFont);
		if(iTextParagraph == null) this.iTextParagraph = new Paragraph();
		this.iTextParagraph.add(chunk);

	} else {
		if(propertyName.startsWith(RtfProperty.PARAGRAPH)) {
			// this is a paragraph change. what do we do?
		} else {
			if(propertyName.startsWith(RtfProperty.SECTION)) {
				
			} else {
				if(propertyName.startsWith(RtfProperty.DOCUMENT)) {

				}
			}
		}
	}		
}
 

/**
 * Writes the representation of a <CODE>Font</CODE>.
 *
 * @param font a <CODE>Font</CODE>
 * @param styleAttributes the style of the font
 * @throws IOException
 */

protected void write(Font font, Properties styleAttributes) throws IOException {
	if (font == null || !isOtherFont(font) /* || styleAttributes == null*/) {
		return;
	}
	write(" ");
	write(HtmlTags.STYLE);
	write("=\"");
	if (styleAttributes != null) {
		String key;
		for (Enumeration e = styleAttributes.propertyNames(); e.hasMoreElements();) {
			key = (String) e.nextElement();
			writeCssProperty(key, styleAttributes.getProperty(key));
		}
	}
	if (isOtherFont(font)) {
		writeCssProperty(Markup.CSS_KEY_FONTFAMILY, font.getFamilyname());

		if (font.getSize() != Font.UNDEFINED) {
			writeCssProperty(Markup.CSS_KEY_FONTSIZE, font.getSize() + "pt");
		}
		if (font.getColor() != null) {
			writeCssProperty(Markup.CSS_KEY_COLOR, HtmlEncoder.encode(font.getColor()));
		}

		int fontstyle = font.getStyle();
		BaseFont bf = font.getBaseFont();
		if (bf != null) {
			String ps = bf.getPostscriptFontName().toLowerCase();
			if (ps.indexOf("bold") >= 0) {
				if (fontstyle == Font.UNDEFINED) {
					fontstyle = 0;
				}
				fontstyle |= Font.BOLD;
			}
			if (ps.indexOf("italic") >= 0 || ps.indexOf("oblique") >= 0) {
				if (fontstyle == Font.UNDEFINED) {
					fontstyle = 0;
				}
				fontstyle |= Font.ITALIC;
			}
		}
		if (fontstyle != Font.UNDEFINED && fontstyle != Font.NORMAL) {
			switch (fontstyle & Font.BOLDITALIC) {
				case Font.BOLD:
					writeCssProperty(Markup.CSS_KEY_FONTWEIGHT, Markup.CSS_VALUE_BOLD);
					break;
				case Font.ITALIC:
					writeCssProperty(Markup.CSS_KEY_FONTSTYLE, Markup.CSS_VALUE_ITALIC);
					break;
				case Font.BOLDITALIC:
					writeCssProperty(Markup.CSS_KEY_FONTWEIGHT, Markup.CSS_VALUE_BOLD);
					writeCssProperty(Markup.CSS_KEY_FONTSTYLE, Markup.CSS_VALUE_ITALIC);
					break;
			}

			// CSS only supports one decoration tag so if both are specified
			// only one of the two will display
			if ((fontstyle & Font.UNDERLINE) > 0) {
				writeCssProperty(Markup.CSS_KEY_TEXTDECORATION, Markup.CSS_VALUE_UNDERLINE);
			}
			if ((fontstyle & Font.STRIKETHRU) > 0) {
				writeCssProperty(Markup.CSS_KEY_TEXTDECORATION, Markup.CSS_VALUE_LINETHROUGH);
			}
		}
	}
	write("\"");
}
 

public Font getFont(ChainedProperties props) {
	String face = props.getProperty(ElementTags.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(HtmlTags.I)) {
		style |= Font.ITALIC;
	}
	if (props.hasProperty(HtmlTags.B)) {
		style |= Font.BOLD;
	}
	if (props.hasProperty(HtmlTags.U)) {
		style |= Font.UNDERLINE;
	}
	if (props.hasProperty(HtmlTags.S)) {
		style |= Font.STRIKETHRU;
	}
	String value = props.getProperty(ElementTags.SIZE);
	float size = 12;
	if (value != null) {
		size = Float.parseFloat(value);
	}
	Color color = Markup.decodeColor(props.getProperty("color"));
	String encoding = props.getProperty("encoding");
	if (encoding == null) {
		encoding = BaseFont.WINANSI;
	}
	return fontImp.getFont(face, encoding, true, size, style, color);
}