1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
|
/*
* %W% %E%
*
* (C) Copyright IBM Corp. 1998-2011 - All Rights Reserved
*
*/
#ifndef __SCRIPTCOMPOSITEFONTINSTANCE_H
#define __SCRIPTCOMPOSITEFONTINSTANCE_H
#include "layout/LETypes.h"
#include "layout/LEFontInstance.h"
#include "FontMap.h"
// U_NAMESPACE_BEGIN
class ScriptCompositeFontInstance : public LEFontInstance
{
public:
ScriptCompositeFontInstance(FontMap *fontMap);
virtual ~ScriptCompositeFontInstance();
/**
* Get a physical font which can render the given text. For composite fonts,
* if there is no single physical font which can render all of the text,
* return a physical font which can render an initial substring of the text,
* and set the <code>offset</code> parameter to the end of that substring.
*
* Internally, the LayoutEngine works with runs of text all in the same
* font and script, so it is best to call this method with text which is
* in a single script, passing the script code in as a hint. If you don't
* know the script of the text, you can use zero, which is the script code
* for characters used in more than one script.
*
* The default implementation of this method is intended for instances of
* <code>LEFontInstance</code> which represent a physical font. It returns
* <code>this</code> and indicates that the entire string can be rendered.
*
* This method will return a valid <code>LEFontInstance</code> unless you
* have passed illegal parameters, or an internal error has been encountered.
* For composite fonts, it may return the warning <code>LE_NO_SUBFONT_WARNING</code>
* to indicate that the returned font may not be able to render all of
* the text. Whenever a valid font is returned, the <code>offset</code> parameter
* will be advanced by at least one.
*
* Subclasses which implement composite fonts must override this method.
* Where it makes sense, they should use the script code as a hint to render
* characters from the COMMON script in the font which is used for the given
* script. For example, if the input text is a series of Arabic words separated
* by spaces, and the script code passed in is <code>arabScriptCode</code> you
* should return the font used for Arabic characters for all of the input text,
* including the spaces. If, on the other hand, the input text contains characters
* which cannot be rendered by the font used for Arabic characters, but which can
* be rendered by another font, you should return that font for those characters.
*
* @param chars - the array of Unicode characters.
* @param offset - a pointer to the starting offset in the text. On exit this
* will be set the the limit offset of the text which can be
* rendered using the returned font.
* @param limit - the limit offset for the input text.
* @param script - the script hint.
* @param success - set to an error code if the arguments are illegal, or no font
* can be returned for some reason. May also be set to
* <code>LE_NO_SUBFONT_WARNING</code> if the subfont which
* was returned cannot render all of the text.
*
* @return an <code>LEFontInstance</code> for the sub font which can render the characters, or
* <code>NULL</code> if there is an error.
*
* @see LEScripts.h
*/
virtual const LEFontInstance *getSubFont(const LEUnicode chars[], le_int32 *offset, le_int32 limit, le_int32 script, LEErrorCode &success) const;
/**
* This method maps a single character to a glyph index, using the
* font's charcter to glyph map.
*
* @param ch - the character
*
* @return the glyph index
*/
virtual LEGlyphID mapCharToGlyph(LEUnicode32 ch) const;
virtual const void *getFontTable(LETag tableTag) const;
virtual le_int32 getUnitsPerEM() const;
virtual le_int32 getAscent() const;
virtual le_int32 getDescent() const;
virtual le_int32 getLeading() const;
virtual void getGlyphAdvance(LEGlyphID glyph, LEPoint &advance) const;
virtual le_bool getGlyphPoint(LEGlyphID glyph, le_int32 pointNumber, LEPoint &point) const;
float getXPixelsPerEm() const;
float getYPixelsPerEm() const;
float getScaleFactorX() const;
float getScaleFactorY() const;
/**
* ICU "poor man's RTTI", returns a UClassID for the actual class.
*/
virtual inline UClassID getDynamicClassID() const { return getStaticClassID(); }
/**
* ICU "poor man's RTTI", returns a UClassID for this class.
*/
static inline UClassID getStaticClassID() { return (UClassID)&fgClassID; }
protected:
FontMap *fFontMap;
private:
/**
* The address of this static class variable serves as this class's ID
* for ICU "poor man's RTTI".
*/
static const char fgClassID;
};
inline const void *ScriptCompositeFontInstance::getFontTable(LETag /*tableTag*/) const
{
return NULL;
}
// Can't get units per EM without knowing which sub-font, so
// return a value that will make units == points
inline le_int32 ScriptCompositeFontInstance::getUnitsPerEM() const
{
return 1;
}
inline le_int32 ScriptCompositeFontInstance::getAscent() const
{
return fFontMap->getAscent();
}
inline le_int32 ScriptCompositeFontInstance::getDescent() const
{
return fFontMap->getDescent();
}
inline le_int32 ScriptCompositeFontInstance::getLeading() const
{
return fFontMap->getLeading();
}
inline float ScriptCompositeFontInstance::getXPixelsPerEm() const
{
return fFontMap->getPointSize();
}
inline float ScriptCompositeFontInstance::getYPixelsPerEm() const
{
return fFontMap->getPointSize();
}
// Can't get a scale factor without knowing the sub-font, so
// return 1.0.
inline float ScriptCompositeFontInstance::getScaleFactorX() const
{
return 1.0;
}
// Can't get a scale factor without knowing the sub-font, so
// return 1.0
inline float ScriptCompositeFontInstance::getScaleFactorY() const
{
return 1.0;
}
// U_NAMESPACE_END
#endif
|
