using System;
using System.util;
using iTextSharp.text.pdf;
using iTextSharp.text.html;
/*
* $Id: Font.cs,v 1.9 2007/09/28 13:55:23 psoares33 Exp $
* $Name: $
*
* Copyright 1999, 2000, 2001, 2002 by Bruno Lowagie.
*
* 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 {
/// <summary>
/// Contains all the specifications of a font: fontfamily, size, style and color.
/// </summary>
/// <example>
/// <code>
/// Paragraph p = new Paragraph("This is a paragraph",
/// <strong>new Font(Font.HELVETICA, 18, Font.BOLDITALIC, new Color(0, 0, 255))</strong>);
/// </code>
/// </example>
public class Font : IComparable {
// static membervariables for the different families
/// <summary> a possible value of a font family. </summary>
public const int COURIER = 0;
/// <summary> a possible value of a font family. </summary>
public const int HELVETICA = 1;
/// <summary> a possible value of a font family. </summary>
public const int TIMES_ROMAN = 2;
/// <summary> a possible value of a font family. </summary>
public const int SYMBOL = 3;
/// <summary> a possible value of a font family. </summary>
public const int ZAPFDINGBATS = 4;
// static membervariables for the different styles
/// <summary> this is a possible style. </summary>
public const int NORMAL = 0;
/// <summary> this is a possible style. </summary>
public const int BOLD = 1;
/// <summary> this is a possible style. </summary>
public const int ITALIC = 2;
/// <summary> this is a possible style. </summary>
public const int UNDERLINE = 4;
/// <summary> this is a possible style. </summary>
public const int STRIKETHRU = 8;
/// <summary> this is a possible style. </summary>
public const int BOLDITALIC = BOLD | ITALIC;
// static membervariables
/// <summary> the value of an undefined attribute. </summary>
public const int UNDEFINED = -1;
/// <summary> the value of the default size. </summary>
public const int DEFAULTSIZE = 12;
// membervariables
/// <summary> the value of the fontfamily. </summary>
private int family = UNDEFINED;
/// <summary> the value of the fontsize. </summary>
private float size = UNDEFINED;
/// <summary> the value of the style. </summary>
private int style = UNDEFINED;
/// <summary> the value of the color. </summary>
private Color color;
/// <summary> the external font </summary>
private BaseFont baseFont = null;
// constructors
/**
* Copy constructor of a Font
* @param other the font that has to be copied
*/
public Font(Font other) {
this.color = other.color;
this.family = other.family;
this.size = other.size;
this.style = other.style;
this.baseFont = other.baseFont;
}
/// <summary>
/// Constructs a Font.
/// </summary>
/// <param name="family">the family to which this font belongs</param>
/// <param name="size">the size of this font</param>
/// <param name="style">the style of this font</param>
/// <param name="color">the Color of this font.</param>
public Font(int family, float size, int style, Color color) {
this.family = family;
this.size = size;
this.style = style;
this.color = color;
}
/// <summary>
/// Constructs a Font.
/// </summary>
/// <param name="bf">the external font</param>
/// <param name="size">the size of this font</param>
/// <param name="style">the style of this font</param>
/// <param name="color">the Color of this font.</param>
public Font(BaseFont bf, float size, int style, Color color) {
this.baseFont = bf;
this.size = size;
this.style = style;
this.color = color;
}
/// <summary>
/// Constructs a Font.
/// </summary>
/// <param name="bf">the external font</param>
/// <param name="size">the size of this font</param>
/// <param name="style">the style of this font</param>
public Font(BaseFont bf, float size, int style) : this(bf, size, style, null) {}
/// <summary>
/// Constructs a Font.
/// </summary>
/// <param name="bf">the external font</param>
/// <param name="size">the size of this font</param>
public Font(BaseFont bf, float size) : this(bf, size, UNDEFINED, null) {}
/// <summary>
/// Constructs a Font.
/// </summary>
/// <param name="bf">the external font</param>
public Font(BaseFont bf) : this(bf, UNDEFINED, UNDEFINED, null) {}
/// <summary>
/// Constructs a Font.
/// </summary>
/// <param name="family">the family to which this font belongs</param>
/// <param name="size">the size of this font</param>
/// <param name="style">the style of this font</param>
public Font(int family, float size, int style) : this(family, size, style, null) {}
/// <summary>
/// Constructs a Font.
/// </summary>
/// <param name="family">the family to which this font belongs</param>
/// <param name="size">the size of this font</param>
public Font(int family, float size) : this(family, size, UNDEFINED, null) {}
/// <summary>
/// Constructs a Font.
/// </summary>
/// <param name="family">the family to which this font belongs</param>
public Font(int family) : this(family, UNDEFINED, UNDEFINED, null) {}
/// <summary>
/// Constructs a Font.
/// </summary>
/// <overloads>
/// Has nine overloads.
/// </overloads>
public Font() : this(UNDEFINED, UNDEFINED, UNDEFINED, null) {}
// implementation of the Comparable interface
/// <summary>
/// Compares this Font with another
/// </summary>
/// <param name="obj">the other Font</param>
/// <returns>a value</returns>
public int CompareTo(Object obj) {
if (obj == null) {
return -1;
}
Font font;
try {
font = (Font) obj;
if (baseFont != null && !baseFont.Equals(font.BaseFont)) {
return -2;
}
if (this.family != font.Family) {
return 1;
}
if (this.size != font.Size) {
return 2;
}
if (this.style != font.Style) {
return 3;
}
if (this.color == null) {
if (font.Color == null) {
return 0;
}
return 4;
}
if (font.Color == null) {
return 4;
}
if (((Color)this.color).Equals(font.Color)) {
return 0;
}
return 4;
}
catch {
return -3;
}
}
// FAMILY
/// <summary>
/// Gets the family of this font.
/// </summary>
/// <value>the value of the family</value>
public int Family {
get {
return family;
}
}
/// <summary>
/// Gets the familyname as a string.
/// </summary>
/// <value>the familyname</value>
public virtual string Familyname {
get {
string tmp = "unknown";
switch (this.Family) {
case Font.COURIER:
return FontFactory.COURIER;
case Font.HELVETICA:
return FontFactory.HELVETICA;
case Font.TIMES_ROMAN:
return FontFactory.TIMES_ROMAN;
case Font.SYMBOL:
return FontFactory.SYMBOL;
case Font.ZAPFDINGBATS:
return FontFactory.ZAPFDINGBATS;
default:
if (baseFont != null) {
string[][] names = baseFont.FamilyFontName;
for (int i = 0; i < names.Length; i++) {
if ("0".Equals(names[i][2])) {
return names[i][3];
}
if ("1033".Equals(names[i][2])) {
tmp = names[i][3];
}
if ("".Equals(names[i][2])) {
tmp = names[i][3];
}
}
}
break;
}
return tmp;
}
}
/// <summary>
/// Sets the family using a String ("Courier",
/// "Helvetica", "Times New Roman", "Symbol" or "ZapfDingbats").
/// </summary>
/// <param name="family">A String representing a certain font-family.</param>
public virtual void SetFamily(String family) {
this.family = GetFamilyIndex(family);
}
/// <summary>
/// Translates a string-value of a certain family
/// into the index that is used for this family in this class.
/// </summary>
/// <param name="family">A string representing a certain font-family</param>
/// <returns>the corresponding index</returns>
public static int GetFamilyIndex(string family) {
if (Util.EqualsIgnoreCase(family, FontFactory.COURIER)) {
return COURIER;
}
if (Util.EqualsIgnoreCase(family, FontFactory.HELVETICA)) {
return HELVETICA;
}
if (Util.EqualsIgnoreCase(family, FontFactory.TIMES_ROMAN)) {
return TIMES_ROMAN;
}
if (Util.EqualsIgnoreCase(family, FontFactory.SYMBOL)) {
return SYMBOL;
}
if (Util.EqualsIgnoreCase(family, FontFactory.ZAPFDINGBATS)) {
return ZAPFDINGBATS;
}
return UNDEFINED;
}
// SIZE
/// <summary>
/// Get/set the size of this font.
/// </summary>
/// <value>the size of this font</value>
public virtual float Size {
get {
return size;
}
set {
this.size = value;
}
}
/** Gets the size that can be used with the calculated <CODE>BaseFont</CODE>.
* @return the size that can be used with the calculated <CODE>BaseFont</CODE>
*/
public float CalculatedSize {
get {
float s = this.size;
if (s == UNDEFINED) {
s = DEFAULTSIZE;
}
return s;
}
}
/**
* Gets the leading that can be used with this font.
*
* @param linespacing
* a certain linespacing
* @return the height of a line
*/
public float GetCalculatedLeading(float linespacing) {
return linespacing * CalculatedSize;
}
// STYLE
/// <summary>
/// Gets the style of this font.
/// </summary>
/// <value>the style of this font</value>
public int Style {
get {
return style;
}
}
/** Gets the style that can be used with the calculated <CODE>BaseFont</CODE>.
* @return the style that can be used with the calculated <CODE>BaseFont</CODE>
*/
public int CalculatedStyle {
get {
int style = this.style;
if (style == UNDEFINED) {
style = NORMAL;
}
if (baseFont != null)
return style;
if (family == SYMBOL || family == ZAPFDINGBATS)
return style;
else
return style & (~BOLDITALIC);
}
}
/// <summary>
/// checks if this font is Bold.
/// </summary>
/// <returns>a boolean</returns>
public bool IsBold() {
if (style == UNDEFINED) {
return false;
}
return (style & BOLD) == BOLD;
}
/// <summary>
/// checks if this font is Bold.
/// </summary>
/// <returns>a boolean</returns>
public bool IsItalic() {
if (style == UNDEFINED) {
return false;
}
return (style & ITALIC) == ITALIC;
}
/// <summary>
/// checks if this font is underlined.
/// </summary>
/// <returns>a boolean</returns>
public bool IsUnderlined() {
if (style == UNDEFINED) {
return false;
}
return (style & UNDERLINE) == UNDERLINE;
}
/// <summary>
/// checks if the style of this font is STRIKETHRU.
/// </summary>
/// <returns>a boolean</returns>
public bool IsStrikethru() {
if (style == UNDEFINED) {
return false;
}
return (style & STRIKETHRU) == STRIKETHRU;
}
/// <summary>
/// Sets the style using a String containing one of
/// more of the following values: normal, bold, italic, underline, strike.
/// </summary>
/// <param name="style">A String representing a certain style.</param>
public virtual void SetStyle(String style) {
if (this.style == UNDEFINED) this.style = NORMAL;
this.style |= GetStyleValue(style);
}
/**
* Sets the style.
* @param style the style.
*/
public virtual void SetStyle(int style) {
if (this.style == UNDEFINED) this.style = NORMAL;
this.style |= style;
}
/// <summary>
/// Translates a string-value of a certain style
/// into the index value is used for this style in this class.
/// </summary>
/// <param name="style">a string</param>
/// <returns>the corresponding value</returns>
public static int GetStyleValue(string style) {
int s = 0;
if (style.IndexOf(Markup.CSS_VALUE_NORMAL) != -1) {
s |= NORMAL;
}
if (style.IndexOf(Markup.CSS_VALUE_BOLD) != -1) {
s |= BOLD;
}
if (style.IndexOf(Markup.CSS_VALUE_ITALIC) != -1) {
s |= ITALIC;
}
if (style.IndexOf(Markup.CSS_VALUE_OBLIQUE) != -1) {
s |= ITALIC;
}
if (style.IndexOf(Markup.CSS_VALUE_UNDERLINE) != -1) {
s |= UNDERLINE;
}
if (style.IndexOf(Markup.CSS_VALUE_LINETHROUGH) != -1) {
s |= STRIKETHRU;
}
return s;
}
// COLOR
/// <summary>
/// Get/set the color of this font.
/// </summary>
/// <value>the color of this font</value>
public virtual Color Color {
get {
return color;
}
set {
this.color = value;
}
}
/// <summary>
/// Sets the color.
/// </summary>
/// <param name="red">the red-value of the new color</param>
/// <param name="green">the green-value of the new color</param>
/// <param name="blue">the blue-value of the new color</param>
public virtual void SetColor(int red, int green, int blue) {
this.color = new Color(red, green, blue);
}
// BASEFONT
/// <summary>
/// Gets the BaseFont inside this object.
/// </summary>
/// <value>the BaseFont</value>
public BaseFont BaseFont {
get {
return baseFont;
}
}
/** Gets the <CODE>BaseFont</CODE> this class represents.
* For the built-in fonts a <CODE>BaseFont</CODE> is calculated.
* @param specialEncoding <CODE>true</CODE> to use the special encoding for Symbol and ZapfDingbats,
* <CODE>false</CODE> to always use <CODE>Cp1252</CODE>
* @return the <CODE>BaseFont</CODE> this class represents
*/
public BaseFont GetCalculatedBaseFont(bool specialEncoding) {
if (baseFont != null)
return baseFont;
int style = this.style;
if (style == UNDEFINED) {
style = NORMAL;
}
String fontName = BaseFont.HELVETICA;
String encoding = BaseFont.WINANSI;
BaseFont cfont = null;
switch (family) {
case COURIER:
switch (style & BOLDITALIC) {
case BOLD:
fontName = BaseFont.COURIER_BOLD;
break;
case ITALIC:
fontName = BaseFont.COURIER_OBLIQUE;
break;
case BOLDITALIC:
fontName = BaseFont.COURIER_BOLDOBLIQUE;
break;
default:
//case NORMAL:
fontName = BaseFont.COURIER;
break;
}
break;
case TIMES_ROMAN:
switch (style & BOLDITALIC) {
case BOLD:
fontName = BaseFont.TIMES_BOLD;
break;
case ITALIC:
fontName = BaseFont.TIMES_ITALIC;
break;
case BOLDITALIC:
fontName = BaseFont.TIMES_BOLDITALIC;
break;
default:
//case NORMAL:
fontName = BaseFont.TIMES_ROMAN;
break;
}
break;
case SYMBOL:
fontName = BaseFont.SYMBOL;
if (specialEncoding)
encoding = BaseFont.SYMBOL;
break;
case ZAPFDINGBATS:
fontName = BaseFont.ZAPFDINGBATS;
if (specialEncoding)
encoding = BaseFont.ZAPFDINGBATS;
break;
default:
//case Font.HELVETICA:
switch (style & BOLDITALIC) {
case BOLD:
fontName = BaseFont.HELVETICA_BOLD;
break;
case ITALIC:
fontName = BaseFont.HELVETICA_OBLIQUE;
break;
case BOLDITALIC:
fontName = BaseFont.HELVETICA_BOLDOBLIQUE;
break;
default:
//case NORMAL:
fontName = BaseFont.HELVETICA;
break;
}
break;
}
cfont = BaseFont.CreateFont(fontName, encoding, false);
return cfont;
}
// Helper methods
/// <summary>
/// Checks if the properties of this font are undefined or null.
/// <p/>
/// If so, the standard should be used.
/// </summary>
/// <returns>a boolean</returns>
public bool IsStandardFont() {
return (family == UNDEFINED
&& size == UNDEFINED
&& style == UNDEFINED
&& color == null
&& baseFont == null);
}
/// <summary>
/// Replaces the attributes that are equal to null with
/// the attributes of a given font.
/// </summary>
/// <param name="font">the font of a bigger element class</param>
/// <returns>a Font</returns>
public virtual Font Difference(Font font) {
if (font == null) return this;
// size
float dSize = font.size;
if (dSize == UNDEFINED) {
dSize = this.size;
}
// style
int dStyle = UNDEFINED;
int style1 = this.Style;
int style2 = font.Style;
if (style1 != UNDEFINED || style2 != UNDEFINED) {
if (style1 == UNDEFINED) style1 = 0;
if (style2 == UNDEFINED) style2 = 0;
dStyle = style1 | style2;
}
// color
object dColor = (Color)font.Color;
if (dColor == null) {
dColor = this.Color;
}
// family
if (font.baseFont != null) {
return new Font(font.BaseFont, dSize, dStyle, (Color)dColor);
}
if (font.Family != UNDEFINED) {
return new Font(font.Family, dSize, dStyle, (Color)dColor);
}
if (this.baseFont != null) {
if (dStyle == style1) {
return new Font(this.BaseFont, dSize, dStyle, (Color)dColor);
}
else {
return FontFactory.GetFont(this.Familyname, dSize, dStyle, (Color)dColor);
}
}
return new Font(this.Family, dSize, dStyle, (Color)dColor);
}
}
}
Submit an article or tip