1 /*
2 **********************************************************************
3 * Copyright (C) 1998-2014, International Business Machines
4 * Corporation and others. All Rights Reserved.
5 **********************************************************************
6 */
7
8 #ifndef __LEGLYPHSTORAGE_H
9 #define __LEGLYPHSTORAGE_H
10
11 #include "LETypes.h"
12 #include "LEInsertionList.h"
13
14 /**
15 * \file
16 * \brief C++ API: This class encapsulates the per-glyph storage used by the ICU LayoutEngine.
17 */
18
19 U_NAMESPACE_BEGIN
20
21 /**
22 * This class encapsulates the per-glyph storage used by the ICU LayoutEngine.
23 * For each glyph it holds the glyph ID, the index of the backing store character
24 * which produced the glyph, the X and Y position of the glyph and an auxillary data
25 * pointer.
26 *
27 * The storage is growable using the <code>LEInsertionList</code> class.
28 *
29 *
30 * @see LEInsertionList.h
31 *
32 * @deprecated ICU 54. See {@link icu::LayoutEngine}
33 */
34 class U_LAYOUT_API LEGlyphStorage : public UObject, protected LEInsertionCallback
35 {
36 private:
37 /**
38 * The number of entries in the per-glyph arrays.
39 *
40 * @internal
41 */
42 le_int32 fGlyphCount;
43
44 /**
45 * The glyph ID array.
46 *
47 * @internal
48 */
49 LEGlyphID *fGlyphs;
50
51 /**
52 * The char indices array.
53 *
54 * @internal
55 */
56 le_int32 *fCharIndices;
57
58 /**
59 * The glyph positions array.
60 *
61 * @internal
62 */
63 float *fPositions;
64
65 /**
66 * The auxillary data array.
67 *
68 * @internal
69 */
70 le_uint32 *fAuxData;
71
72
73 /**
74 * The insertion list, used to grow the above arrays.
75 *
76 * @internal
77 */
78 LEInsertionList *fInsertionList;
79
80 /**
81 * The source index while growing the data arrays.
82 *
83 * @internal
84 */
85 le_int32 fSrcIndex;
86
87 /**
88 * The destination index used while growing the data arrays.
89 *
90 * @internal
91 */
92 le_int32 fDestIndex;
93
94 protected:
95 /**
96 * This implements <code>LEInsertionCallback</code>. The <code>LEInsertionList</code>
97 * will call this method once for each insertion.
98 *
99 * @param atPosition the position of the insertion
100 * @param count the number of glyphs being inserted
101 * @param newGlyphs the address of the new glyph IDs
102 *
103 * @return <code>true</code> if <code>LEInsertionList</code> should stop
104 * processing the insertion list after this insertion.
105 *
106 * @see LEInsertionList.h
107 *
108 * @deprecated ICU 54. See {@link icu::LayoutEngine}
109 */
110 virtual le_bool applyInsertion(le_int32 atPosition, le_int32 count, LEGlyphID newGlyphs[]);
111
112 public:
113
114 /**
115 * Allocates an empty <code>LEGlyphStorage</code> object. You must call
116 * <code>allocateGlyphArray, allocatePositions and allocateAuxData</code>
117 * to allocate the data.
118 *
119 * @deprecated ICU 54. See {@link icu::LayoutEngine}
120 */
121 LEGlyphStorage();
122
123 /**
124 * The destructor. This will deallocate all of the arrays.
125 *
126 * @deprecated ICU 54. See {@link icu::LayoutEngine}
127 */
128 ~LEGlyphStorage();
129
130 /**
131 * This method returns the number of glyphs in the glyph array.
132 *
133 * @return the number of glyphs in the glyph array
134 *
135 * @deprecated ICU 54. See {@link icu::LayoutEngine}
136 */
137 inline le_int32 getGlyphCount() const;
138
139 /**
140 * This method copies the glyph array into a caller supplied array.
141 * The caller must ensure that the array is large enough to hold all
142 * the glyphs.
143 *
144 * @param glyphs - the destiniation glyph array
145 * @param success - set to an error code if the operation fails
146 *
147 * @deprecated ICU 54. See {@link icu::LayoutEngine}
148 */
149 void getGlyphs(LEGlyphID glyphs[], LEErrorCode &success) const;
150
151 /**
152 * This method copies the glyph array into a caller supplied array,
153 * ORing in extra bits. (This functionality is needed by the JDK,
154 * which uses 32 bits pre glyph idex, with the high 16 bits encoding
155 * the composite font slot number)
156 *
157 * @param glyphs - the destination (32 bit) glyph array
158 * @param extraBits - this value will be ORed with each glyph index
159 * @param success - set to an error code if the operation fails
160 *
161 * @deprecated ICU 54. See {@link icu::LayoutEngine}
162 */
163 void getGlyphs(le_uint32 glyphs[], le_uint32 extraBits, LEErrorCode &success) const;
164
165 /**
166 * This method copies the character index array into a caller supplied array.
167 * The caller must ensure that the array is large enough to hold a
168 * character index for each glyph.
169 *
170 * @param charIndices - the destiniation character index array
171 * @param success - set to an error code if the operation fails
172 *
173 * @deprecated ICU 54. See {@link icu::LayoutEngine}
174 */
175 void getCharIndices(le_int32 charIndices[], LEErrorCode &success) const;
176
177 /**
178 * This method copies the character index array into a caller supplied array.
179 * The caller must ensure that the array is large enough to hold a
180 * character index for each glyph.
181 *
182 * @param charIndices - the destiniation character index array
183 * @param indexBase - an offset which will be added to each index
184 * @param success - set to an error code if the operation fails
185 *
186 * @deprecated ICU 54. See {@link icu::LayoutEngine}
187 */
188 void getCharIndices(le_int32 charIndices[], le_int32 indexBase, LEErrorCode &success) const;
189
190 /**
191 * This method copies the position array into a caller supplied array.
192 * The caller must ensure that the array is large enough to hold an
193 * X and Y position for each glyph, plus an extra X and Y for the
194 * advance of the last glyph.
195 *
196 * @param positions - the destiniation position array
197 * @param success - set to an error code if the operation fails
198 *
199 * @deprecated ICU 54. See {@link icu::LayoutEngine}
200 */
201 void getGlyphPositions(float positions[], LEErrorCode &success) const;
202
203 /**
204 * This method returns the X and Y position of the glyph at
205 * the given index.
206 *
207 * Input parameters:
208 * @param glyphIndex - the index of the glyph
209 *
210 * Output parameters:
211 * @param x - the glyph's X position
212 * @param y - the glyph's Y position
213 * @param success - set to an error code if the operation fails
214 *
215 * @deprecated ICU 54. See {@link icu::LayoutEngine}
216 */
217 void getGlyphPosition(le_int32 glyphIndex, float &x, float &y, LEErrorCode &success) const;
218
219 /**
220 * This method allocates the glyph array, the char indices array and the insertion list. You
221 * must call this method before using the object. This method also initializes the char indices
222 * array.
223 *
224 * @param initialGlyphCount the initial size of the glyph and char indices arrays.
225 * @param rightToLeft <code>true</code> if the original input text is right to left.
226 * @param success set to an error code if the storage cannot be allocated of if the initial
227 * glyph count is not positive.
228 *
229 * @deprecated ICU 54. See {@link icu::LayoutEngine}
230 */
231 void allocateGlyphArray(le_int32 initialGlyphCount, le_bool rightToLeft, LEErrorCode &success);
232
233 /**
234 * This method allocates the storage for the glyph positions. It allocates one extra X, Y
235 * position pair for the position just after the last glyph.
236 *
237 * @param success set to an error code if the positions array cannot be allocated.
238 *
239 * @return the number of X, Y position pairs allocated.
240 *
241 * @deprecated ICU 54. See {@link icu::LayoutEngine}
242 */
243 le_int32 allocatePositions(LEErrorCode &success);
244
245 /**
246 * This method allocates the storage for the auxillary glyph data.
247 *
248 * @param success set to an error code if the aulillary data array cannot be allocated.
249 *
250 * @return the size of the auxillary data array.
251 *
252 * @deprecated ICU 54. See {@link icu::LayoutEngine}
253 */
254 le_int32 allocateAuxData(LEErrorCode &success);
255
256 /**
257 * Copy the entire auxillary data array.
258 *
259 * @param auxData the auxillary data array will be copied to this address
260 * @param success set to an error code if the data cannot be copied
261 *
262 * @deprecated ICU 54. See {@link icu::LayoutEngine}
263 */
264 void getAuxData(le_uint32 auxData[], LEErrorCode &success) const;
265
266 /**
267 * Get the glyph ID for a particular glyph.
268 *
269 * @param glyphIndex the index into the glyph array
270 * @param success set to an error code if the glyph ID cannot be retrieved.
271 *
272 * @return the glyph ID
273 *
274 * @deprecated ICU 54. See {@link icu::LayoutEngine}
275 */
276 LEGlyphID getGlyphID(le_int32 glyphIndex, LEErrorCode &success) const;
277
278 /**
279 * Get the char index for a particular glyph.
280 *
281 * @param glyphIndex the index into the glyph array
282 * @param success set to an error code if the char index cannot be retrieved.
283 *
284 * @return the character index
285 *
286 * @deprecated ICU 54. See {@link icu::LayoutEngine}
287 */
288 le_int32 getCharIndex(le_int32 glyphIndex, LEErrorCode &success) const;
289
290
291 /**
292 * Get the auxillary data for a particular glyph.
293 *
294 * @param glyphIndex the index into the glyph array
295 * @param success set to an error code if the auxillary data cannot be retrieved.
296 *
297 * @return the auxillary data
298 *
299 * @deprecated ICU 54. See {@link icu::LayoutEngine}
300 */
301 le_uint32 getAuxData(le_int32 glyphIndex, LEErrorCode &success) const;
302
303 /**
304 * This operator allows direct access to the glyph array
305 * using the index operator.
306 *
307 * @param glyphIndex the index into the glyph array
308 *
309 * @return a reference to the given location in the glyph array
310 *
311 * @deprecated ICU 54. See {@link icu::LayoutEngine}
312 */
313 inline LEGlyphID &operator[](le_int32 glyphIndex) const;
314
315 /**
316 * Call this method to replace a single glyph in the glyph array
317 * with multiple glyphs. This method uses the <code>LEInsertionList</code>
318 * to do the insertion. It returns the address of storage where the new
319 * glyph IDs can be stored. They will not actually be inserted into the
320 * glyph array until <code>applyInsertions</code> is called.
321 *
322 * @param atIndex the index of the glyph to be replaced
323 * @param insertCount the number of glyphs to replace it with
324 * @param success set to an error code if the auxillary data cannot be retrieved.
325 *
326 * @return the address at which to store the replacement glyphs.
327 *
328 * @see LEInsertionList.h
329 *
330 * @deprecated ICU 54. See {@link icu::LayoutEngine}
331 */
332 LEGlyphID *insertGlyphs(le_int32 atIndex, le_int32 insertCount, LEErrorCode& success);
333
334 /**
335 * Call this method to replace a single glyph in the glyph array
336 * with multiple glyphs. This method uses the <code>LEInsertionList</code>
337 * to do the insertion. It returns the address of storage where the new
338 * glyph IDs can be stored. They will not actually be inserted into the
339 * glyph array until <code>applyInsertions</code> is called.
340 *
341 * Note: Don't use this version, use the other version of this function which has an error code.
342 *
343 * @param atIndex the index of the glyph to be replaced
344 * @param insertCount the number of glyphs to replace it with
345 *
346 * @return the address at which to store the replacement glyphs.
347 *
348 * @see LEInsertionList.h
349 *
350 * @deprecated ICU 54. See {@link icu::LayoutEngine}
351 */
352 LEGlyphID *insertGlyphs(le_int32 atIndex, le_int32 insertCount);
353
354 /**
355 * This method is used to reposition glyphs during Indic v2 processing. It moves
356 * all of the relevant glyph information ( glyph, indices, positions, and auxData ),
357 * from the source position to the target position, and also allows for a marker bit
358 * to be set in the target glyph's auxData so that it won't be reprocessed later in the
359 * cycle.
360 *
361 * @param fromPosition - position of the glyph to be moved
362 * @param toPosition - target position of the glyph
363 * @param marker marker bit
364 *
365 * @deprecated ICU 54. See {@link icu::LayoutEngine}
366 */
367 void moveGlyph(le_int32 fromPosition, le_int32 toPosition, le_uint32 marker);
368
369 /**
370 * This method causes all of the glyph insertions recorded by
371 * <code>insertGlyphs</code> to be applied to the glyph array. The
372 * new slots in the char indices and the auxillary data arrays
373 * will be filled in with the values for the glyph being replaced.
374 *
375 * @return the new size of the glyph array
376 *
377 * @see LEInsertionList.h
378 *
379 * @deprecated ICU 54. See {@link icu::LayoutEngine}
380 */
381 le_int32 applyInsertions();
382
383 /**
384 * Set the glyph ID for a particular glyph.
385 *
386 * @param glyphIndex the index of the glyph
387 * @param glyphID the new glyph ID
388 * @param success will be set to an error code if the glyph ID cannot be set.
389 *
390 * @deprecated ICU 54. See {@link icu::LayoutEngine}
391 */
392 void setGlyphID(le_int32 glyphIndex, LEGlyphID glyphID, LEErrorCode &success);
393
394 /**
395 * Set the char index for a particular glyph.
396 *
397 * @param glyphIndex the index of the glyph
398 * @param charIndex the new char index
399 * @param success will be set to an error code if the char index cannot be set.
400 *
401 * @deprecated ICU 54. See {@link icu::LayoutEngine}
402 */
403 void setCharIndex(le_int32 glyphIndex, le_int32 charIndex, LEErrorCode &success);
404
405 /**
406 * Set the X, Y position for a particular glyph.
407 *
408 * @param glyphIndex the index of the glyph
409 * @param x the new X position
410 * @param y the new Y position
411 * @param success will be set to an error code if the position cannot be set.
412 *
413 * @deprecated ICU 54. See {@link icu::LayoutEngine}
414 */
415 void setPosition(le_int32 glyphIndex, float x, float y, LEErrorCode &success);
416
417 /**
418 * Adjust the X, Y position for a particular glyph.
419 *
420 * @param glyphIndex the index of the glyph
421 * @param xAdjust the adjustment to the glyph's X position
422 * @param yAdjust the adjustment to the glyph's Y position
423 * @param success will be set to an error code if the glyph's position cannot be adjusted.
424 *
425 * @deprecated ICU 54. See {@link icu::LayoutEngine}
426 */
427 void adjustPosition(le_int32 glyphIndex, float xAdjust, float yAdjust, LEErrorCode &success);
428
429 /**
430 * Set the auxillary data for a particular glyph.
431 *
432 * @param glyphIndex the index of the glyph
433 * @param auxData the new auxillary data
434 * @param success will be set to an error code if the auxillary data cannot be set.
435 *
436 * @deprecated ICU 54. See {@link icu::LayoutEngine}
437 */
438 void setAuxData(le_int32 glyphIndex, le_uint32 auxData, LEErrorCode &success);
439
440 /**
441 * Delete the glyph array and replace it with the one
442 * in <code>from</code>. Set the glyph array pointer
443 * in <code>from</code> to <code>NULL</code>.
444 *
445 * @param from the <code>LEGlyphStorage</code> object from which
446 * to get the new glyph array.
447 *
448 * @deprecated ICU 54. See {@link icu::LayoutEngine}
449 */
450 void adoptGlyphArray(LEGlyphStorage &from);
451
452 /**
453 * Delete the char indices array and replace it with the one
454 * in <code>from</code>. Set the char indices array pointer
455 * in <code>from</code> to <code>NULL</code>.
456 *
457 * @param from the <code>LEGlyphStorage</code> object from which
458 * to get the new char indices array.
459 *
460 * @deprecated ICU 54. See {@link icu::LayoutEngine}
461 */
462 void adoptCharIndicesArray(LEGlyphStorage &from);
463
464 /**
465 * Delete the position array and replace it with the one
466 * in <code>from</code>. Set the position array pointer
467 * in <code>from</code> to <code>NULL</code>.
468 *
469 * @param from the <code>LEGlyphStorage</code> object from which
470 * to get the new position array.
471 *
472 * @deprecated ICU 54. See {@link icu::LayoutEngine}
473 */
474 void adoptPositionArray(LEGlyphStorage &from);
475
476 /**
477 * Delete the auxillary data array and replace it with the one
478 * in <code>from</code>. Set the auxillary data array pointer
479 * in <code>from</code> to <code>NULL</code>.
480 *
481 * @param from the <code>LEGlyphStorage</code> object from which
482 * to get the new auxillary data array.
483 *
484 * @deprecated ICU 54. See {@link icu::LayoutEngine}
485 */
486 void adoptAuxDataArray(LEGlyphStorage &from);
487
488 /**
489 * Change the glyph count of this object to be the same
490 * as the one in <code>from</code>.
491 *
492 * @param from the <code>LEGlyphStorage</code> object from which
493 * to get the new glyph count.
494 *
495 * @deprecated ICU 54. See {@link icu::LayoutEngine}
496 */
497 void adoptGlyphCount(LEGlyphStorage &from);
498
499 /**
500 * Change the glyph count of this object to the given value.
501 *
502 * @param newGlyphCount the new glyph count.
503 *
504 * @deprecated ICU 54. See {@link icu::LayoutEngine}
505 */
506 void adoptGlyphCount(le_int32 newGlyphCount);
507
508 /**
509 * This method frees the glyph, character index, position and
510 * auxillary data arrays so that the LayoutEngine can be reused
511 * to layout a different characer array. (This method is also called
512 * by the destructor)
513 *
514 * @deprecated ICU 54. See {@link icu::LayoutEngine}
515 */
516 void reset();
517
518 /**
519 * ICU "poor man's RTTI", returns a UClassID for the actual class.
520 *
521 * @deprecated ICU 54. See {@link icu::LayoutEngine}
522 */
523 virtual UClassID getDynamicClassID() const;
524
525 /**
526 * ICU "poor man's RTTI", returns a UClassID for this class.
527 *
528 * @deprecated ICU 54. See {@link icu::LayoutEngine}
529 */
530 static UClassID getStaticClassID();
531 };
532
getGlyphCount()533 inline le_int32 LEGlyphStorage::getGlyphCount() const
534 {
535 return fGlyphCount;
536 }
537
538 inline LEGlyphID &LEGlyphStorage::operator[](le_int32 glyphIndex) const
539 {
540 return fGlyphs[glyphIndex];
541 }
542
543
544 U_NAMESPACE_END
545 #endif
546
547