/usr/include/x86_64-linux-gnu/layout/loengine.h is in libicu-dev 55.1-7.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
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 224 225 | /*
*
* (C) Copyright IBM Corp. 1998-2011 - All Rights Reserved
*
*/
#ifndef __LOENGINE_H
#define __LOENGINE_H
#include "LETypes.h"
#ifndef U_HIDE_INTERNAL_API
/**
* \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 /* U_HIDE_INTERNAL_API */
#endif
|