Bidi Classe

Definizione

        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

Ereditarietà

Object

JavaObject

Object

Bidi

Attributi

RegisterAttribute

Commenti

<Algoritmo h2>Bidi per ICU</h2>

Si tratta di un'implementazione dell'algoritmo bidirezionale Unicode. L'algoritmo è definito nell'allegato standard Unicode n. 9.

Nota: le librerie che eseguono un algoritmo bidirezionale e riordinano le stringhe di conseguenza sono talvolta denominate "Motori di layout di archiviazione". Le classi Bidi e shaping (ArabicShaping) dell'ICU possono essere usate al centro di tali "Motori di layout di archiviazione".

<h3>Osservazioni generali sull'API:</h3>

Il " limit" di una sequenza di caratteri è la posizione subito dopo l'ultimo carattere, ovvero una più di quella posizione.

Alcuni dei metodi API forniscono l'accesso a " run". Tale " run" viene definito come una sequenza di caratteri allo stesso livello di incorporamento dopo l'esecuzione dell'algoritmo Bidi.

<h3>Concetto di base: paragrafo</h3> Un frammento di testo può essere diviso in diversi paragrafi per caratteri con la classe Block SeparatorBidi . Per la gestione dei paragrafi, vedere: <ul><li>#countParagraphs<li>#getParaLevel<li li>#getParagraph<>#getParagraphByIndex</ul>

<h3>Concetto di base: direzione< del testo/h3> La direzione di un pezzo di testo può essere: <ul><li>#LTR<li>#RTL<li li>#MIXED<>#NEUTRAL</ul>

<h3>Concetto di base: livelli</h3>

I livelli in questa API rappresentano i livelli di incorporamento in base all'algoritmo bidirezionale Unicode. Il bit di ordine basso (valore pari/dispari) indica la direzione visiva.

I livelli possono essere valori astratti quando vengono usati per gli paraLevel argomenti e embeddingLevels di setPara(). There: <ul><li>il bit di ordine elevato di un embeddingLevels[] valore indica se l'applicazione using specifica il livello di un carattere per eseguire l'override di qualsiasi implementazione bidi la risolverà.</li><li>paraLevel può essere impostato sui valori LEVEL_DEFAULT_LTR pseudolivello e LEVEL_DEFAULT_RTL.</li></ul>

Le costanti correlate non sono valori di livello reali e validi. DEFAULT_XXX può essere utilizzato per specificare un valore predefinito per il livello di paragrafo per quando il setPara() metodo lo determina, ma non esiste un carattere fortemente tipizzato nell'input.

Si noti che il valore per è pari e quello per LEVEL_DEFAULT_LTRLEVEL_DEFAULT_RTL è dispari, proprio come con i normali valori di livello LTR e RTL, questi valori speciali sono progettati in questo modo. Inoltre, l'implementazione presuppone che MAX_EXPLICIT_LEVEL sia strano.

Nota: i valori numerici delle costanti correlate non cambieranno: sono associati all'uso di valori di byte a 7 bit (più il bit di override) e del tipo di dati di byte in questa API.

<b>Vedere anche:</b><ul><li li>#LEVEL_DEFAULT_LTR<>#LEVEL_DEFAULT_RTL<li>#LEVEL_OVERRIDE<li li>#MAX_EXPLICIT_LEVEL<>#setPara</ul>

<h3>Basic concept: Reordering Mode</h3> Reordering mode values indica quale variante dell'algoritmo Bidi usare.

<b>Vedere anche:</b><ul><li 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>Concetto di base: è possibile applicare< le opzioni di riordinamento delle opzioni/h3> durante le trasformazioni di testo Bidi.

<b>Vedere anche:</b><ul><li li>#setReorderingOptions<>#OPTION_DEFAULT<li>#OPTION_INSERT_MARKS<li li>#OPTION_REMOVE_CONTROLS<>#OPTION_STREAMING</ul>

<h4> Codice di esempio per l'API <Bidi di ICU /h4>

<h5>Rendering di un paragrafo con l'API< Bidi di ICU/h5>

Questo è il codice di esempio (ipotetico) che illustra come l'API ICU Bidi può essere usata per eseguire il rendering di un paragrafo di testo. Il codice di rendering dipende in modo elevato dal sistema grafico, pertanto questo codice di esempio deve fare molti presupposti, che possono o meno corrispondere alle proprietà di qualsiasi sistema grafico esistente.

I presupposti di base sono:

<ul><li>Rendering viene eseguito da sinistra a destra su una linea orizzontale.</li><li>Una sequenza di testo unidirezionale di tipo singolo può essere eseguito contemporaneamente. </li><li>Tale esecuzione di testo viene passata al sistema grafico con caratteri (unità di codice) in ordine logico.</li><li>L'algoritmo di interruzione di riga è molto complicato e dipendente dalle impostazioni locali, pertanto l'implementazione omessa da questo codice di esempio.</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);
                 }
             }

per android.icu.text.Bidi.

Le parti di questa pagina sono modifiche basate sul lavoro creato e condiviso dalla e usati in base ai termini descritti in Creative License 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.