/*

******************************************************************************

*

*   Copyright (C) 1999-2005, International Business Machines

*   Corporation and others.  All Rights Reserved.

*

******************************************************************************

*   file name:  ubidi.h

*   encoding:   US-ASCII

*   tab size:   8 (not used)

*   indentation:4

*

*   created on: 1999jul27

*   created by: Markus W. Scherer

*/

#ifndef UBIDI_H

#define UBIDI_H

#include "unicode/utypes.h"

#include "unicode/uchar.h"

/*

 * javadoc-style comments are intended to be transformed into HTML

 * using DOC++ - see

 * http://www.zib.de/Visual/software/doc++/index.html .

 *

 * The HTML documentation is created with

 *  doc++ -H ubidi.h

 *

 * The following #define trick allows us to do it all in one file

 * and still be able to compile it.

 */

/*#define DOCXX_TAG*/

/*#define BIDI_SAMPLE_CODE*/

/**

 *\file

 * \brief C API: BIDI algorithm

 *

 * <h2>BIDI algorithm for ICU</h2>

 *

 * This is an implementation of the Unicode Bidirectional algorithm.

 * The algorithm is defined in the

 * <a href="http://www.unicode.org/unicode/reports/tr9/">Unicode Standard Annex #9</a>,

 * version 13, also described in The Unicode Standard, Version 4.0 .<p>

 *

 * Note: Libraries that perform a bidirectional algorithm and

 * reorder strings accordingly are sometimes called "Storage Layout Engines".

 * ICU's BiDi and shaping (u_shapeArabic()) APIs can be used at the core of such

 * "Storage Layout Engines".

 *

 * <h3>General remarks about the API:</h3>

 *

 * In functions with an error code parameter,

 * the <code>pErrorCode</code> pointer must be valid

 * and the value that it points to must not indicate a failure before

 * the function call. Otherwise, the function returns immediately.

 * After the function call, the value indicates success or failure.<p>

 *

 * The "limit" of a sequence of characters is the position just after their

 * last character, i.e., one more than that position.<p>

 *

 * Some of the API functions provide access to "runs".

 * Such a "run" is defined as a sequence of characters

 * that are at the same embedding level

 * after performing the BIDI algorithm.<p>

 *

 * @author Markus W. Scherer

 * @version 1.0

 *

 *

 * <h4> Sample code for the ICU BIDI API </h4>

 *

 * <h5>Rendering a paragraph with the ICU BiDi API</h5>

 *

 * This is (hypothetical) sample code that illustrates

 * how the ICU BiDi API could be used to render a paragraph of text.

 * Rendering code depends highly on the graphics system,

 * therefore this sample code must make a lot of assumptions,

 * which may or may not match any existing graphics system's properties.

 *

 * <p>The basic assumptions are:</p>

 * <ul>

 * <li>Rendering is done from left to right on a horizontal line.</li>

 * <li>A run of single-style, unidirectional text can be rendered at once.</li>

 * <li>Such a run of text is passed to the graphics system with

 *     characters (code units) in logical order.</li>

 * <li>The line-breaking algorithm is very complicated

 *     and Locale-dependent -

 *     and therefore its implementation omitted from this sample code.</li>

 * </ul>

 *

 * <pre>

 * \code

 *#include "unicode/ubidi.h"

 *

 *typedef enum {

 *     styleNormal=0, styleSelected=1,

 *     styleBold=2, styleItalics=4,

 *     styleSuper=8, styleSub=16

 *} Style;

 *

 *typedef struct { int32_t limit; Style style; } StyleRun;

 *

 *int getTextWidth(const UChar *text, int32_t start, int32_t limit,

 *                  const StyleRun *styleRuns, int styleRunCount);

 *

 * // set *pLimit and *pStyleRunLimit for a line

 * // from text[start] and from styleRuns[styleRunStart]

 * // using ubidi_getLogicalRun(para, ...)

 *void getLineBreak(const UChar *text, int32_t start, int32_t *pLimit,

 *                  UBiDi *para,

 *                  const StyleRun *styleRuns, int styleRunStart, int *pStyleRunLimit,

 *                  int *pLineWidth);

 *

 * // render runs on a line sequentially, always from left to right

 *

 * // prepare rendering a new line

 * void startLine(UBiDiDirection textDirection, int lineWidth);

 *

 * // render a run of text and advance to the right by the run width

 * // the text[start..limit-1] is always in logical order

 * void renderRun(const UChar *text, int32_t start, int32_t limit,

 *               UBiDiDirection textDirection, Style style);

 *

 * // We could compute a cross-product

 * // from the style runs with the directional runs

 * // and then reorder it.

 * // Instead, here we iterate over each run type

 * // and render the intersections -

 * // with shortcuts in simple (and common) cases.

 * // renderParagraph() is the main function.

 *

 * // render a directional run with

 * // (possibly) multiple style runs intersecting with it

 * void renderDirectionalRun(const UChar *text,

 *                           int32_t start, int32_t limit,

 *                           UBiDiDirection direction,

 *                           const StyleRun *styleRuns, int styleRunCount) {

 *     int i;

 *

 *     // iterate over style runs

 *     if(direction==UBIDI_LTR) {

 *         int styleLimit;

 *

 *         for(i=0; i<styleRunCount; ++i) {

 *             styleLimit=styleRun[i].limit;

 *             if(start<styleLimit) {

 *                 if(styleLimit>limit) { styleLimit=limit; }

 *                 renderRun(text, start, styleLimit,

 *                           direction, styleRun[i].style);

 *                 if(styleLimit==limit) { break; }

 *                 start=styleLimit;

 *             }

 *         }

 *     } else {

 *         int styleStart;

 *

 *         for(i=styleRunCount-1; i>=0; --i) {

 *             if(i>0) {

 *                 styleStart=styleRun[i-1].limit;

 *             } else {

 *                 styleStart=0;

 *             }

 *             if(limit>=styleStart) {

 *                 if(styleStart<start) { styleStart=start; }

 *                 renderRun(text, styleStart, limit,

 *                           direction, styleRun[i].style);

 *                 if(styleStart==start) { break; }

 *                 limit=styleStart;

 *             }

 *         }

 *     }

 * }

 *

 * // the line object represents text[start..limit-1]

 * void renderLine(UBiDi *line, const UChar *text,

 *                 int32_t start, int32_t limit,

 *                 const StyleRun *styleRuns, int styleRunCount) {

 *     UBiDiDirection direction=ubidi_getDirection(line);

 *     if(direction!=UBIDI_MIXED) {

 *         // unidirectional

 *         if(styleRunCount<=1) {

 *             renderRun(text, start, limit, direction, styleRuns[0].style);

 *         } else {

 *             renderDirectionalRun(text, start, limit,

 *                                  direction, styleRuns, styleRunCount);

 *         }

 *     } else {

 *         // mixed-directional

 *         int32_t count, i, length;

 *         UBiDiLevel level;

 *

 *         count=ubidi_countRuns(para, pErrorCode);

 *         if(U_SUCCESS(*pErrorCode)) {

 *             if(styleRunCount<=1) {

 *                 Style style=styleRuns[0].style;

 *

 *                 // iterate over directional runs

 *                for(i=0; i<count; ++i) {

 *                    direction=ubidi_getVisualRun(para, i, &start, &length);

 *                     renderRun(text, start, start+length, direction, style);

 *                }

 *             } else {

 *                 int32_t j;

 *

 *                 // iterate over both directional and style runs

 *                 for(i=0; i<count; ++i) {

 *                     direction=ubidi_getVisualRun(line, i, &start, &length);

 *                     renderDirectionalRun(text, start, start+length,

 *                                          direction, styleRuns, styleRunCount);

 *                 }

 *             }

 *         }

 *     }

 * }

 *

 *void renderParagraph(const UChar *text, int32_t length,

 *                     UBiDiDirection textDirection,

 *                      const StyleRun *styleRuns, int styleRunCount,

 *                      int lineWidth,

 *                      UErrorCode *pErrorCode) {

 *     UBiDi *para;

 *

 *     if(pErrorCode==NULL || U_FAILURE(*pErrorCode) || length<=0) {

 *         return;

 *     }

 *

 *     para=ubidi_openSized(length, 0, pErrorCode);

 *     if(para==NULL) { return; }

 *

 *     ubidi_setPara(para, text, length,

 *                   textDirection ? UBIDI_DEFAULT_RTL : UBIDI_DEFAULT_LTR,

 *                   NULL, pErrorCode);

 *     if(U_SUCCESS(*pErrorCode)) {

 *         UBiDiLevel paraLevel=1&ubidi_getParaLevel(para);

 *         StyleRun styleRun={ length, styleNormal };

 *         int width;

 *

 *         if(styleRuns==NULL || styleRunCount<=0) {

 *            styleRunCount=1;

 *             styleRuns=&styleRun;

 *         }

 *

 *        // assume styleRuns[styleRunCount-1].limit>=length

 *

 *         width=getTextWidth(text, 0, length, styleRuns, styleRunCount);

 *         if(width<=lineWidth) {

 *             // everything fits onto one line

 *

 *            // prepare rendering a new line from either left or right

 *             startLine(paraLevel, width);

 *

 *             renderLine(para, text, 0, length,

 *                        styleRuns, styleRunCount);

 *         } else {

 *             UBiDi *line;

 *

 *             // we need to render several lines

 *             line=ubidi_openSized(length, 0, pErrorCode);

 *             if(line!=NULL) {

 *                 int32_t start=0, limit;

 *                 int styleRunStart=0, styleRunLimit;

 *

 *                 for(;;) {

 *                     limit=length;

 *                     styleRunLimit=styleRunCount;

 *                     getLineBreak(text, start, &limit, para,

 *                                  styleRuns, styleRunStart, &styleRunLimit,

 *                                 &width);

 *                     ubidi_setLine(para, start, limit, line, pErrorCode);

 *                     if(U_SUCCESS(*pErrorCode)) {

 *                         // prepare rendering a new line

 *                         // from either left or right

 *                         startLine(paraLevel, width);

 *

 *                         renderLine(line, text, start, limit,

 *                                    styleRuns+styleRunStart,

 *                                    styleRunLimit-styleRunStart);

 *                     }

 *                     if(limit==length) { break; }

 *                     start=limit;

 *                     styleRunStart=styleRunLimit-1;

 *                     if(start>=styleRuns[styleRunStart].limit) {

 *                         ++styleRunStart;

 *                     }

 *                 }

 *

 *                 ubidi_close(line);

 *             }

 *        }

 *    }

 *

 *     ubidi_close(para);

 *}

 *\endcode

 * </pre>

 */

/*DOCXX_TAG*/

/*@{*/

/**

 * UBiDiLevel is the type of the level values in this

 * BiDi implementation.

 * It holds an embedding level and indicates the visual direction

 * by its bit&nbsp;0 (even/odd value).<p>

 *

 * It can also hold non-level values for the

 * <code>paraLevel</code> and <code>embeddingLevels</code>

 * arguments of <code>ubidi_setPara()</code>; there:

 * <ul>

 * <li>bit&nbsp;7 of an <code>embeddingLevels[]</code>

 * value indicates whether the using application is

 * specifying the level of a character to <i>override</i> whatever the

 * BiDi implementation would resolve it to.</li>

 * <li><code>paraLevel</code> can be set to the

 * pseudo-level values <code>UBIDI_DEFAULT_LTR</code>

 * and <code>UBIDI_DEFAULT_RTL</code>.</li>

 * </ul>

 *

 * @see ubidi_setPara

 *

 * <p>The related constants are not real, valid level values.

 * <code>UBIDI_DEFAULT_XXX</code> can be used to specify

 * a default for the paragraph level for

 * when the <code>ubidi_setPara()</code> function

 * shall determine it but there is no

 * strongly typed character in the input.<p>

 *

 * Note that the value for <code>UBIDI_DEFAULT_LTR</code> is even

 * and the one for <code>UBIDI_DEFAULT_RTL</code> is odd,

 * just like with normal LTR and RTL level values -

 * these special values are designed that way. Also, the implementation

 * assumes that UBIDI_MAX_EXPLICIT_LEVEL is odd.

 *

 * @see UBIDI_DEFAULT_LTR

 * @see UBIDI_DEFAULT_RTL

 * @see UBIDI_LEVEL_OVERRIDE

 * @see UBIDI_MAX_EXPLICIT_LEVEL

 * @stable ICU 2.0

 */

typedef uint8_t UBiDiLevel;

/** Paragraph level setting.

 *  If there is no strong character, then set the paragraph level to 0 (left-to-right).

 * @stable ICU 2.0

 */

#define UBIDI_DEFAULT_LTR 0xfe

/** Paragraph level setting.

 *  If there is no strong character, then set the paragraph level to 1 (right-to-left).

 * @stable ICU 2.0

 */

#define UBIDI_DEFAULT_RTL 0xff

/**

 * Maximum explicit embedding level.

 * (The maximum resolved level can be up to <code>UBIDI_MAX_EXPLICIT_LEVEL+1</code>).

 * @stable ICU 2.0

 */

#define UBIDI_MAX_EXPLICIT_LEVEL 61

/** Bit flag for level input.

 *  Overrides directional properties.

 * @stable ICU 2.0

 */

#define UBIDI_LEVEL_OVERRIDE 0x80

/**

 * <code>UBiDiDirection</code> values indicate the text direction.

 * @stable ICU 2.0

 */

enum UBiDiDirection {

    /** All left-to-right text. This is a 0 value. @stable ICU 2.0 */

    UBIDI_LTR,

    /** All right-to-left text. This is a 1 value. @stable ICU 2.0 */

    UBIDI_RTL,

    /** Mixed-directional text. @stable ICU 2.0 */

    UBIDI_MIXED

};

/** @stable ICU 2.0 */

typedef enum UBiDiDirection UBiDiDirection;

/**

 * Forward declaration of the <code>UBiDi</code> structure for the declaration of

 * the API functions. Its fields are implementation-specific.<p>

 * This structure holds information about a paragraph (or multiple paragraphs)

 * of text with BiDi-algorithm-related details, or about one line of

 * such a paragraph.<p>

 * Reordering can be done on a line, or on one or more paragraphs which are

 * then interpreted each as one single line.

 * @stable ICU 2.0

 */

struct UBiDi;

/** @stable ICU 2.0 */

typedef struct UBiDi UBiDi;

/**

 * Allocate a <code>UBiDi</code> structure.

 * Such an object is initially empty. It is assigned

 * the BiDi properties of a piece of text containing one or more paragraphs

 * by <code>ubidi_setPara()</code>

 * or the BiDi properties of a line within a paragraph by

 * <code>ubidi_setLine()</code>.<p>

 * This object can be reused for as long as it is not deallocated

 * by calling <code>ubidi_close()</code>.<p>

 * <code>ubidi_setPara()</code> and <code>ubidi_setLine()</code> will allocate

 * additional memory for internal structures as necessary.

 *

 * @return An empty <code>UBiDi</code> object.

 * @stable ICU 2.0

 */

U_STABLE UBiDi * U_EXPORT2

ubidi_open(void);

/**

 * Allocate a <code>UBiDi</code> structure with preallocated memory

 * for internal structures.

 * This function provides a <code>UBiDi</code> object like <code>ubidi_open()</code>

 * with no arguments, but it also preallocates memory for internal structures

 * according to the sizings supplied by the caller.<p>

 * Subsequent functions will not allocate any more memory, and are thus

 * guaranteed not to fail because of lack of memory.<p>

 * The preallocation can be limited to some of the internal memory

 * by setting some values to 0 here. That means that if, e.g.,

 * <code>maxRunCount</code> cannot be reasonably predetermined and should not

 * be set to <code>maxLength</code> (the only failproof value) to avoid

 * wasting memory, then <code>maxRunCount</code> could be set to 0 here

 * and the internal structures that are associated with it will be allocated

 * on demand, just like with <code>ubidi_open()</code>.

 *

 * @param maxLength is the maximum text or line length that internal memory

 *        will be preallocated for. An attempt to associate this object with a

 *        longer text will fail, unless this value is 0, which leaves the allocation

 *        up to the implementation.

 *

 * @param maxRunCount is the maximum anticipated number of same-level runs

 *        that internal memory will be preallocated for. An attempt to access

 *        visual runs on an object that was not preallocated for as many runs

 *        as the text was actually resolved to will fail,

 *        unless this value is 0, which leaves the allocation up to the implementation.<p>

 *        The number of runs depends on the actual text and maybe anywhere between

 *        1 and <code>maxLength</code>. It is typically small.<p>

 *

 * @param pErrorCode must be a valid pointer to an error code value.

 *

 * @return An empty <code>UBiDi</code> object with preallocated memory.

 * @stable ICU 2.0

 */

U_STABLE UBiDi * U_EXPORT2

ubidi_openSized(int32_t maxLength, int32_t maxRunCount, UErrorCode *pErrorCode);

/**

 * <code>ubidi_close()</code> must be called to free the memory

 * associated with a UBiDi object.<p>

 *

 * <strong>Important: </strong>

 * A parent <code>UBiDi</code> object must not be destroyed or reused if

 * it still has children.

 * If a <code>UBiDi</code> object is the <i>child</i>

 * of another one (its <i>parent</i>), after calling

 * <code>ubidi_setLine()</code>, then the child object must

 * be destroyed (closed) or reused (by calling

 * <code>ubidi_setPara()</code> or <code>ubidi_setLine()</code>)

 * before the parent object.

 *

 * @param pBiDi is a <code>UBiDi</code> object.

 *

 * @see ubidi_setPara

 * @see ubidi_setLine

 * @stable ICU 2.0

 */

U_STABLE void U_EXPORT2

ubidi_close(UBiDi *pBiDi);

/**

 * Modify the operation of the BiDi algorithm such that it

 * approximates an "inverse BiDi" algorithm. This function

 * must be called before <code>ubidi_setPara()</code>.

 *

 * <p>The normal operation of the BiDi algorithm as described

 * in the Unicode Technical Report is to take text stored in logical

 * (keyboard, typing) order and to determine the reordering of it for visual

 * rendering.

 * Some legacy systems store text in visual order, and for operations

 * with standard, Unicode-based algorithms, the text needs to be transformed

 * to logical order. This is effectively the inverse algorithm of the

 * described BiDi algorithm. Note that there is no standard algorithm for

 * this "inverse BiDi" and that the current implementation provides only an

 * approximation of "inverse BiDi".</p>

 *

 * <p>With <code>isInverse</code> set to <code>TRUE</code>,

 * this function changes the behavior of some of the subsequent functions

 * in a way that they can be used for the inverse BiDi algorithm.

 * Specifically, runs of text with numeric characters will be treated in a

 * special way and may need to be surrounded with LRM characters when they are

 * written in reordered sequence.</p>

 *

 * <p>Output runs should be retrieved using <code>ubidi_getVisualRun()</code>.

 * Since the actual input for "inverse BiDi" is visually ordered text and

 * <code>ubidi_getVisualRun()</code> gets the reordered runs, these are actually

 * the runs of the logically ordered output.</p>

 *

 * @param pBiDi is a <code>UBiDi</code> object.

 *

 * @param isInverse specifies "forward" or "inverse" BiDi operation

 *

 * @see ubidi_setPara

 * @see ubidi_writeReordered

 * @stable ICU 2.0

 */

U_STABLE void U_EXPORT2

ubidi_setInverse(UBiDi *pBiDi, UBool isInverse);

/**

 * Is this BiDi object set to perform the inverse BiDi algorithm?

 *

 * @param pBiDi is a <code>UBiDi</code> object.

 * @return TRUE if the BiDi object is set to perform the inverse BiDi algorithm

 *

 * @see ubidi_setInverse

 * @stable ICU 2.0

 */

U_STABLE UBool U_EXPORT2

ubidi_isInverse(UBiDi *pBiDi);

/**

 * Specify whether block separators must be allocated level zero,

 * so that successive paragraphs will progress from left to right.

 * This function must be called before <code>ubidi_setPara()</code>.

 * Paragraph separators (B) may appear in the text.  Setting them to level zero

 * means that all paragraph separators (including one possibly appearing

 * in the last text position) are kept in the reordered text after the text

 * that they follow in the source text.

 * When this feature is not enabled, a paragraph separator at the last

 * position of the text before reordering will go to the first position

 * of the reordered text when the paragraph level is odd.

 *

 * @param pBiDi is a <code>UBiDi</code> object.

 *

 * @param orderParagraphsLTR specifies whether paragraph separators (B) must

 * receive level 0, so that successive paragraphs progress from left to right.

 *

 * @see ubidi_setPara

 * @stable ICU 3.4

 */

U_STABLE void U_EXPORT2

ubidi_orderParagraphsLTR(UBiDi *pBiDi, UBool orderParagraphsLTR);

/**

 * Is this BiDi object set to allocate level 0 to block separators so that

 * successive paragraphs progress from left to right?

 *

 * @param pBiDi is a <code>UBiDi</code> object.

 * @return TRUE if the BiDi object is set to allocate level 0 to block

 *         separators.

 *

 * @see ubidi_orderParagraphsLTR

 * @stable ICU 3.4

 */

U_STABLE UBool U_EXPORT2

ubidi_isOrderParagraphsLTR(UBiDi *pBiDi);

/**

 * Perform the Unicode BiDi algorithm. It is defined in the

 * <a href="http://www.unicode.org/unicode/reports/tr9/">Unicode Standard Anned #9</a>,

 * version 13,

 * also described in The Unicode Standard, Version 4.0 .<p>

 *

 * This function takes a piece of plain text containing one or more paragraphs,

 * with or without externally specified embedding levels from <i>styled</i>

 * text and computes the left-right-directionality of each character.<p>

 *

 * If the entire text is all of the same directionality, then

 * the function may not perform all the steps described by the algorithm,

 * i.e., some levels may not be the same as if all steps were performed.

 * This is not relevant for unidirectional text.<br>

 * For example, in pure LTR text with numbers the numbers would get

 * a resolved level of 2 higher than the surrounding text according to

 * the algorithm. This implementation may set all resolved levels to

 * the same value in such a case.<p>

 *

 * The text can be composed of multiple paragraphs. Occurrence of a block

 * separator in the text terminates a paragraph, and whatever comes next starts

 * a new paragraph. The exception to this rule is when a Carriage Return (CR)

 * is followed by a Line Feed (LF). Both CR and LF are block separators, but

 * in that case, the pair of characters is considered as terminating the

 * preceding paragraph, and a new paragraph will be started by a character

 * coming after the LF.

 *

 * @param pBiDi A <code>UBiDi</code> object allocated with <code>ubidi_open()</code>

 *        which will be set to contain the reordering information,

 *        especially the resolved levels for all the characters in <code>text</code>.

 *

 * @param text is a pointer to the text that the

 *        BiDi algorithm will be performed on

 *        <strong>The text must be (at least) <code>length</code> long.</strong>

 *        This pointer is stored in the UBiDi object and can be retrieved

 *        with <code>ubidi_getText()</code>.

 *

 * @param length is the length of the text; if <code>length==-1</code> then

 *        the text must be zero-terminated.

 *

 * @param paraLevel specifies the default level for the text;

 *        it is typically 0 (LTR) or 1 (RTL).

 *        If the function shall determine the paragraph level from the text,

 *        then <code>paraLevel</code> can be set to

 *        either <code>UBIDI_DEFAULT_LTR</code>

 *        or <code>UBIDI_DEFAULT_RTL</code>; if the text contains multiple

 *        paragraphs, the paragraph level shall be determined separately for

 *        each paragraph; if a paragraph does not include any strongly typed

 *        character, then the desired default is used (0 for LTR or 1 for RTL).

 *        Any other value between 0 and <code>UBIDI_MAX_EXPLICIT_LEVEL</code> is also valid,

 *        with odd levels indicating RTL.

 *

 * @param embeddingLevels (in) may be used to preset the embedding and override levels,

 *        ignoring characters like LRE and PDF in the text.

 *        A level overrides the directional property of its corresponding

 *        (same index) character if the level has the

 *        <code>UBIDI_LEVEL_OVERRIDE</code> bit set.<p>

 *        Except for that bit, it must be

 *        <code>paraLevel<=embeddingLevels[]<=UBIDI_MAX_EXPLICIT_LEVEL</code>,

 *        with one exception: a level of zero may be specified for a paragraph

 *        separator even if <code>paraLevel>0</code> when multiple paragraphs

 *        are submitted in the same call to <code>ubidi_setPara()</code>.<p>

 *        <strong>Caution: </strong>A copy of this pointer, not of the levels,

 *        will be stored in the <code>UBiDi</code> object;

 *        the <code>embeddingLevels</code> array must not be

 *        deallocated before the <code>UBiDi</code> structure is destroyed or reused,

 *        and the <code>embeddingLevels</code>

 *        should not be modified to avoid unexpected results on subsequent BiDi operations.

 *        However, the <code>ubidi_setPara()</code> and

 *        <code>ubidi_setLine()</code> functions may modify some or all of the levels.<p>

 *        After the <code>UBiDi</code> object is reused or destroyed, the caller

 *        must take care of the deallocation of the <code>embeddingLevels</code> array.<p>

 *        <strong>The <code>embeddingLevels</code> array must be

 *        at least <code>length</code> long.</strong>

 *

 * @param pErrorCode must be a valid pointer to an error code value.

 * @stable ICU 2.0

 */

U_STABLE void U_EXPORT2

ubidi_setPara(UBiDi *pBiDi, const UChar *text, int32_t length,

              UBiDiLevel paraLevel, UBiDiLevel *embeddingLevels,

              UErrorCode *pErrorCode);

/**

 * <code>ubidi_setLine()</code> sets a <code>UBiDi</code> to

 * contain the reordering information, especially the resolved levels,

 * for all the characters in a line of text. This line of text is

 * specified by referring to a <code>UBiDi</code> object representing

 * this information for a piece of text containing one or more paragraphs,

 * and by specifying a range of indexes in this text.<p>

 * In the new line object, the indexes will range from 0 to <code>limit-start-1</code>.<p>

 *

 * This is used after calling <code>ubidi_setPara()</code>

 * for a piece of text, and after line-breaking on that text.

 * It is not necessary if each paragraph is treated as a single line.<p>

 *

 * After line-breaking, rules (L1) and (L2) for the treatment of

 * trailing WS and for reordering are performed on

 * a <code>UBiDi</code> object that represents a line.<p>

 *

 * <strong>Important: </strong><code>pLineBiDi</code> shares data with

 * <code>pParaBiDi</code>.

 * You must destroy or reuse <code>pLineBiDi</code> before <code>pParaBiDi</code>.

 * In other words, you must destroy or reuse the <code>UBiDi</code> object for a line

 * before the object for its parent paragraph.<p>

 *

 * The text pointer that was stored in <code>pParaBiDi</code> is also copied,

 * and <code>start</code> is added to it so that it points to the beginning of the

 * line for this object.

 *

 * @param pParaBiDi is the parent paragraph object. It must have been set

 * by a successful call to ubidi_setPara.

 *

 * @param start is the line's first index into the text.

 *

 * @param limit is just behind the line's last index into the text

 *        (its last index +1).<br>

 *        It must be <code>0<=start<=limit<=</code>containing paragraph limit.

 *        If the specified line crosses a paragraph boundary, the function

 *        will terminate with error code U_ILLEGAL_ARGUMENT_ERROR.

 *

 * @param pLineBiDi is the object that will now represent a line of the text.

 *

 * @param pErrorCode must be a valid pointer to an error code value.

 *

 * @see ubidi_setPara

 * @stable ICU 2.0

 */

U_STABLE void U_EXPORT2

ubidi_setLine(const UBiDi *pParaBiDi,

              int32_t start, int32_t limit,

              UBiDi *pLineBiDi,

              UErrorCode *pErrorCode);

/**

 * Get the directionality of the text.

 *

 * @param pBiDi is the paragraph or line <code>UBiDi</code> object.

 *

 * @return A <code>UBIDI_XXX</code> value that indicates if the entire text

 *         represented by this object is unidirectional,

 *         and which direction, or if it is mixed-directional.

 *

 * @see UBiDiDirection

 * @stable ICU 2.0

 */

U_STABLE UBiDiDirection U_EXPORT2

ubidi_getDirection(const UBiDi *pBiDi);

/**

 * Get the pointer to the text.

 *

 * @param pBiDi is the paragraph or line <code>UBiDi</code> object.

 *

 * @return The pointer to the text that the UBiDi object was created for.

 *

 * @see ubidi_setPara

 * @see ubidi_setLine

 * @stable ICU 2.0

 */

U_STABLE const UChar * U_EXPORT2

ubidi_getText(const UBiDi *pBiDi);

/**

 * Get the length of the text.

 *

 * @param pBiDi is the paragraph or line <code>UBiDi</code> object.

 *

 * @return The length of the text that the UBiDi object was created for.

 * @stable ICU 2.0

 */

U_STABLE int32_t U_EXPORT2

ubidi_getLength(const UBiDi *pBiDi);

/**

 * Get the paragraph level of the text.

 *

 * @param pBiDi is the paragraph or line <code>UBiDi</code> object.

 *

 * @return The paragraph level. If there are multiple paragraphs, their

 *         level may vary if the required paraLevel is UBIDI_DEFAULT_LTR or

 *         UBIDI_DEFAULT_RTL.  In that case, the level of the first paragraph

 *         is returned.

 *

 * @see UBiDiLevel

 * @see ubidi_getParagraph

 * @see ubidi_getParagraphByIndex

 * @stable ICU 2.0

 */

U_STABLE UBiDiLevel U_EXPORT2

ubidi_getParaLevel(const UBiDi *pBiDi);

/**

 * Get the number of paragraphs.

 *

 * @param pBiDi is the paragraph or line <code>UBiDi</code> object.

 *

 * @return The number of paragraphs.

 * @stable ICU 3.4

 */

U_STABLE int32_t U_EXPORT2

ubidi_countParagraphs(UBiDi *pBiDi);

/**

 * Get a paragraph, given a position within the text.

 * This function returns information about a paragraph.<p>

 *

 * @param pBiDi is the paragraph or line <code>UBiDi</code> object.

 *

 * @param charIndex is the index of a character within the text, in the

 *        range <code>[0..ubidi_getLength(pBiDi)-1]</code>.

 *

 * @param pParaStart will receive the index of the first character of the

 *        paragraph in the text.

 *        This pointer can be <code>NULL</code> if this

 *        value is not necessary.

 *

 * @param pParaLimit will receive the limit of the paragraph.

 *        The l-value that you point to here may be the

 *        same expression (variable) as the one for

 *        <code>charIndex</code>.

 *        This pointer can be <code>NULL</code> if this

 *        value is not necessary.

 *

 * @param pParaLevel will receive the level of the paragraph.

 *        This pointer can be <code>NULL</code> if this

 *        value is not necessary.

 *

 * @param pErrorCode must be a valid pointer to an error code value.

 *

 * @return The index of the paragraph containing the specified position.

 * @stable ICU 3.4

 */

U_STABLE int32_t U_EXPORT2

ubidi_getParagraph(const UBiDi *pBiDi, int32_t charIndex, int32_t *pParaStart,

                   int32_t *pParaLimit, UBiDiLevel *pParaLevel,

                   UErrorCode *pErrorCode);

/**

 * Get a paragraph, given the index of this paragraph.

 *

 * This function returns information about a paragraph.<p>

 *

 * @param pBiDi is the paragraph <code>UBiDi</code> object.

 *

 * @param paraIndex is the number of the paragraph, in the

 *        range <code>[0..ubidi_countParagraphs(pBiDi)-1]</code>.

 *

 * @param pParaStart will receive the index of the first character of the

 *        paragraph in the text.

 *        This pointer can be <code>NULL</code> if this

 *        value is not necessary.

 *

 * @param pParaLimit will receive the limit of the paragraph.

 *        This pointer can be <code>NULL</code> if this

 *        value is not necessary.

 *

 * @param pParaLevel will receive the level of the paragraph.

 *        This pointer can be <code>NULL</code> if this

 *        value is not necessary.

 *

 * @param pErrorCode must be a valid pointer to an error code value.

 *

 * @stable ICU 3.4

 */

U_STABLE void U_EXPORT2

ubidi_getParagraphByIndex(const UBiDi *pBiDi, int32_t paraIndex,

                          int32_t *pParaStart, int32_t *pParaLimit,

                          UBiDiLevel *pParaLevel, UErrorCode *pErrorCode);

/**

 * Get the level for one character.

 *

 * @param pBiDi is the paragraph or line <code>UBiDi</code> object.

 *

 * @param charIndex the index of a character.

 *

 * @return The level for the character at charIndex.

 *

 * @see UBiDiLevel

 * @stable ICU 2.0

 */

U_STABLE UBiDiLevel U_EXPORT2

ubidi_getLevelAt(const UBiDi *pBiDi, int32_t charIndex);

/**

 * Get an array of levels for each character.<p>

 *

 * Note that this function may allocate memory under some

 * circumstances, unlike <code>ubidi_getLevelAt()</code>.

 *

 * @param pBiDi is the paragraph or line <code>UBiDi</code> object, whose

 *        text length must be strictly positive.

 *

 * @param pErrorCode must be a valid pointer to an error code value.

 *

 * @return The levels array for the text,

 *         or <code>NULL</code> if an error occurs.

 *

 * @see UBiDiLevel

 * @stable ICU 2.0

 */

U_STABLE const UBiDiLevel * U_EXPORT2

ubidi_getLevels(UBiDi *pBiDi, UErrorCode *pErrorCode);

/**

 * Get a logical run.

 * This function returns information about a run and is used

 * to retrieve runs in logical order.<p>

 * This is especially useful for line-breaking on a paragraph.

 *

 * @param pBiDi is the paragraph or line <code>UBiDi</code> object.

 *

 * @param logicalStart is the first character of the run.

 *

 * @param pLogicalLimit will receive the limit of the run.

 *        The l-value that you point to here may be the

 *        same expression (variable) as the one for

 *        <code>logicalStart</code>.

 *        This pointer can be <code>NULL</code> if this

 *        value is not necessary.

 *

 * @param pLevel will receive the level of the run.

 *        This pointer can be <code>NULL</code> if this

 *        value is not necessary.

 * @stable ICU 2.0

 */

U_STABLE void U_EXPORT2

ubidi_getLogicalRun(const UBiDi *pBiDi, int32_t logicalStart,

                    int32_t *pLogicalLimit, UBiDiLevel *pLevel);

/**

 * Get the number of runs.

 * This function may invoke the actual reordering on the

 * <code>UBiDi</code> object, after <code>ubidi_setPara()</code>

 * may have resolved only the levels of the text. Therefore,

 * <code>ubidi_countRuns()</code> may have to allocate memory,

 * and may fail doing so.

 *

 * @param pBiDi is the paragraph or line <code>UBiDi</code> object.

 *

 * @param pErrorCode must be a valid pointer to an error code value.

 *

 * @return The number of runs.

 * @stable ICU 2.0

 */

U_STABLE int32_t U_EXPORT2

ubidi_countRuns(UBiDi *pBiDi, UErrorCode *pErrorCode);

/**

 * Get one run's logical start, length, and directionality,

 * which can be 0 for LTR or 1 for RTL.

 * In an RTL run, the character at the logical start is

 * visually on the right of the displayed run.

 * The length is the number of characters in the run.<p>

 * <code>ubidi_countRuns()</code> should be called

 * before the runs are retrieved.

 *

 * @param pBiDi is the paragraph or line <code>UBiDi</code> object.

 *

 * @param runIndex is the number of the run in visual order, in the

 *        range <code>[0..ubidi_countRuns(pBiDi)-1]</code>.

 *

 * @param pLogicalStart is the first logical character index in the text.

 *        The pointer may be <code>NULL</code> if this index is not needed.

 *

 * @param pLength is the number of characters (at least one) in the run.

 *        The pointer may be <code>NULL</code> if this is not needed.

 *

 * @return the directionality of the run,

 *         <code>UBIDI_LTR==0</code> or <code>UBIDI_RTL==1</code>,

 *         never <code>UBIDI_MIXED</code>.

 *

 * @see ubidi_countRuns

 *

 * Example:

 * <pre>

 * \code

 * int32_t i, count=ubidi_countRuns(pBiDi),

 *         logicalStart, visualIndex=0, length;

 * for(i=0; i<count; ++i) {

 *    if(UBIDI_LTR==ubidi_getVisualRun(pBiDi, i, &logicalStart, &length)) {

 *         do { // LTR

 *             show_char(text[logicalStart++], visualIndex++);

 *         } while(--length>0);

 *     } else {

 *         logicalStart+=length;  // logicalLimit

 *         do { // RTL

 *             show_char(text[--logicalStart], visualIndex++);

 *         } while(--length>0);

 *     }

 * }

 *\endcode

 * </pre>

 *

 * Note that in right-to-left runs, code like this places

 * modifier letters before base characters and second surrogates

 * before first ones.

 * @stable ICU 2.0

 */

U_STABLE UBiDiDirection U_EXPORT2

ubidi_getVisualRun(UBiDi *pBiDi, int32_t runIndex,

                   int32_t *pLogicalStart, int32_t *pLength);

/**

 * Get the visual position from a logical text position.

 * If such a mapping is used many times on the same

 * <code>UBiDi</code> object, then calling

 * <code>ubidi_getLogicalMap()</code> is more efficient.<p>

 *

 * Note that in right-to-left runs, this mapping places

 * modifier letters before base characters and second surrogates

 * before first ones.

 *

 * @param pBiDi is the paragraph or line <code>UBiDi</code> object.

 *

 * @param logicalIndex is the index of a character in the text.

 *

 * @param pErrorCode must be a valid pointer to an error code value.

 *

 * @return The visual position of this character.

 *

 * @see ubidi_getLogicalMap

 * @see ubidi_getLogicalIndex

 * @stable ICU 2.0

 */