Bidi Klasse

Definition

        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

Vererbung

Object

JavaObject

Object

Bidi

Attribute

RegisterAttribute

Hinweise

<h2>Bidi-Algorithmus für ICU</h2>

Dies ist eine Implementierung des bidirektionalen Unicode-Algorithmus. Der Algorithmus wird im Unicode-Standard-Anhang Nr. 9 definiert.

Hinweis: Bibliotheken, die einen bidirektionalen Algorithmus ausführen und Zeichenfolgen entsprechend neu anordnen, werden manchmal als "Storage Layout Engines" bezeichnet. ICU-Klassen Bidi und Shaping (ArabicShaping) können im Kern solcher "Storage Layout Engines" verwendet werden.

<h3>Allgemeine Hinweise zur API:</h3>

Das " limit" eine Abfolge von Zeichen ist die Position unmittelbar nach dem letzten Zeichen, d. h. einer mehr als dieser Position.

Einige der API-Methoden bieten Zugriff auf " wird ausgeführt". Eine solche " ausführen" wird als Eine Abfolge von Zeichen definiert, die sich nach dem Ausführen des Bidi-Algorithmus auf derselben Einbettungsebene befinden.

<h3>Grundlegendes Konzept: Absatz</h3> Ein Textteil kann in mehrere Absätze nach Zeichen mit der Bidi-Klasse Block Separatorunterteilt werden. Für die Behandlung von Absätzen siehe: <ul><li>#countParagraphs<li li>#getParaLevel<li>#getParagraph<>#getParagraphByIndex</ul>

<h3>Grundkonzept: Textrichtung</h3> Die Richtung eines Textstücks kann sein: <ul><li>#LTR<li li>#RTL<>#MIXED<li>#NEUTRAL</ul>

<h3>Grundkonzept: Levels</h3>

Ebenen in dieser API stellen Einbettungsebenen gemäß dem Bidirektionalen Unicode-Algorithmus dar. Das Bit mit niedriger Reihenfolge (gerade/ungerade Werte) gibt die visuelle Richtung an.

Ebenen können abstrakte Werte sein, wenn sie für die paraLevel Argumente und embeddingLevels Argumente von setPara(); verwendet werden: <><ul li>das Hochreihenfolge-Bit eines embeddingLevels[] Werts gibt an, ob die verwendete Anwendung die Ebene eines Zeichens angibt, in das die Bidi-Implementierung aufgelöst würde.</li li><>paraLevel kann auf die Pseudoebenenwerte LEVEL_DEFAULT_LTR und .LEVEL_DEFAULT_RTL</li></ul>

Die zugehörigen Konstanten sind keine echten, gültigen Levelwerte. DEFAULT_XXX kann verwendet werden, um eine Standardeinstellung für die Absatzebene anzugeben, für die die setPara() Methode bestimmt werden soll, in der Eingabe jedoch kein stark typisiertes Zeichen vorhanden ist.

Beachten Sie, dass der Wert gerade LEVEL_DEFAULT_LTR ist und der LEVEL_DEFAULT_RTL wert ist ungerade ist, genau wie bei normalen LTR- und RTL-Werten – diese speziellen Werte sind so konzipiert. Außerdem geht die Implementierung davon aus, dass MAX_EXPLICIT_LEVEL ungerade ist.

Hinweis: Die numerischen Werte der zugehörigen Konstanten ändern sich nicht: Sie sind an die Verwendung von 7-Bit-Bytewerten (plus der Überschreibungsbit) und des Byte-Datentyps in dieser API gebunden.

<b>Siehe auch:</b><ul><li>#LEVEL_DEFAULT_LTR<li>#LEVEL_DEFAULT_RTL<li li>#LEVEL_OVERRIDE<li>#MAX_EXPLICIT_LEVEL<>#setPara</ul>

<h3>Grundlegendes Konzept: Neuanordnen des Modus</h3> Neuanordnungsmoduswerte geben an, welche Variante des Bidi-Algorithmus verwendet werden soll.

<b>Siehe auch:</b><ul><li>#setReorderingMode<>#REORDER_DEFAULT<>#REORDER_NUMBERS_SPECIAL<>#REORDER_GROUP_NUMBERS_WITH_R<li>#REORDER_RUNS_ONLY<>#REORDER_INVERSE_NUMBERS_AS_L<>#REORDER_INVERSE_LIKE_DIRECT<>#REORDER_INVERSE_FOR_NUMBERS_SPECIAL</ul>

<h3>Basic-Konzept: Optionen neu anordnen</h3> Neuanordnungsoptionen können während Bidi-Texttransformationen angewendet werden.

<b>Siehe auch:</b><ul><li>#setReorderingOptions<li>#OPTION_DEFAULT<li li>#OPTION_INSERT_MARKS<li>#OPTION_REMOVE_CONTROLS<>#OPTION_STREAMING</ul>

<h4-Beispielcode> für die ICU Bidi-API </h4>

<h5>Rendern eines Absatzes mit der ICU Bidi-API</h5>

Dies ist (hypothetischer) Beispielcode, der veranschaulicht, wie die ICU Bidi-API zum Rendern eines Textabsatzs verwendet werden kann. Das Rendern von Code hängt stark vom Grafiksystem ab, daher muss dieser Beispielcode viele Annahmen treffen, die möglicherweise den Eigenschaften des vorhandenen Grafiksystems entsprechen oder nicht.

Die grundlegenden Annahmen sind:

<ul><li>Rendering erfolgt von links nach rechts in einer horizontalen Linie.</li><Li>Eine Ausführung von einzelformatigem, unidirektionalem Text kann gleichzeitig gerendert werden. </li li><>Eine solche Textausführung wird an das Grafiksystem mit Zeichen (Codeeinheiten) in logischer Reihenfolge übergeben.</li Li><>Der Zeilenumbruchalgorithmus ist sehr kompliziert und gebietsschemaabhängig - daher wird die Implementierung aus diesem Beispielcode weggelassen.</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 Dokumentation für android.icu.text.Bidi.

Teile dieser Seite sind Änderungen auf der Grundlage von Arbeiten, die von der Android Open Source Project erstellt und gemeinsam verwendet und gemäß den in der 2.5 Attribution License beschriebenen Begriffen verwendet werden.

        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.