protected FontRenderContext() 
{
        aaHintValue = VALUE_TEXT_ANTIALIAS_DEFAULT;
        fmHintValue = VALUE_FRACTIONALMETRICS_DEFAULT;
        defaulting = true;
}

Constructs a new FontRenderContext object.

 public FontRenderContext(AffineTransform tx,
    boolean isAntiAliased,
    boolean usesFractionalMetrics) 
{
        if (tx != null && !tx.isIdentity()) {
            this.tx = new AffineTransform(tx);
        }
        if (isAntiAliased) {
            aaHintValue = VALUE_TEXT_ANTIALIAS_ON;
        } else {
            aaHintValue = VALUE_TEXT_ANTIALIAS_OFF;
        }
        if (usesFractionalMetrics) {
            fmHintValue = VALUE_FRACTIONALMETRICS_ON;
        } else {
            fmHintValue = VALUE_FRACTIONALMETRICS_OFF;
        }
}

Constructs a FontRenderContext object from an optional AffineTransform and two boolean values that determine if the newly constructed object has anti-aliasing or fractional metrics. In each case the boolean values true and false correspond to the rendering hint values ON and OFF respectively.

To specify other hint values, use the constructor which specifies the rendering hint values as parameters : #FontRenderContext(AffineTransform, Object, Object) .

Parameters:

tx - the transform which is used to scale typographical points to pixels in this FontRenderContext. If null, an identity transform is used.

isAntiAliased - determines if the newly constructed object has anti-aliasing.

usesFractionalMetrics - determines if the newly constructed object has fractional metrics.

 public FontRenderContext(AffineTransform tx,
    Object aaHint,
    Object fmHint) 
{
        if (tx != null && !tx.isIdentity()) {
            this.tx = new AffineTransform(tx);
        }
        try {
            if (KEY_TEXT_ANTIALIASING.isCompatibleValue(aaHint)) {
                aaHintValue = aaHint;
            } else {
                throw new IllegalArgumentException("AA hint:" + aaHint);
            }
        } catch (Exception e) {
            throw new IllegalArgumentException("AA hint:" +aaHint);
        }
        try {
            if (KEY_FRACTIONALMETRICS.isCompatibleValue(fmHint)) {
                fmHintValue = fmHint;
            } else {
                throw new IllegalArgumentException("FM hint:" + fmHint);
            }
        } catch (Exception e) {
            throw new IllegalArgumentException("FM hint:" +fmHint);
        }
}

Constructs a FontRenderContext object from an optional AffineTransform and two Object values that determine if the newly constructed object has anti-aliasing or fractional metrics.

Parameters:

tx - the transform which is used to scale typographical points to pixels in this FontRenderContext. If null, an identity tranform is used.

aaHint - - one of the text antialiasing rendering hint values defined in java.awt.RenderingHints . Any other value will throw IllegalArgumentException. VALUE_TEXT_ANTIALIAS_DEFAULT may be specified, in which case the mode used is implementation dependent.

fmHint - - one of the text fractional rendering hint values defined in java.awt.RenderingHints . VALUE_FRACTIONALMETRICS_DEFAULT may be specified, in which case the mode used is implementation dependent. Any other value will throw IllegalArgumentException

Throws:

IllegalArgumentException - if the hints are not one of the legal values.

since: 1.6 -

 public boolean equals(Object obj) 
{
        try {
            return equals((FontRenderContext)obj);
        }
        catch (ClassCastException e) {
            return false;
        }
}

Return true if obj is an instance of FontRenderContext and has the same transform, antialiasing, and fractional metrics values as this.

 public boolean equals(FontRenderContext rhs) 
{
        if (this == rhs) {
            return true;
        }
        if (rhs == null) {
            return false;
        }
        /* if neither instance is a subclass, reference values directly. */
        if (!rhs.defaulting && !defaulting) {
            if (rhs.aaHintValue == aaHintValue &&
                rhs.fmHintValue == fmHintValue) {
                return tx == null ? rhs.tx == null : tx.equals(rhs.tx);
            }
            return false;
        } else {
            return
                rhs.getAntiAliasingHint() == getAntiAliasingHint() &&
                rhs.getFractionalMetricsHint() == getFractionalMetricsHint() &&
                rhs.getTransform().equals(getTransform());
        }
}

Return true if rhs has the same transform, antialiasing, and fractional metrics values as this.

 public Object getAntiAliasingHint() 
{
        if (defaulting) {
            if (isAntiAliased()) {
                 return VALUE_TEXT_ANTIALIAS_ON;
            } else {
                return VALUE_TEXT_ANTIALIAS_OFF;
            }
        }
        return aaHintValue;
}

Return the text anti-aliasing rendering mode hint used in this FontRenderContext. This will be one of the text antialiasing rendering hint values defined in java.awt.RenderingHints .

 public Object getFractionalMetricsHint() 
{
        if (defaulting) {
            if (usesFractionalMetrics()) {
                 return VALUE_FRACTIONALMETRICS_ON;
            } else {
                return VALUE_FRACTIONALMETRICS_OFF;
            }
        }
        return fmHintValue;
}

Return the text fractional metrics rendering mode hint used in this FontRenderContext. This will be one of the text fractional metrics rendering hint values defined in java.awt.RenderingHints .

 public AffineTransform getTransform() 
{
        return (tx == null) ? new AffineTransform() : new AffineTransform(tx);
}

Gets the transform that is used to scale typographical points to pixels in this FontRenderContext.

 public int getTransformType() 
{
        if (!defaulting) {
            if (tx == null) {
                return AffineTransform.TYPE_IDENTITY;
            } else {
                return tx.getType();
            }
        } else {
            return getTransform().getType();
        }
}

Returns the integer type of the affine transform for this FontRenderContext as specified by java.awt.geom.AffineTransform#getType()

 public int hashCode() 
{
        int hash = tx == null ? 0 : tx.hashCode();
        /* SunHints value objects have identity hashcode, so we can rely on
         * this to ensure that two equal FRC's have the same hashcode.
         */
        if (defaulting) {
            hash += getAntiAliasingHint().hashCode();
            hash += getFractionalMetricsHint().hashCode();
        } else {
            hash += aaHintValue.hashCode();
            hash += fmHintValue.hashCode();
        }
        return hash;
}

Return a hashcode for this FontRenderContext.

 public boolean isAntiAliased() 
{
        return !(aaHintValue == VALUE_TEXT_ANTIALIAS_OFF ||
                 aaHintValue == VALUE_TEXT_ANTIALIAS_DEFAULT);
}

Returns a boolean which indicates whether or not some form of antialiasing is specified by this FontRenderContext. Call getAntiAliasingHint() for the specific rendering hint value.

 public boolean isTransformed() 
{
        if (!defaulting) {
            return tx != null;
        } else {
            return !getTransform().isIdentity();
        }
}

Indicates whether or not this FontRenderContext object measures text in a transformed render context.

 public boolean usesFractionalMetrics() 
{
        return !(fmHintValue == VALUE_FRACTIONALMETRICS_OFF ||
                 fmHintValue == VALUE_FRACTIONALMETRICS_DEFAULT);
}

Returns a boolean which whether text fractional metrics mode is used in this FontRenderContext. Call getFractionalMetricsHint() to obtain the corresponding rendering hint value.