| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (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.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| /** |
| * @author Ilya S. Okomin |
| * @version $Revision$ |
| */ |
| package org.apache.harmony.awt.gl.font; |
| |
| import java.awt.font.LineMetrics; |
| |
| import org.apache.harmony.awt.internal.nls.Messages; |
| |
| /** |
| * |
| * LineMetrics implementation class. |
| */ |
| |
| public class LineMetricsImpl extends LineMetrics implements Cloneable{ |
| |
| // array of baseline offsets |
| float[] baselineOffsets; |
| |
| // the number of characters to measure |
| int numChars; |
| |
| // baseline index of the font corresponding to this line metrics |
| int baseLineIndex; |
| |
| // underline thickness |
| float underlineThickness; |
| |
| // underline offset |
| float underlineOffset; |
| |
| // strikethrough thickness |
| float strikethroughThickness; |
| |
| // strikethrough offset |
| float strikethroughOffset; |
| |
| // External leading |
| float leading; |
| |
| // Height of the font ( == (ascent+descent+leading)) |
| float height; |
| |
| // Ascent of the font |
| float ascent; |
| |
| // Descent of the font |
| float descent; |
| |
| // Width of the widest char in the font |
| float maxCharWidth; |
| |
| // underline thickness (in pixels) |
| int lUnderlineThickness; |
| |
| // underline offset (in pixels) |
| int lUnderlineOffset; |
| |
| // strikethrough thickness (in pixels) |
| int lStrikethroughThickness; |
| |
| // strikethrough offset (in pixels) |
| int lStrikethroughOffset; |
| |
| // External leading (in pixels) |
| int lLeading; |
| |
| // Height of the font ( == (ascent+descent+leading)) (in pixels) |
| int lHeight; |
| |
| // Ascent of the font (in pixels) |
| int lAscent; |
| |
| // Descent of the font (in pixels) |
| int lDescent; |
| |
| // Width of the widest char in the font (in pixels) |
| int lMaxCharWidth; |
| |
| // units per EM square in font value |
| int units_per_EM = 0; |
| |
| /** |
| * Creates LineMetricsImpl object from specified parameters. If baseline data parameter |
| * is null than {0, (-ascent+descent)/2, -ascent} values are used for baseline offsets. |
| * |
| * @param len a number of characters |
| * @param metrics an array of 16 elements with metrics values that can be |
| * initialized in native code.<p> |
| * metrics[0] - ascent<p> |
| * metrics[1] - descent<p> |
| * metrics[2] - external leading<p> |
| * metrics[3] - underline thickness<p> |
| * -metrics[4] - underline offset<p> |
| * metrics[5] - strikethrough thickness<p> |
| * -metrics[6] - strikethrough offset<p> |
| * metrics[7] - maximum char width<p> |
| * metrics[8] - ascent in pixels<p> |
| * metrics[9] - descent in pixles<p> |
| * metrics[10] - external leading in pixels<p> |
| * metrics[11] - underline thickness in pixels<p> |
| * -metrics[12] - underline offset in pixels<p> |
| * metrics[13] - strikethrough thickness in pixels<p> |
| * -metrics[14] - strikethrough offset in pixels<p> |
| * metrics[15] - maximum char width in pixels<p> |
| |
| * @param _baselineData an array of 3 elements with baseline offsets metrics<p> |
| * _baselineData[0] - roman baseline offset<p> |
| * _baselineData[1] - center baseline offset<p> |
| * _baselineData[2] - hanging baseline offset<p> |
| */ |
| public LineMetricsImpl(int len, float[] metrics, float[] _baselineData){ |
| numChars = len; |
| |
| ascent = metrics[0]; // Ascent of the font |
| descent = metrics[1]; // Descent of the font |
| leading = metrics[2]; // External leading |
| height = metrics[0] + metrics[1] + metrics[2]; // Height of the font ( == (ascent + descent + leading)) |
| } |
| |
| /** |
| * Creates LineMetricsImpl object from specified parameters. If baseline data parameter |
| * is null than {0, (-ascent+descent)/2, -ascent} values are used for baseline offsets. |
| * |
| * @param _numChars number of chars |
| * @param _baseLineIndex index of the baseline offset |
| * @param _baselineOffsets an array of baseline offsets |
| * @param _underlineThickness underline thickness |
| * @param _underlineOffset underline offset |
| * @param _strikethroughThickness strikethrough thickness |
| * @param _strikethroughOffset strinkethrough offset |
| * @param _leading leading of the font |
| * @param _height font height |
| * @param _ascent ascent of the font |
| * @param _descent descent of the font |
| * @param _maxCharWidth max char width |
| */ |
| public LineMetricsImpl(int _numChars, int _baseLineIndex, |
| float[] _baselineOffsets, float _underlineThickness, |
| float _underlineOffset, float _strikethroughThickness, |
| float _strikethroughOffset, float _leading, float _height, |
| float _ascent, float _descent, float _maxCharWidth) { |
| |
| numChars = _numChars; |
| baseLineIndex = _baseLineIndex; |
| underlineThickness = _underlineThickness; |
| underlineOffset = _underlineOffset; |
| strikethroughThickness = _strikethroughThickness; |
| strikethroughOffset = _strikethroughOffset; |
| leading = _leading; |
| height = _height; |
| ascent = _ascent; |
| descent = _descent; |
| baselineOffsets = _baselineOffsets; |
| lUnderlineThickness = (int) underlineThickness; |
| lUnderlineOffset = (int) underlineOffset; |
| lStrikethroughThickness = (int) strikethroughThickness; |
| lStrikethroughOffset = (int) strikethroughOffset; |
| lLeading = (int) leading; |
| lHeight = (int) height; |
| lAscent = (int) ascent; |
| lDescent = (int) descent; |
| maxCharWidth = _maxCharWidth; |
| } |
| |
| public LineMetricsImpl(){ |
| |
| } |
| |
| /** |
| * All metrics are scaled according to scaleX and scaleY values. |
| * This function helps to recompute metrics according to the scale factors |
| * of desired AffineTransform. |
| * |
| * @param scaleX scale X factor |
| * @param scaleY scale Y factor |
| */ |
| public void scale(float scaleX, float scaleY){ |
| float absScaleX = Math.abs(scaleX); |
| float absScaleY = Math.abs(scaleY); |
| |
| underlineThickness *= absScaleY; |
| underlineOffset *= scaleY; |
| strikethroughThickness *= absScaleY; |
| strikethroughOffset *= scaleY; |
| leading *= absScaleY; |
| height *= absScaleY; |
| ascent *= absScaleY; |
| descent *= absScaleY; |
| |
| if(baselineOffsets == null) { |
| getBaselineOffsets(); |
| } |
| |
| for (int i=0; i< baselineOffsets.length; i++){ |
| baselineOffsets[i] *= scaleY; |
| } |
| |
| lUnderlineThickness *= absScaleY; |
| lUnderlineOffset *= scaleY; |
| lStrikethroughThickness *= absScaleY; |
| lStrikethroughOffset *= scaleY; |
| lLeading *= absScaleY; |
| lHeight *= absScaleY; |
| lAscent *= absScaleY; |
| lDescent *= absScaleY; |
| maxCharWidth *= absScaleX; |
| |
| } |
| |
| |
| /** |
| * Returns offset of the baseline. |
| */ |
| @Override |
| public float[] getBaselineOffsets() { |
| // XXX: at the moment there only horizontal metrics are taken into |
| // account. If there is no baseline information in TrueType font |
| // file default values used: {0, -ascent, (-ascent+descent)/2} |
| |
| return baselineOffsets; |
| } |
| |
| /** |
| * Returns a number of chars in specified text |
| */ |
| @Override |
| public int getNumChars() { |
| return numChars; |
| } |
| |
| /** |
| * Returns index of the baseline, one of predefined constants. |
| */ |
| @Override |
| public int getBaselineIndex() { |
| // Baseline index is the deafult baseline index value |
| // taken from the TrueType table "BASE". |
| return baseLineIndex; |
| } |
| |
| /** |
| * Returns thickness of the Underline. |
| */ |
| @Override |
| public float getUnderlineThickness() { |
| return underlineThickness; |
| } |
| |
| /** |
| * Returns offset of the Underline. |
| */ |
| @Override |
| public float getUnderlineOffset() { |
| return underlineOffset; |
| } |
| |
| /** |
| * Returns thickness of the Strikethrough line. |
| */ |
| @Override |
| public float getStrikethroughThickness() { |
| return strikethroughThickness; |
| } |
| |
| /** |
| * Returns offset of the Strikethrough line. |
| */ |
| @Override |
| public float getStrikethroughOffset() { |
| return strikethroughOffset; |
| } |
| |
| /** |
| * Returns the leading. |
| */ |
| @Override |
| public float getLeading() { |
| return leading; |
| } |
| |
| /** |
| * Returns the height of the font. |
| */ |
| @Override |
| public float getHeight() { |
| //return height; // equals to (ascent + descent + leading); |
| return ascent + descent + leading; |
| } |
| |
| /** |
| * Returns the descent. |
| */ |
| @Override |
| public float getDescent() { |
| return descent; |
| } |
| |
| /** |
| * Returns the ascent. |
| */ |
| @Override |
| public float getAscent() { |
| return ascent; |
| } |
| |
| /** |
| * Returns logical thickness of the Underline. |
| */ |
| public int getLogicalUnderlineThickness() { |
| return lUnderlineThickness; |
| } |
| |
| /** |
| * Returns logical offset of the Underline. |
| */ |
| public int getLogicalUnderlineOffset() { |
| return lUnderlineOffset; |
| } |
| |
| /** |
| * Returns logical thickness of the Strikethrough line. |
| */ |
| public int getLogicalStrikethroughThickness() { |
| return lStrikethroughThickness; |
| } |
| |
| /** |
| * Returns logical offset of the Strikethrough line. |
| */ |
| public int getLogicalStrikethroughOffset() { |
| return lStrikethroughOffset; |
| } |
| |
| /** |
| * Returns the logical leading. |
| */ |
| public int getLogicalLeading() { |
| return lLeading; |
| } |
| |
| /** |
| * Returns the logical height of the font. |
| */ |
| public int getLogicalHeight() { |
| return lHeight; // equals to (ascent + descent + leading); |
| } |
| |
| /** |
| * Returns the logical descent. |
| */ |
| public int getLogicalDescent() { |
| return lDescent; |
| } |
| |
| /** |
| * Returns the logical ascent. |
| */ |
| public int getLogicalAscent() { |
| return lAscent; |
| } |
| |
| /** |
| * Returns the logical size of the widest char. |
| */ |
| public int getLogicalMaxCharWidth() { |
| return lMaxCharWidth; |
| } |
| |
| /** |
| * Returns the size of the widest char. |
| */ |
| public float getMaxCharWidth() { |
| return maxCharWidth; |
| } |
| |
| /** |
| * Set num chars to the desired value. |
| * |
| * @param num specified number of chars |
| */ |
| public void setNumChars(int num){ |
| numChars = num; |
| } |
| |
| @Override |
| public Object clone(){ |
| try{ |
| return super.clone(); |
| }catch (CloneNotSupportedException e){ |
| return null; |
| } |
| } |
| |
| } |