Bidi Classe

Définition

        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

Héritage

Object

JavaObject

Object

Bidi

Attributs

RegisterAttribute

Remarques

<Algorithme Bidi h2>pour ICU</h2>

Il s’agit d’une implémentation de l’algorithme bidirectionnel Unicode. L’algorithme est défini dans l’annexe Standard Unicode #9.

Remarque : les bibliothèques qui effectuent un algorithme bidirectionnel et réorganisent les chaînes en conséquence sont parfois appelées « Moteurs de disposition de stockage ». Les classes Bidi et mise en forme (arabicShaping) de l’ICU peuvent être utilisées au cœur de ces « moteurs de disposition de stockage ».

< >Remarques générales sur l’API :</h3>

" limit" d’une séquence de caractères est la position juste après leur dernier caractère, c’est-à-dire une autre position.

Certaines méthodes d’API fournissent un accès à " exécute". Un tel " run" est défini comme une séquence de caractères qui se trouvent au même niveau d’incorporation après avoir effectué l’algorithme Bidi.

<Concept de base h3>: paragraphe</h3> Une partie de texte peut être divisée en plusieurs paragraphes par caractères avec la classe Block SeparatorBidi . Pour la gestion des paragraphes, consultez : <ul><li>#countParagraphs<li li>#getParaLevel<>#getParagraph<>#getParagraphByIndex</ul>

<concept de base h3>: sens< du texte/h3> La direction d’un morceau de texte peut être : <ul><li>#LTR<li li>#RTL<>#MIXED<li>#NEUTRAL</ul>

<concept de base h3>: niveaux</h3>

Les niveaux de cette API représentent des niveaux d’incorporation en fonction de l’algorithme bidirectionnel Unicode. Leur bit de faible ordre (même/impair) indique la direction visuelle.

Les niveaux peuvent être des valeurs abstraites lorsqu’ils sont utilisés pour les paraLevelembeddingLevels arguments et les arguments de setPara(); il y a : <ul><li>le bit d’ordre élevé d’une embeddingLevels[] valeur indique si l’application using spécifie le niveau d’un caractère pour remplacer l’implémentation Bidi la résoudre.</li li><>paraLevel peut être défini sur les valeurs LEVEL_DEFAULT_LTR de pseudo-niveau et .LEVEL_DEFAULT_RTL</li></ul>

Les constantes associées ne sont pas des valeurs de niveau réels et valides. DEFAULT_XXX peut être utilisé pour spécifier une valeur par défaut pour le niveau de paragraphe pour le moment où la setPara() méthode doit la déterminer, mais il n’y a pas de caractère fortement typé dans l’entrée.

Notez que la valeur pour LEVEL_DEFAULT_LTR est même et que celle pour LEVEL_DEFAULT_RTL est impaire, tout comme avec les valeurs de niveau LTR et RTL normales , ces valeurs spéciales sont conçues de cette façon. En outre, l’implémentation suppose que MAX_EXPLICIT_LEVEL est impair.

Remarque : Les valeurs numériques des constantes associées ne changeront pas : elles sont liées à l’utilisation de valeurs d’octets 7 bits (plus le bit de remplacement) et du type de données d’octet dans cette API.

<b>Voir aussi :</b><ul><>#LEVEL_DEFAULT_LTR<li li>#LEVEL_DEFAULT_RTL<li li>#LEVEL_OVERRIDE<li>#MAX_EXPLICIT_LEVEL<>#setPara</ul>

<Concept de base h3>: Réorganiser le mode</h3> Les valeurs du mode de réorganisation indiquent quelle variante de l’algorithme Bidi à utiliser.

<b>Voir aussi :</b><ul><>#setReorderingMode<li>#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>

<Concept de base h3>: les options de réorganisation des options</h3> de réorganisation peuvent être appliquées pendant les transformations de texte Bidi.

<b>Voir aussi :</b><ul><>#setReorderingOptions<li li>#OPTION_DEFAULT<li li>#OPTION_INSERT_MARKS<li>#OPTION_REMOVE_CONTROLS<>#OPTION_STREAMING</ul>

<Exemple de code h4> pour l’API <Bidi de l’ICU /h4>

<h5>Rendu d’un paragraphe avec l’API< Bidi iCU/h5>

Il s’agit d’un exemple de code (hypothétique) qui illustre la façon dont l’API Bidi ICU peut être utilisée pour afficher un paragraphe de texte. Le code de rendu dépend fortement du système graphique, par conséquent cet exemple de code doit faire beaucoup d’hypothèses, qui peuvent ou ne pas correspondre aux propriétés du système graphique existant.

Les hypothèses de base sont les suivantes :

<ul><li>Rendering est effectué de gauche à droite sur une ligne horizontale.</li li><>Une série de texte unidirectionnel unique peut être rendue à la fois. </li li><>Une telle série de texte est passée au système graphique avec des caractères (unités de code) dans l’ordre logique.</li li><>L’algorithme cassant la ligne est très compliqué et dépendant des paramètres régionaux , et par conséquent son implémentation omise à partir de cet exemple de code.</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 documentation pour android.icu.text.Bidi.

Les parties de cette page sont des modifications basées sur le travail créé et partagé par Android Open Source et utilisées en fonction des termes décrits dans la 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.