/*

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

*

*   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