Bidi クラス

定義

        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

継承

Object

JavaObject

Object

Bidi

属性

RegisterAttribute

注釈

<h2> ICU のBidi アルゴリズム</h2>

これは、Unicode 双方向アルゴリズムの実装です。 このアルゴリズムは Unicode 標準付属書 #9 で定義されています。

注: 双方向アルゴリズムを実行し、それに応じて文字列を並べ替えるライブラリは、"ストレージ レイアウト エンジン" と呼ばれることがあります。 ICU の Bidi とシェイプ (ArabicShaping) クラスは、このような "ストレージ レイアウト エンジン" の中核として使用できます。

<h3> API:</h3 に関する一般的な解説>

次の値を使用します。limit>一連の文字は、最後の文字の直後の位置(つまり、その位置より 1 つ多い位置)です。

API メソッドの中には、> へのアクセスを提供するものもあります。runs>. このような >run>は、Bidi アルゴリズムの実行後に同じ埋め込みレベルにある文字のシーケンスとして定義されます。

<h3>Basic concept: paragraph</h3> テキストの一部は、Bidi クラスの Block Separatorを使用して文字ごとに複数の段落に分割できます。 段落の処理については、「 <ul><li>#countParagraphs<li>#getParaLevel<li>#getParagraph<li>#getParagraphByIndex</ul」を参照してください。>

<h3>Basic concept: text direction</h3> テキストの方向は、<ul><li>#LTR<>#RTL<li>#MIXED<li>#NEUTRAL</ul です。>

<h3>基本概念: levels</h3>

この API のレベルは、Unicode 双方向アルゴリズムに従った埋め込みレベルを表します。 それらの下位ビット (偶数/奇数値) は、視覚的な方向を示します。

レベルは、paraLevelのembeddingLevels引数とsetPara()引数に使用する場合に抽象値にすることができます。<ul><li>embeddingLevels[]値の上位ビットは、Using アプリケーションが、Bidi 実装で解決される文字のレベルをオーバーライドする文字のレベルを指定しているかどうかを示します。</li><li>paraLevel は擬似レベルの値LEVEL_DEFAULT_LTRに設定でき、LEVEL_DEFAULT_RTL.</li></ul>

関連する定数は、実際の有効なレベル値ではありません。 DEFAULT_XXX を使用すると、 setPara() メソッドによって決定されるが、入力に厳密に型指定された文字がない場合に、段落レベルの既定値を指定できます。

LEVEL_DEFAULT_LTRの値は偶数であり、通常の LTR および RTL レベルの値と同様に、LEVEL_DEFAULT_RTLの値は奇数であることに注意してください。これらの特別な値はそのように設計されています。 また、実装では、MAX_EXPLICIT_LEVELが奇数であることを前提としています。

注: 関連定数の数値は変更されません。これらは、7 ビットバイト値 (およびオーバーライド ビット) と、この API のバイト データ型の使用に関連付けられています。

<b>See Also:</b><ul><li>#LEVEL_DEFAULT_LTR<li>#LEVEL_DEFAULT_RTL<li>#LEVEL_OVERRIDE<li>#MAX_EXPLICIT_LEVEL<li>#setPara</ul>

<h3>基本概念: 並べ替えモード</h3> 並べ替えモードの値は、使用する Bidi アルゴリズムのバリアントを示します。

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

<h3>基本概念: 並べ替えオプション</h3> 並べ替えオプションは、Bidi テキスト変換中に適用できます。

<b>See Also:</b><ul><li>#setReorderingOptions<li>#OPTION_DEFAULT<li>#OPTION_INSERT_MARKS<li>#OPTION_REMOVE_CONTROLS<li>#OPTION_STREAMING</ul>

<h4> ICU Bidi API </h4 のサンプル コード>

<h5> ICU Bidi API を使用して段落をレンダリングする</h5>

これは、ICU Bidi API を使用してテキストの段落をレンダリングする方法を示す (仮定の) サンプル コードです。 レンダリング コードはグラフィックス システムに大きく依存するため、このサンプル コードでは、既存のグラフィックス システムのプロパティと一致する場合と一致しない可能性がある多くの前提条件を満たす必要があります。

基本的な前提条件は次のとおりです。

<ul><li>水平線で左から右にレンダリングが行われます。</li><li>単一スタイルの一方向テキストの実行を一度にレンダリングできます。 </li><li>テキストの実行が論理順序で文字 (コード単位) でグラフィックス システムに渡されます</li><li>改行アルゴリズムは非常に複雑でロケールに依存するため、このサンプル コードでは実装を省略しています</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ドキュメント。

このページの一部は、によって作成および共有され、に記載されている条件に従って使用される作業に基づく変更です。

        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.