/* ==================================================================== | |
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. | |
==================================================================== */ | |
package org.apache.poi.hwmf.record; | |
import java.io.IOException; | |
import java.nio.charset.Charset; | |
import org.apache.poi.util.LittleEndianConsts; | |
import org.apache.poi.util.LittleEndianInputStream; | |
/** | |
* The Font object specifies the attributes of a logical font | |
*/ | |
public class HwmfFont { | |
public enum WmfCharset { | |
/** Specifies the English character set. */ | |
ANSI_CHARSET(0x00000000), | |
/** | |
* Specifies a character set based on the current system locale; | |
* for example, when the system locale is United States English, | |
* the default character set is ANSI_CHARSET. | |
*/ | |
DEFAULT_CHARSET(0x00000001), | |
/** Specifies a character set of symbols. */ | |
SYMBOL_CHARSET(0x00000002), | |
/** Specifies the Apple Macintosh character set. */ | |
MAC_CHARSET(0x0000004D), | |
/** Specifies the Japanese character set. */ | |
SHIFTJIS_CHARSET(0x00000080), | |
/** Also spelled "Hangeul". Specifies the Hangul Korean character set. */ | |
HANGUL_CHARSET(0x00000081), | |
/** Also spelled "Johap". Specifies the Johab Korean character set. */ | |
JOHAB_CHARSET(0x00000082), | |
/** Specifies the "simplified" Chinese character set for People's Republic of China. */ | |
GB2312_CHARSET(0x00000086), | |
/** | |
* Specifies the "traditional" Chinese character set, used mostly in | |
* Taiwan and in the Hong Kong and Macao Special Administrative Regions. | |
*/ | |
CHINESEBIG5_CHARSET(0x00000088), | |
/** Specifies the Greek character set. */ | |
GREEK_CHARSET(0x000000A1), | |
/** Specifies the Turkish character set. */ | |
TURKISH_CHARSET(0x000000A2), | |
/** Specifies the Vietnamese character set. */ | |
VIETNAMESE_CHARSET(0x000000A3), | |
/** Specifies the Hebrew character set. */ | |
HEBREW_CHARSET(0x000000B1), | |
/** Specifies the Arabic character set. */ | |
ARABIC_CHARSET(0x000000B2), | |
/** Specifies the Baltic (Northeastern European) character set. */ | |
BALTIC_CHARSET(0x000000BA), | |
/** Specifies the Russian Cyrillic character set. */ | |
RUSSIAN_CHARSET(0x000000CC), | |
/** Specifies the Thai character set. */ | |
THAI_CHARSET(0x000000DE), | |
/** Specifies a Eastern European character set. */ | |
EASTEUROPE_CHARSET(0x000000EE), | |
/** | |
* Specifies a mapping to one of the OEM code pages, | |
* according to the current system locale setting. | |
*/ | |
OEM_CHARSET(0x000000FF); | |
int flag; | |
WmfCharset(int flag) { | |
this.flag = flag; | |
} | |
static WmfCharset valueOf(int flag) { | |
for (WmfCharset cs : values()) { | |
if (cs.flag == flag) return cs; | |
} | |
return null; | |
} | |
} | |
/** | |
* The output precision defines how closely the output must match the requested font's height, | |
* width, character orientation, escapement, pitch, and font type. | |
*/ | |
public enum WmfOutPrecision { | |
/** | |
* A value that specifies default behavior. | |
*/ | |
OUT_DEFAULT_PRECIS(0x00000000), | |
/** | |
* A value that is returned when rasterized fonts are enumerated. | |
*/ | |
OUT_STRING_PRECIS(0x00000001), | |
/** | |
* A value that is returned when TrueType and other outline fonts, and | |
* vector fonts are enumerated. | |
*/ | |
OUT_STROKE_PRECIS(0x00000003), | |
/** | |
* A value that specifies the choice of a TrueType font when the system | |
* contains multiple fonts with the same name. | |
*/ | |
OUT_TT_PRECIS(0x00000004), | |
/** | |
* A value that specifies the choice of a device font when the system | |
* contains multiple fonts with the same name. | |
*/ | |
OUT_DEVICE_PRECIS(0x00000005), | |
/** | |
* A value that specifies the choice of a rasterized font when the system | |
* contains multiple fonts with the same name. | |
*/ | |
OUT_RASTER_PRECIS(0x00000006), | |
/** | |
* A value that specifies the requirement for only TrueType fonts. If | |
* there are no TrueType fonts installed in the system, default behavior is specified. | |
*/ | |
OUT_TT_ONLY_PRECIS(0x00000007), | |
/** | |
* A value that specifies the requirement for TrueType and other outline fonts. | |
*/ | |
OUT_OUTLINE_PRECIS (0x00000008), | |
/** | |
* A value that specifies a preference for TrueType and other outline fonts. | |
*/ | |
OUT_SCREEN_OUTLINE_PRECIS (0x00000009), | |
/** | |
* A value that specifies a requirement for only PostScript fonts. If there | |
* are no PostScript fonts installed in the system, default behavior is specified. | |
*/ | |
OUT_PS_ONLY_PRECIS (0x0000000A); | |
int flag; | |
WmfOutPrecision(int flag) { | |
this.flag = flag; | |
} | |
static WmfOutPrecision valueOf(int flag) { | |
for (WmfOutPrecision op : values()) { | |
if (op.flag == flag) return op; | |
} | |
return null; | |
} | |
} | |
/** | |
* ClipPrecision Flags specify clipping precision, which defines how to clip characters that are | |
* partially outside a clipping region. These flags can be combined to specify multiple options. | |
*/ | |
public enum WmfClipPrecision { | |
/** | |
* Specifies that default clipping MUST be used. | |
*/ | |
CLIP_DEFAULT_PRECIS (0x00000000), | |
/** | |
* This value SHOULD NOT be used. | |
*/ | |
CLIP_CHARACTER_PRECIS (0x00000001), | |
/** | |
* This value MAY be returned when enumerating rasterized, TrueType and vector fonts. | |
*/ | |
CLIP_STROKE_PRECIS (0x00000002), | |
/** | |
* This value is used to control font rotation, as follows: | |
* If set, the rotation for all fonts SHOULD be determined by the orientation of the coordinate system; | |
* that is, whether the orientation is left-handed or right-handed. | |
* | |
* If clear, device fonts SHOULD rotate counterclockwise, but the rotation of other fonts | |
* SHOULD be determined by the orientation of the coordinate system. | |
*/ | |
CLIP_LH_ANGLES (0x00000010), | |
/** | |
* This value SHOULD NOT be used. | |
*/ | |
CLIP_TT_ALWAYS (0x00000020), | |
/** | |
* This value specifies that font association SHOULD< be turned off. | |
*/ | |
CLIP_DFA_DISABLE (0x00000040), | |
/** | |
* This value specifies that font embedding MUST be used to render document content; | |
* embedded fonts are read-only. | |
*/ | |
CLIP_EMBEDDED (0x00000080); | |
int flag; | |
WmfClipPrecision(int flag) { | |
this.flag = flag; | |
} | |
static WmfClipPrecision valueOf(int flag) { | |
for (WmfClipPrecision cp : values()) { | |
if (cp.flag == flag) return cp; | |
} | |
return null; | |
} | |
} | |
/** | |
* The output quality defines how carefully to attempt to match the logical font attributes to those of an actual | |
* physical font. | |
*/ | |
public enum WmfFontQuality { | |
/** | |
* Specifies that the character quality of the font does not matter, so DRAFT_QUALITY can be used. | |
*/ | |
DEFAULT_QUALITY (0x00), | |
/** | |
* Specifies that the character quality of the font is less important than the | |
* matching of logical attribuetes. For rasterized fonts, scaling SHOULD be enabled, which | |
* means that more font sizes are available. | |
*/ | |
DRAFT_QUALITY (0x01), | |
/** | |
* Specifies that the character quality of the font is more important than the | |
* matching of logical attributes. For rasterized fonts, scaling SHOULD be disabled, and the font | |
* closest in size SHOULD be chosen. | |
*/ | |
PROOF_QUALITY (0x02), | |
/** | |
* Specifies that anti-aliasing SHOULD NOT be used when rendering text. | |
*/ | |
NONANTIALIASED_QUALITY (0x03), | |
/** | |
* Specifies that anti-aliasing SHOULD be used when rendering text, if the font supports it. | |
*/ | |
ANTIALIASED_QUALITY (0x04), | |
/** | |
* Specifies that ClearType anti-aliasing SHOULD be used when rendering text, if the font supports it. | |
* | |
* Fonts that do not support ClearType anti-aliasing include type 1 fonts, PostScript fonts, | |
* OpenType fonts without TrueType outlines, rasterized fonts, vector fonts, and device fonts. | |
*/ | |
CLEARTYPE_QUALITY (0x05); | |
int flag; | |
WmfFontQuality(int flag) { | |
this.flag = flag; | |
} | |
static WmfFontQuality valueOf(int flag) { | |
for (WmfFontQuality fq : values()) { | |
if (fq.flag == flag) return fq; | |
} | |
return null; | |
} | |
} | |
/** | |
* A property of a font that describes its general appearance. | |
*/ | |
public enum WmfFontFamilyClass { | |
/** | |
* The default font is specified, which is implementation-dependent. | |
*/ | |
FF_DONTCARE (0x00), | |
/** | |
* Fonts with variable stroke widths, which are proportional to the actual widths of | |
* the glyphs, and which have serifs. "MS Serif" is an example. | |
*/ | |
FF_ROMAN (0x01), | |
/** | |
* Fonts with variable stroke widths, which are proportional to the actual widths of the | |
* glyphs, and which do not have serifs. "MS Sans Serif" is an example. | |
*/ | |
FF_SWISS (0x02), | |
/** | |
* Fonts with constant stroke width, with or without serifs. Fixed-width fonts are | |
* usually modern. "Pica", "Elite", and "Courier New" are examples. | |
*/ | |
FF_MODERN (0x03), | |
/** | |
* Fonts designed to look like handwriting. "Script" and "Cursive" are examples. | |
*/ | |
FF_SCRIPT (0x04), | |
/** | |
* Novelty fonts. "Old English" is an example. | |
*/ | |
FF_DECORATIVE (0x05); | |
int flag; | |
WmfFontFamilyClass(int flag) { | |
this.flag = flag; | |
} | |
static WmfFontFamilyClass valueOf(int flag) { | |
for (WmfFontFamilyClass ff : values()) { | |
if (ff.flag == flag) return ff; | |
} | |
return null; | |
} | |
} | |
/** | |
* A property of a font that describes the pitch, of the characters. | |
*/ | |
public enum WmfFontPitch { | |
/** | |
* The default pitch, which is implementation-dependent. | |
*/ | |
DEFAULT_PITCH (0x00), | |
/** | |
* A fixed pitch, which means that all the characters in the font occupy the same | |
* width when output in a string. | |
*/ | |
FIXED_PITCH (0x01), | |
/** | |
* A variable pitch, which means that the characters in the font occupy widths | |
* that are proportional to the actual widths of the glyphs when output in a string. For example, | |
* the "i" and space characters usually have much smaller widths than a "W" or "O" character. | |
*/ | |
VARIABLE_PITCH (0x02); | |
int flag; | |
WmfFontPitch(int flag) { | |
this.flag = flag; | |
} | |
static WmfFontPitch valueOf(int flag) { | |
for (WmfFontPitch fp : values()) { | |
if (fp.flag == flag) return fp; | |
} | |
return null; | |
} | |
} | |
/** | |
* A 16-bit signed integer that specifies the height, in logical units, of the font's | |
* character cell. The character height is computed as the character cell height minus the | |
* internal leading. The font mapper SHOULD interpret the height as follows. | |
* | |
* negative value: | |
* The font mapper SHOULD transform this value into device units and match its | |
* absolute value against the character height of available fonts. | |
* | |
* zero value: | |
* A default height value MUST be used when creating a physical font. | |
* | |
* positive value: | |
* The font mapper SHOULD transform this value into device units and match it | |
* against the cell height of available fonts. | |
* | |
* For all height comparisons, the font mapper SHOULD find the largest physical | |
* font that does not exceed the requested size. | |
*/ | |
int height; | |
/** | |
* A 16-bit signed integer that defines the average width, in logical units, of | |
* characters in the font. If Width is 0x0000, the aspect ratio of the device SHOULD be matched | |
* against the digitization aspect ratio of the available fonts to find the closest match, | |
* determined by the absolute value of the difference. | |
*/ | |
int width; | |
/** | |
* A 16-bit signed integer that defines the angle, in tenths of degrees, between the | |
* escapement vector and the x-axis of the device. The escapement vector is parallel | |
* to the base line of a row of text. | |
*/ | |
int escapement; | |
/** | |
* A 16-bit signed integer that defines the angle, in tenths of degrees, | |
* between each character's base line and the x-axis of the device. | |
*/ | |
int orientation; | |
/** | |
* A 16-bit signed integer that defines the weight of the font in the range 0 | |
* through 1000. For example, 400 is normal and 700 is bold. If this value is 0x0000, | |
* a default weight SHOULD be used. | |
*/ | |
int weight; | |
/** | |
* A 8-bit Boolean value that specifies the italic attribute of the font. | |
* 0 = not italic / 1 = italic. | |
*/ | |
boolean italic; | |
/** | |
* An 8-bit Boolean value that specifies the underline attribute of the font. | |
* 0 = not underlined / 1 = underlined | |
*/ | |
boolean underline; | |
/** | |
* An 8-bit Boolean value that specifies the strike out attribute of the font. | |
* 0 = not striked out / 1 = striked out | |
*/ | |
boolean strikeOut; | |
/** | |
* An 8-bit unsigned integer that defines the character set. | |
* It SHOULD be set to a value in the {@link WmfCharset} Enumeration. | |
* | |
* The DEFAULT_CHARSET value MAY be used to allow the name and size of a font to fully | |
* describe the logical font. If the specified font name does not exist, a font in another character | |
* set MAY be substituted. The DEFAULT_CHARSET value is set to a value based on the current | |
* system locale. For example, when the system locale is United States, it is set to ANSI_CHARSET. | |
* If a typeface name in the FaceName field is specified, the CharSet value MUST match the | |
* character set of that typeface. | |
*/ | |
WmfCharset charSet; | |
/** | |
* An 8-bit unsigned integer that defines the output precision. | |
*/ | |
WmfOutPrecision outPrecision; | |
/** | |
* An 8-bit unsigned integer that defines the clipping precision. | |
* These flags can be combined to specify multiple options. | |
* | |
* @see WmfClipPrecision | |
*/ | |
WmfClipPrecision clipPrecision; | |
/** | |
* An 8-bit unsigned integer that defines the output quality. | |
*/ | |
WmfFontQuality quality; | |
/** | |
* A PitchAndFamily object that defines the pitch and the family of the font. | |
* Font families specify the look of fonts in a general way and are intended for | |
* specifying fonts when the exact typeface wanted is not available. | |
*/ | |
int pitchAndFamily; | |
/** | |
* Font families specify the look of fonts in a general way and are | |
* intended for specifying fonts when the exact typeface wanted is not available. | |
* (LSB 4 bits) | |
*/ | |
WmfFontFamilyClass family; | |
/** | |
* A property of a font that describes the pitch (MSB 2 bits) | |
*/ | |
WmfFontPitch pitch; | |
/** | |
* A null-terminated string of 8-bit Latin-1 [ISO/IEC-8859-1] ANSI | |
* characters that specifies the typeface name of the font. The length of this string MUST NOT | |
* exceed 32 8-bit characters, including the terminating null. | |
*/ | |
String facename; | |
public int init(LittleEndianInputStream leis) throws IOException { | |
height = leis.readShort(); | |
width = leis.readShort(); | |
escapement = leis.readShort(); | |
orientation = leis.readShort(); | |
weight = leis.readShort(); | |
italic = leis.readByte() != 0; | |
underline = leis.readByte() != 0; | |
strikeOut = leis.readByte() != 0; | |
charSet = WmfCharset.valueOf(leis.readUByte()); | |
outPrecision = WmfOutPrecision.valueOf(leis.readUByte()); | |
clipPrecision = WmfClipPrecision.valueOf(leis.readUByte()); | |
quality = WmfFontQuality.valueOf(leis.readUByte()); | |
pitchAndFamily = leis.readUByte(); | |
byte buf[] = new byte[32], b, readBytes = 0; | |
do { | |
if (readBytes == 32) { | |
throw new IOException("Font facename can't be determined."); | |
} | |
buf[readBytes++] = b = leis.readByte(); | |
} while (b != 0 && b != -1 && readBytes <= 32); | |
facename = new String(buf, 0, readBytes-1, Charset.forName("ISO-8859-1")); | |
return 5*LittleEndianConsts.SHORT_SIZE+8*LittleEndianConsts.BYTE_SIZE+readBytes; | |
} | |
public int getHeight() { | |
return height; | |
} | |
public int getWidth() { | |
return width; | |
} | |
public int getEscapement() { | |
return escapement; | |
} | |
public int getOrientation() { | |
return orientation; | |
} | |
public int getWeight() { | |
return weight; | |
} | |
public boolean isItalic() { | |
return italic; | |
} | |
public boolean isUnderline() { | |
return underline; | |
} | |
public boolean isStrikeOut() { | |
return strikeOut; | |
} | |
public WmfCharset getCharSet() { | |
return charSet; | |
} | |
public WmfOutPrecision getOutPrecision() { | |
return outPrecision; | |
} | |
public WmfClipPrecision getClipPrecision() { | |
return clipPrecision; | |
} | |
public WmfFontQuality getQuality() { | |
return quality; | |
} | |
public int getPitchAndFamily() { | |
return pitchAndFamily; | |
} | |
public WmfFontFamilyClass getFamily() { | |
return WmfFontFamilyClass.valueOf(pitchAndFamily & 0xF); | |
} | |
public WmfFontPitch getPitch() { | |
return WmfFontPitch.valueOf((pitchAndFamily >>> 6) & 3); | |
} | |
public String getFacename() { | |
return facename; | |
} | |
} |