Bidi Clase

Definición

        This is an implementation of the Unicode Bidirectional Algorithm.

[Android.Runtime.Register("android/icu/text/Bidi", ApiSince=29, DoNotGenerateAcw=true)]
public class Bidi : Java.Lang.Object

[<Android.Runtime.Register("android/icu/text/Bidi", ApiSince=29, DoNotGenerateAcw=true)>]
type Bidi = class
    inherit Object

Herencia

Object

JavaObject

Object

Bidi

Atributos

RegisterAttribute

Comentarios

<h2>Algoritmo bidi para ICU</h2>

Se trata de una implementación del algoritmo bidireccional Unicode. El algoritmo se define en el Anexo estándar Unicode n.º 9.

Nota: Las bibliotecas que realizan un algoritmo bidireccional y reordenar las cadenas en consecuencia se denominan a veces "Motores de diseño de almacenamiento". Las clases Bidi y modelado de ICU (ÁrabeShaping) se pueden usar en el núcleo de tales "Motores de diseño de almacenamiento".

<h3>Observaciones generales sobre la API:</h3>

" limit" de una secuencia de caracteres es la posición justo después de su último carácter, es decir, una más que esa posición.

Algunos de los métodos de API proporcionan acceso a " ejecuta". Tal " ejecutar" se define como una secuencia de caracteres que están en el mismo nivel de inserción después de realizar el algoritmo Bidi.

<h3>Concepto básico: párrafo</h3> Un fragmento de texto se puede dividir en varios párrafos por caracteres con la clase Block SeparatorBidi . Para el tratamiento de párrafos, consulte: <ul><li>#countParagraphs<li>#getParaLevel<li li>#getParagraph<>#getParagraphByIndex</ul>

<h3>Concepto básico: dirección< del texto/h3> La dirección de un fragmento de texto puede ser: <ul><li li>#LTR<>#RTL<li>#MIXED<>#NEUTRAL</ul>

<h3>Concepto básico: niveles</h3>

Los niveles de esta API representan niveles de inserción según el algoritmo bidireccional Unicode. Su bit de orden bajo (valor par/impar) indica la dirección visual.

Los niveles pueden ser valores abstractos cuando se usan para los paraLevel argumentos y embeddingLevels de setPara(); there: <ul><li>el bit de orden superior de un embeddingLevels[] valor indica si la aplicación using especifica el nivel de un carácter para invalidar lo que la implementación de Bidi resolvería.</li><li>paraLevel se puede establecer en los valores LEVEL_DEFAULT_LTR pseudoni level y LEVEL_DEFAULT_RTL.</li></ul>

Las constantes relacionadas no son valores de nivel reales y válidos. DEFAULT_XXX se puede usar para especificar un valor predeterminado para el nivel de párrafo para cuando el setPara() método lo determine, pero no hay ningún carácter fuertemente tipado en la entrada.

Tenga en cuenta que el valor de LEVEL_DEFAULT_LTR es par y el LEVEL_DEFAULT_RTL de es impar, al igual que con los valores normales de nivel LTR y RTL: estos valores especiales están diseñados de esa manera. Además, la implementación supone que MAX_EXPLICIT_LEVEL es impar.

Nota: Los valores numéricos de las constantes relacionadas no cambiarán: están vinculados al uso de valores de bytes de 7 bits (más el bit de invalidación) y del tipo de datos byte de esta API.

<b>Véase también:</b><ul li><>#LEVEL_DEFAULT_LTR<li>#LEVEL_DEFAULT_RTL<li li>#LEVEL_OVERRIDE<>#MAX_EXPLICIT_LEVEL<>#setPara</ul>

<h3>Concepto básico: Los valores del modo de reordenación/h3< Reordenar> los valores del modo indican la variante del algoritmo Bidi que se va a usar.

<b>Véase también:</b><ul li><>#setReorderingMode<>#REORDER_DEFAULT<>#REORDER_NUMBERS_SPECIAL<>#REORDER_GROUP_NUMBERS_WITH_R<>#REORDER_RUNS_ONLY<>#REORDER_INVERSE_NUMBERS_AS_L<>#REORDER_INVERSE_LIKE_DIRECT<>#REORDER_INVERSE_FOR_NUMBERS_SPECIAL</ul>

<h3>Concepto básico: Las opciones< de reordenación/h3> se pueden aplicar durante las transformaciones de texto bidi.

<b>Véase también:</b><ul li><>#setReorderingOptions<li>#OPTION_DEFAULT<li li>#OPTION_INSERT_MARKS<>#OPTION_REMOVE_CONTROLS<>#OPTION_STREAMING</ul>

<h4> Código de ejemplo para la API <bidi de ICU /h4>

<h5>Representación de un párrafo con la API< bidi de ICU/h5>

Este es el código de ejemplo (hipotético) que ilustra cómo se podría usar la API bidi de ICU para representar un párrafo de texto. El código de representación depende en gran medida del sistema gráfico, por lo que este código de ejemplo debe realizar una gran cantidad de suposiciones, lo que puede o no coincidir con las propiedades del sistema gráfico existente.

Las suposiciones básicas son:

<ul><li>Rendering se realiza de izquierda a derecha en una línea horizontal.</li li><>Una ejecución de texto unidireccional de estilo único se puede representar a la vez. </li li><>Esta ejecución de texto se pasa al sistema gráfico con caracteres (unidades de código) en orden lógico.</li li><>El algoritmo de salto de línea es muy complicado y dependiente de la configuración regional; por lo tanto, su implementación se omite de este código de ejemplo.</li></ul>

package android.icu.dev.test.bidi;

             import android.icu.text.Bidi;
             import android.icu.text.BidiRun;

             public class Sample {

                 static final int styleNormal = 0;
                 static final int styleSelected = 1;
                 static final int styleBold = 2;
                 static final int styleItalics = 4;
                 static final int styleSuper=8;
                 static final int styleSub = 16;

                 static class StyleRun {
                     int limit;
                     int style;

                     public StyleRun(int limit, int style) {
                         this.limit = limit;
                         this.style = style;
                     }
                 }

                 static class Bounds {
                     int start;
                     int limit;

                     public Bounds(int start, int limit) {
                         this.start = start;
                         this.limit = limit;
                     }
                 }

                 static int getTextWidth(String text, int start, int limit,
                                         StyleRun[] styleRuns, int styleRunCount) {
                     // simplistic way to compute the width
                     return limit - start;
                 }

                 // set limit and StyleRun limit for a line
                 // from text[start] and from styleRuns[styleRunStart]
                 // using Bidi.getLogicalRun(...)
                 // returns line width
                 static int getLineBreak(String text, Bounds line, Bidi para,
                                         StyleRun styleRuns[], Bounds styleRun) {
                     // dummy return
                     return 0;
                 }

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

                 // prepare rendering a new line
                 static void startLine(byte textDirection, int lineWidth) {
                     System.out.println();
                 }

                 // render a run of text and advance to the right by the run width
                 // the text[start..limit-1] is always in logical order
                 static void renderRun(String text, int start, int limit,
                                       byte textDirection, int 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
                 static void renderDirectionalRun(String text, int start, int limit,
                                                  byte direction, StyleRun styleRuns[],
                                                  int styleRunCount) {
                     int i;

                     // iterate over style runs
                     if (direction == Bidi.LTR) {
                         int styleLimit;
                         for (i = 0; i < styleRunCount; ++i) {
                             styleLimit = styleRuns[i].limit;
                             if (start < styleLimit) {
                                 if (styleLimit > limit) {
                                     styleLimit = limit;
                                 }
                                 renderRun(text, start, styleLimit,
                                           direction, styleRuns[i].style);
                                 if (styleLimit == limit) {
                                     break;
                                 }
                                 start = styleLimit;
                             }
                         }
                     } else {
                         int styleStart;

                         for (i = styleRunCount-1; i >= 0; --i) {
                             if (i > 0) {
                                 styleStart = styleRuns[i-1].limit;
                             } else {
                                 styleStart = 0;
                             }
                             if (limit >= styleStart) {
                                 if (styleStart < start) {
                                     styleStart = start;
                                 }
                                 renderRun(text, styleStart, limit, direction,
                                           styleRuns[i].style);
                                 if (styleStart == start) {
                                     break;
                                 }
                                 limit = styleStart;
                             }
                         }
                     }
                 }

                 // the line object represents text[start..limit-1]
                 static void renderLine(Bidi line, String text, int start, int limit,
                                        StyleRun styleRuns[], int styleRunCount) {
                     byte direction = line.getDirection();
                     if (direction != Bidi.MIXED) {
                         // unidirectional
                         if (styleRunCount <= 1) {
                             renderRun(text, start, limit, direction, styleRuns[0].style);
                         } else {
                             renderDirectionalRun(text, start, limit, direction,
                                                  styleRuns, styleRunCount);
                         }
                     } else {
                         // mixed-directional
                         int count, i;
                         BidiRun run;

                         try {
                             count = line.countRuns();
                         } catch (IllegalStateException e) {
                             e.printStackTrace();
                             return;
                         }
                         if (styleRunCount <= 1) {
                             int style = styleRuns[0].style;

                             // iterate over directional runs
                             for (i = 0; i < count; ++i) {
                                 run = line.getVisualRun(i);
                                 renderRun(text, run.getStart(), run.getLimit(),
                                           run.getDirection(), style);
                             }
                         } else {
                             // iterate over both directional and style runs
                             for (i = 0; i < count; ++i) {
                                 run = line.getVisualRun(i);
                                 renderDirectionalRun(text, run.getStart(),
                                                      run.getLimit(), run.getDirection(),
                                                      styleRuns, styleRunCount);
                             }
                         }
                     }
                 }

                 static void renderParagraph(String text, byte textDirection,
                                             StyleRun styleRuns[], int styleRunCount,
                                             int lineWidth) {
                     int length = text.length();
                     Bidi para = new Bidi();
                     try {
                         para.setPara(text,
                                      textDirection != 0 ? Bidi.LEVEL_DEFAULT_RTL
                                                         : Bidi.LEVEL_DEFAULT_LTR,
                                      null);
                     } catch (Exception e) {
                         e.printStackTrace();
                         return;
                     }
                     byte paraLevel = (byte)(1 & para.getParaLevel());
                     StyleRun styleRun = new StyleRun(length, styleNormal);

                     if (styleRuns == null || styleRunCount <= 0) {
                         styleRuns = new StyleRun[1];
                         styleRunCount = 1;
                         styleRuns[0] = styleRun;
                     }
                     // assume styleRuns[styleRunCount-1].limit>=length

                     int 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 {
                         // we need to render several lines
                         Bidi line = new Bidi(length, 0);
                         int start = 0, limit;
                         int styleRunStart = 0, styleRunLimit;

                         for (;;) {
                             limit = length;
                             styleRunLimit = styleRunCount;
                             width = getLineBreak(text, new Bounds(start, limit),
                                                  para, styleRuns,
                                                  new Bounds(styleRunStart, styleRunLimit));
                             try {
                                 line = para.setLine(start, limit);
                             } catch (Exception e) {
                                 e.printStackTrace();
                                 return;
                             }
                             // prepare rendering a new line
                             // from either left or right
                             startLine(paraLevel, width);

                             if (styleRunStart > 0) {
                                 int newRunCount = styleRuns.length - styleRunStart;
                                 StyleRun[] newRuns = new StyleRun[newRunCount];
                                 System.arraycopy(styleRuns, styleRunStart, newRuns, 0,
                                                  newRunCount);
                                 renderLine(line, text, start, limit, newRuns,
                                            styleRunLimit - styleRunStart);
                             } else {
                                 renderLine(line, text, start, limit, styleRuns,
                                            styleRunLimit - styleRunStart);
                             }
                             if (limit == length) {
                                 break;
                             }
                             start = limit;
                             styleRunStart = styleRunLimit - 1;
                             if (start >= styleRuns[styleRunStart].limit) {
                                 ++styleRunStart;
                             }
                         }
                     }
                 }

                 public static void main(String[] args)
                 {
                     renderParagraph("Some Latin text...", Bidi.LTR, null, 0, 80);
                     renderParagraph("Some Hebrew text...", Bidi.RTL, null, 0, 60);
                 }
             }

Java documentación para android.icu.text.Bidi.

Las partes de esta página son modificaciones basadas en el trabajo creado y compartido por el Android y se usan según los términos descritos en creative Creative Commons 2.5 Attribution License.

        This is an implementation of the Unicode Bidirectional Algorithm.

        This is an implementation of the Unicode Bidirectional Algorithm.

        This is an implementation of the Unicode Bidirectional Algorithm.

        This is an implementation of the Unicode Bidirectional Algorithm.

        This is an implementation of the Unicode Bidirectional Algorithm.

        This is an implementation of the Unicode Bidirectional Algorithm.

        This is an implementation of the Unicode Bidirectional Algorithm.

        This is an implementation of the Unicode Bidirectional Algorithm.

        This is an implementation of the Unicode Bidirectional Algorithm.

        This is an implementation of the Unicode Bidirectional Algorithm.

        This is an implementation of the Unicode Bidirectional Algorithm.

        This is an implementation of the Unicode Bidirectional Algorithm.

        This is an implementation of the Unicode Bidirectional Algorithm.

        This is an implementation of the Unicode Bidirectional Algorithm.

        This is an implementation of the Unicode Bidirectional Algorithm.

        This is an implementation of the Unicode Bidirectional Algorithm.