Bidi Classe

Definição

        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

Herança

Object

JavaObject

Object

Bidi

Atributos

RegisterAttribute

Comentários

<Algoritmo de bidi h2>para UTI</h2>

Essa é uma implementação do Algoritmo Bidirecional Unicode. O algoritmo é definido no Anexo Padrão Unicode nº 9.

Observação: bibliotecas que executam um algoritmo bidirecional e reordenam cadeias de caracteres de acordo às vezes são chamadas de "Mecanismos de Layout de Armazenamento". As classes Bidi e shaping (ArabicShaping) da UTI podem ser usadas no núcleo desses "Mecanismos de Layout de Armazenamento".

<comentários gerais h3>sobre a API:</h3>

A > limit" de uma sequência de caracteres é a posição logo após seu último caractere, ou seja, um a mais do que essa posição.

Alguns dos métodos de API fornecem acesso a " executa>. Como um " run" é definido como uma sequência de caracteres que estão no mesmo nível de inserção depois de executar o algoritmo Bidi.

<conceito básico h3>: parágrafo</h3> Uma parte do texto pode ser dividida em vários parágrafos por caracteres com a classe Block SeparatorBidi. Para tratamento de parágrafos, consulte: <ul><li>#countParagraphs<li>#getParaLevel<li>#getParagraph<>#getParagraphByIndex</ul>

<h3>Conceito básico: direção< do texto/h3> A direção de uma parte do texto pode ser: <ul><li>#LTR<li>#RTL<li>#MIXED<>#NEUTRAL</ul>

<Conceito básico h3>: níveis</h3>

Os níveis nessa API representam níveis de inserção de acordo com o Algoritmo Bidirecional Unicode. O bit de ordem baixa (valor par/ímpar) indica a direção visual.

Os níveis podem ser valores abstratos quando usados para o paraLevel e embeddingLevels argumentos de setPara(); lá: <ul><li>o bit de alta ordem de um embeddingLevels[] valor indica se o aplicativo de uso está especificando o nível de um caractere para substituir qualquer que seja a implementação Bidi resolveria.</li><li>paraLevel pode ser definido como os valores LEVEL_DEFAULT_LTR pseudonível e LEVEL_DEFAULT_RTL.</li></ul>

As constantes relacionadas não são valores de nível reais e válidos. DEFAULT_XXX pode ser usado para especificar um padrão para o nível de parágrafo para quando o setPara() método deve determiná-lo, mas não há nenhum caractere fortemente tipado na entrada.

Observe que o valor para LEVEL_DEFAULT_LTR é uniforme e aquele para LEVEL_DEFAULT_RTL é ímpar, assim como com valores normais de nível LTR e RTL - esses valores especiais são projetados dessa forma. Além disso, a implementação pressupõe que MAX_EXPLICIT_LEVEL é ímpar.

Observação: os valores numéricos das constantes relacionadas não serão alterados: eles estão vinculados ao uso de valores de bytes de 7 bits (mais o bit de substituição) e ao tipo de dados de bytes nesta API.

<b>Consulte Também:</b><ul><li>#LEVEL_DEFAULT_LTR<>#LEVEL_DEFAULT_RTL<li li>#LEVEL_OVERRIDE<li>#MAX_EXPLICIT_LEVEL<>#setPara</ul>

<Conceito básico h3>: valores de modo de reordenação de modo</h3> indicam qual variante do algoritmo Bidi usar.

<b>Consulte Também:</b><ul><li>#setReorderingMode<>#REORDER_DEFAULT<li>#REORDER_NUMBERS_SPECIAL<li>#REORDER_GROUP_NUMBERS_WITH_R<li>#REORDER_RUNS_ONLY<li>#REORDER_INVERSE_NUMBERS_AS_L<li>#REORDER_INVERSE_LIKE_DIRECT<li>#REORDER_INVERSE_FOR_NUMBERS_SPECIAL</ul>

<Conceito básico h3>: Opções< de reordenação/h3> Opções de reordenação podem ser aplicadas durante transformações de texto Bidi.

<b>Consulte Também:</b><ul><li>#setReorderingOptions<>#OPTION_DEFAULT<li li>#OPTION_INSERT_MARKS<li>#OPTION_REMOVE_CONTROLS<>#OPTION_STREAMING</ul>

<Código de exemplo h4> para a API <bidi da UTI /h4>

<h5>Renderizando um parágrafo com a API< Bidi da UTI/h5>

Este é um código de exemplo (hipotético) que ilustra como a API Bidi da UTI pode ser usada para renderizar um parágrafo de texto. O código de renderização depende muito do sistema gráfico, portanto, esse código de exemplo deve fazer muitas suposições, que podem ou não corresponder às propriedades do sistema gráfico existente.

As suposições básicas são:

<ul><li>Rendering é feito da esquerda para a direita em uma linha horizontal.</li><li>Uma execução de texto unidirecional de estilo único pode ser renderizada de uma só vez. </li li><>Essa execução de texto é passada para o sistema gráfico com caracteres (unidades de código) em ordem lógica.</li><li>O algoritmo de quebra de linha é muito complicado e dependente de localidade e, portanto, sua implementação omitida desse código de exemplo.</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 documentação para android.icu.text.Bidi.

Partes desta página são modificações baseadas no trabalho criado e compartilhado pelo Project Open Source do Open Source e usadas de acordo com os termos descritos na Creative Commons 2.5.

        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.