Package org.pentaho.reporting.engine.classic.core.style

Source Code of org.pentaho.reporting.engine.classic.core.style.FontDefinition

/*
* This program is free software; you can redistribute it and/or modify it under the
* terms of the GNU Lesser General Public License, version 2.1 as published by the Free Software
* Foundation.
*
* You should have received a copy of the GNU Lesser General Public License along with this
* program; if not, you can obtain a copy at http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html
* or from the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*
* 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 Lesser General Public License for more details.
*
* Copyright (c) 2001 - 2009 Object Refinery Ltd, Pentaho Corporation and Contributors..  All rights reserved.
*/

package org.pentaho.reporting.engine.classic.core.style;

import java.awt.Font;
import java.io.Serializable;

import org.pentaho.reporting.libraries.base.util.StringUtils;


/**
* The FontDefinition encapsulates all Font-Style information. The java.awt.Font class does not support extended Styles
* like Strikethrough or Underline or font metadata like the base encoding.
*
* @author Thomas Morgner
* @deprecated use single properties instead.
*/
public class FontDefinition implements Serializable, Cloneable
{
  /**
   * a constant to draw a font in bold style.
   */
  public static final boolean BOLD = true;

  /**
   * a constant to draw a font in italic style.
   */
  public static final boolean ITALIC = true;

  /**
   * a constant to draw a font with underline style.
   */
  public static final boolean UNDERLINE = true;

  /**
   * a constant to draw a font with strikethrough style.
   */
  public static final boolean STRIKETHROUGH = true;

  /**
   * a constant to draw a font in plain style.
   */
  public static final boolean PLAIN = false;

  /**
   * the preferred text encoding for this font.
   */
  private String fontEncoding;

  /**
   * The FontName of the font. This defines the Font-Family.
   */
  private String fontName;

  /**
   * the font size in point.
   */
  private int fontSize;

  /**
   * this font's bold flag.
   */
  private boolean isBold;

  /**
   * this font's italic flag.
   */
  private boolean isItalic;

  /**
   * this font's underline flag.
   */
  private boolean isUnderline;

  /**
   * this font's strikethrough flag.
   */
  private boolean isStrikeThrough;

  /**
   * the AWT-Font represented by this font definition.
   */
  private transient Font font;

  /**
   * whether to embedd the font in the target documents, if supported.
   */
  private boolean embeddedFont;

  /**
   * a cached hashcode.
   */
  private transient int hashCode;

  // color is defined elsewhere

  /**
   * Creates a font definition using the given name and size and with the given styles defined.
   *
   * @param fontName      the font name used in this font definition.
   * @param fontSize      the font size for the defined font.
   * @param bold          true, if the font should be bold, false otherwise
   * @param italic        true, if the font should be italic, false otherwise
   * @param underline     true, if the font should be drawn with underline style, false otherwise
   * @param strikeThrough true, if the font should be drawn with strikethrough style, false otherwise
   * @param encoding      the default text encoding that should be used with this font.
   * @param embedded      whether this font should be embedded in the target document.
   */
  public FontDefinition(final String fontName, final int fontSize,
                        final boolean bold, final boolean italic,
                        final boolean underline, final boolean strikeThrough,
                        final String encoding, final boolean embedded)
  {
    if (fontName == null)
    {
      throw new NullPointerException("FontName must not be null");
    }
    if (fontSize <= 0)
    {
      throw new IllegalArgumentException("FontSize must be greater than 0");
    }
    this.fontName = fontName;
    this.fontSize = fontSize;
    isBold = bold;
    isItalic = italic;
    isUnderline = underline;
    isStrikeThrough = strikeThrough;
    this.fontEncoding = encoding;
    this.embeddedFont = embedded;
  }

  /**
   * Creates a font definition using the given name and size and with the given styles defined.
   *
   * @param fontName      the font name used in this font definition.
   * @param fontSize      the font size for the defined font.
   * @param bold          true, if the font should be bold, false otherwise
   * @param italic        true, if the font should be italic, false otherwise
   * @param underline     true, if the font should be drawn with underline style, false otherwise
   * @param strikeThrough true, if the font should be drawn with strikethrough style, false otherwise
   */
  public FontDefinition(final String fontName, final int fontSize, final boolean bold,
                        final boolean italic, final boolean underline,
                        final boolean strikeThrough)
  {
    this(fontName, fontSize, bold, italic, underline, strikeThrough, null, false);
  }

  /**
   * Creates a font definition using the given name and size and with no additional style enabled.
   *
   * @param fontName the font name used in this font definition.
   * @param fontSize the font size for the defined font.
   */
  public FontDefinition(final String fontName, final int fontSize)
  {
    this(fontName, fontSize, false, false, false, false, null, false);
  }

  /**
   * Creates a font definition base on the given AWT font.
   *
   * @param font the awt font that should be used as definition source.
   */
  public FontDefinition(final Font font)
  {
    this(font.getName(), font.getSize(), font.isBold(), font.isItalic(), false, false, null,
        false);
  }

  /**
   * Returns the font name of this font definition. The font name is the font face name.
   *
   * @return the name of the font.
   */
  public String getFontName()
  {
    return fontName;
  }

  /**
   * Returns the size of the defined font.
   *
   * @return the font size in points.
   */
  public int getFontSize()
  {
    return fontSize;
  }

  /**
   * Returns whether the font should be embedded in the target document.
   *
   * @return true, if the font should be embedded.
   */
  public boolean isEmbeddedFont()
  {
    return embeddedFont;
  }

  /**
   * Returns the bold style of this font definition.
   *
   * @return true, if the font should be drawn in bold style.
   */
  public boolean isBold()
  {
    return isBold;
  }

  /**
   * Returns the italic style of this font definition.
   *
   * @return true, if the font should be drawn in italic style.
   */
  public boolean isItalic()
  {
    return isItalic;
  }

  /**
   * Returns the underline style of this font definition.
   *
   * @return true, if the font should be drawn in underline style.
   */
  public boolean isUnderline()
  {
    return isUnderline;
  }

  /**
   * Returns the strikethrough style of this font definition.
   *
   * @return true, if the font should be drawn in strikethrough style.
   */
  public boolean isStrikeThrough()
  {
    return isStrikeThrough;
  }

  /**
   * Creates and returns a copy of this object.
   *
   * @return a clone of this instance.
   * @throws CloneNotSupportedException if a error occured during cloning .
   * @see java.lang.Cloneable
   */
  public Object clone()
      throws CloneNotSupportedException
  {
    return super.clone();
  }

  /**
   * Returns the AWT StyleInformation, only Bold and Italic are encoding in the return value.
   *
   * @return the AWT-compatible style information.
   */
  private int getFontStyle()
  {
    int fontstyle = Font.PLAIN;
    if (isBold())
    {
      fontstyle += Font.BOLD;
    }
    if (isItalic())
    {
      fontstyle += Font.ITALIC;
    }
    return fontstyle;
  }

  /**
   * returns the AWT-Font defined by this FontDefinition.
   *
   * @return the AWT font.
   */
  public Font getFont()
  {
    if (font == null)
    {
      font = new Font(getFontName(), getFontStyle(), getFontSize());
    }
    return font;
  }

  /**
   * Returns this fonts string encoding. If the font does not define an encoding, the given default encoding is
   * returned.
   *
   * @param defaultEncoding the font encoding to be used if this font definition does not define an own encoding.
   * @return the font encoding or the default encoding.
   */
  public String getFontEncoding(final String defaultEncoding)
  {
    if (this.fontEncoding == null)
    {
      return defaultEncoding;
    }
    else
    {
      return fontEncoding;
    }
  }

  /**
   * Returns a string representation of this font definition.
   *
   * @return a string representation of this font definition.
   */
  public String toString()
  {
    final StringBuffer buffer = new StringBuffer();
    buffer.append("FontDefinition='fontname=\"");
    buffer.append(fontName);
    buffer.append("\"; fontSize=");
    buffer.append(fontSize);
    buffer.append("; bold=");
    buffer.append(isBold);
    buffer.append("; italic=");
    buffer.append(isItalic);
    buffer.append("; underline=");
    buffer.append(isUnderline);
    buffer.append("; strike=");
    buffer.append(isStrikeThrough);
    buffer.append("; embedded=");
    buffer.append(embeddedFont);
    buffer.append('\'');
    return buffer.toString();
  }

  /**
   * Indicates whether some other object is "equal to" this one.
   *
   * @param o the reference object with which to compare.
   * @return <code>true</code> if this object is the same as the obj argument; <code>false</code> otherwise.
   * @see #hashCode()
   * @see java.util.Hashtable
   */
  public boolean equals(final Object o)
  {
    if (this == o)
    {
      return true;
    }
    if (!(o instanceof FontDefinition))
    {
      return false;
    }

    final FontDefinition definition = (FontDefinition) o;

    if (embeddedFont != definition.embeddedFont)
    {
      return false;
    }
    if (fontSize != definition.fontSize)
    {
      return false;
    }
    if (isBold != definition.isBold)
    {
      return false;
    }
    if (isItalic != definition.isItalic)
    {
      return false;
    }
    if (isStrikeThrough != definition.isStrikeThrough)
    {
      return false;
    }
    if (isUnderline != definition.isUnderline)
    {
      return false;
    }
    if (!fontName.equals(definition.fontName))
    {
      return false;
    }
    if (fontEncoding != null ? !fontEncoding.equals(definition.fontEncoding)
        : definition.fontEncoding != null)
    {
      return false;
    }

    return true;
  }

  /**
   * Returns a hash code value for the object. This method is supported for the benefit of hashtables such as those
   * provided by <code>java.util.Hashtable</code>.
   *
   * @return a hash code value for this object.
   * @see java.lang.Object#equals(java.lang.Object)
   */
  public int hashCode()
  {
    if (hashCode == 0)
    {
      int result = (fontEncoding != null ? fontEncoding.hashCode() : 0);
      result = 29 * result + fontName.hashCode();
      result = 29 * result + fontSize;
      result = 29 * result + (isBold ? 1 : 0);
      result = 29 * result + (isItalic ? 1 : 0);
      result = 29 * result + (isUnderline ? 1 : 0);
      result = 29 * result + (isStrikeThrough ? 1 : 0);
      result = 29 * result + (embeddedFont ? 1 : 0);
      hashCode = result;
    }
    return hashCode;
  }

  /**
   * Returns true if the logical font name is equivalent to 'SansSerif', and false otherwise.
   *
   * @return true or false.
   */
  public boolean isSansSerif()
  {
    return StringUtils.startsWithIgnoreCase(fontName, "SansSerif")
        || StringUtils.startsWithIgnoreCase(fontName, "Dialog")
        || StringUtils.startsWithIgnoreCase(fontName, "SanSerif");
    // is it a bug? Somewhere in the JDK this name is used (typo, but heck, we accept it anyway).
  }

  /**
   * Returns true if the logical font name is equivalent to 'Courier', and false otherwise.
   *
   * @return true or false.
   */
  public boolean isCourier()
  {
    return (StringUtils.startsWithIgnoreCase(fontName, "dialoginput")
        || StringUtils.startsWithIgnoreCase(fontName, "monospaced"));
  }

  /**
   * Returns true if the logical font name is equivalent to 'Serif', and false otherwise.
   *
   * @return true or false.
   */
  public boolean isSerif()
  {
    return (StringUtils.startsWithIgnoreCase(fontName, "serif"));
  }


}
TOP

Related Classes of org.pentaho.reporting.engine.classic.core.style.FontDefinition

TOP
Copyright © 2018 www.massapi.com. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.