699 lines
24 KiB
C#
699 lines
24 KiB
C#
using System;
|
|
using System.util;
|
|
|
|
using iTextSharp.text.pdf;
|
|
using iTextSharp.text.html;
|
|
|
|
/*
|
|
* $Id: Font.cs,v 1.11 2008/05/13 11:25:10 psoares33 Exp $
|
|
*
|
|
*
|
|
* 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 virtual 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 virtual 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);
|
|
}
|
|
}
|
|
}
|