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
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
|
/*
*
* (C) Copyright IBM Corp. 1998-2007 - All Rights Reserved
*
*/
#ifndef __LOENGINE_H
#define __LOENGINE_H
#include "LETypes.h"
/**
* \file
* \brief C API for complex text layout.
* \internal
*
* This is a technology preview. The API may
* change significantly.
*
*/
/**
* The opaque type for a LayoutEngine.
*
* @internal
*/
typedef void le_engine;
/**
* The opaque type for a font instance.
*
* @internal
*/
typedef void le_font;
/**
* This function returns an le_engine capable of laying out text
* in the given font, script and langauge. Note that the LayoutEngine
* returned may be a subclass of LayoutEngine.
*
* @param font - the font of the text
* @param scriptCode - the script of the text
* @param languageCode - the language of the text
* @param typo_flags - flags that control layout features like kerning and ligatures.
* @param success - output parameter set to an error code if the operation fails
*
* @return an le_engine which can layout text in the given font.
*
* @internal
*/
U_INTERNAL le_engine * U_EXPORT2
le_create(const le_font *font,
le_int32 scriptCode,
le_int32 languageCode,
le_int32 typo_flags,
LEErrorCode *success);
/**
* This function closes the given LayoutEngine. After
* it returns, the le_engine is no longer valid.
*
* @param engine - the LayoutEngine to close.
*
* @internal
*/
U_INTERNAL void U_EXPORT2
le_close(le_engine *engine);
/**
* This routine will compute the glyph, character index and position arrays.
*
* @param engine - the LayoutEngine
* @param chars - the input character context
* @param offset - the offset of the first character to process
* @param count - the number of characters to process
* @param max - the number of characters in the input context
* @param rightToLeft - TRUE if the characers are in a right to left directional run
* @param x - the initial X position
* @param y - the initial Y position
* @param success - output parameter set to an error code if the operation fails
*
* @return the number of glyphs in the glyph array
*
* Note: The glyph, character index and position array can be accessed
* using the getter routines below.
*
* Note: If you call this function more than once, you must call the reset()
* function first to free the glyph, character index and position arrays
* allocated by the previous call.
*
* @internal
*/
U_INTERNAL le_int32 U_EXPORT2
le_layoutChars(le_engine *engine,
const LEUnicode chars[],
le_int32 offset,
le_int32 count,
le_int32 max,
le_bool rightToLeft,
float x,
float y,
LEErrorCode *success);
/**
* This function returns the number of glyphs in the glyph array. Note
* that the number of glyphs will be greater than or equal to the number
* of characters used to create the LayoutEngine.
*
* @param engine - the LayoutEngine
* @param success - output parameter set to an error code if the operation fails.
*
* @return the number of glyphs in the glyph array
*
* @internal
*/
U_INTERNAL le_int32 U_EXPORT2
le_getGlyphCount(le_engine *engine,
LEErrorCode *success);
/**
* This function copies the glyph array into a caller supplied array.
* The caller must ensure that the array is large enough to hold all
* the glyphs.
*
* @param engine - the LayoutEngine
* @param glyphs - the destiniation glyph array
* @param success - set to an error code if the operation fails
*
* @internal
*/
U_INTERNAL void U_EXPORT2
le_getGlyphs(le_engine *engine,
LEGlyphID glyphs[],
LEErrorCode *success);
/**
* This function copies the character index array into a caller supplied array.
* The caller must ensure that the array is large enough to hold a
* character index for each glyph.
*
* @param engine - the LayoutEngine
* @param charIndices - the destiniation character index array
* @param success - set to an error code if the operation fails
*
* @internal
*/
U_INTERNAL void U_EXPORT2
le_getCharIndices(le_engine *engine,
le_int32 charIndices[],
LEErrorCode *success);
/**
* This function copies the character index array into a caller supplied array.
* The caller must ensure that the array is large enough to hold a
* character index for each glyph.
*
* @param engine - the LayoutEngine
* @param charIndices - the destiniation character index array
* @param indexBase - an offset that will be added to each index.
* @param success - set to an error code if the operation fails
*
* @internal
*/
U_INTERNAL void U_EXPORT2
le_getCharIndicesWithBase(le_engine *engine,
le_int32 charIndices[],
le_int32 indexBase,
LEErrorCode *success);
/**
* This function copies the position array into a caller supplied array.
* The caller must ensure that the array is large enough to hold an
* X and Y position for each glyph, plus an extra X and Y for the
* advance of the last glyph.
*
* @param engine - the LayoutEngine
* @param positions - the destiniation position array
* @param success - set to an error code if the operation fails
*
* @internal
*/
U_INTERNAL void U_EXPORT2
le_getGlyphPositions(le_engine *engine,
float positions[],
LEErrorCode *success);
/**
* This function returns the X and Y position of the glyph at
* the given index.
*
* Input parameters:
* @param engine - the LayoutEngine
* @param glyphIndex - the index of the glyph
*
* Output parameters:
* @param x - the glyph's X position
* @param y - the glyph's Y position
* @param success - set to an error code if the operation fails
*
* @internal
*/
U_INTERNAL void U_EXPORT2
le_getGlyphPosition(le_engine *engine,
le_int32 glyphIndex,
float *x,
float *y,
LEErrorCode *success);
/**
* This function frees the glyph, character index and position arrays
* so that the LayoutEngine can be reused to layout a different
* characer array. (This function is also called by le_close)
*
* @param engine - the LayoutEngine
* @param success - set to an error code if the operation fails
*
* @internal
*/
U_INTERNAL void U_EXPORT2
le_reset(le_engine *engine,
LEErrorCode *success);
#endif
|
