1 /* 2 * Copyright (C) 2010 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package android.text; 18 19 import android.text.Layout.Directions; 20 21 /** 22 * Access the ICU bidi implementation. 23 * @hide 24 */ 25 /* package */ class AndroidBidi { 26 bidi(int dir, char[] chs, byte[] chInfo, int n, boolean haveInfo)27 public static int bidi(int dir, char[] chs, byte[] chInfo, int n, boolean haveInfo) { 28 if (chs == null || chInfo == null) { 29 throw new NullPointerException(); 30 } 31 32 if (n < 0 || chs.length < n || chInfo.length < n) { 33 throw new IndexOutOfBoundsException(); 34 } 35 36 switch(dir) { 37 case Layout.DIR_REQUEST_LTR: dir = 0; break; 38 case Layout.DIR_REQUEST_RTL: dir = 1; break; 39 case Layout.DIR_REQUEST_DEFAULT_LTR: dir = -2; break; 40 case Layout.DIR_REQUEST_DEFAULT_RTL: dir = -1; break; 41 default: dir = 0; break; 42 } 43 44 int result = runBidi(dir, chs, chInfo, n, haveInfo); 45 result = (result & 0x1) == 0 ? Layout.DIR_LEFT_TO_RIGHT : Layout.DIR_RIGHT_TO_LEFT; 46 return result; 47 } 48 49 /** 50 * Returns run direction information for a line within a paragraph. 51 * 52 * @param dir base line direction, either Layout.DIR_LEFT_TO_RIGHT or 53 * Layout.DIR_RIGHT_TO_LEFT 54 * @param levels levels as returned from {@link #bidi} 55 * @param lstart start of the line in the levels array 56 * @param chars the character array (used to determine whitespace) 57 * @param cstart the start of the line in the chars array 58 * @param len the length of the line 59 * @return the directions 60 */ directions(int dir, byte[] levels, int lstart, char[] chars, int cstart, int len)61 public static Directions directions(int dir, byte[] levels, int lstart, 62 char[] chars, int cstart, int len) { 63 if (len == 0) { 64 return Layout.DIRS_ALL_LEFT_TO_RIGHT; 65 } 66 67 int baseLevel = dir == Layout.DIR_LEFT_TO_RIGHT ? 0 : 1; 68 int curLevel = levels[lstart]; 69 int minLevel = curLevel; 70 int runCount = 1; 71 for (int i = lstart + 1, e = lstart + len; i < e; ++i) { 72 int level = levels[i]; 73 if (level != curLevel) { 74 curLevel = level; 75 ++runCount; 76 } 77 } 78 79 // add final run for trailing counter-directional whitespace 80 int visLen = len; 81 if ((curLevel & 1) != (baseLevel & 1)) { 82 // look for visible end 83 while (--visLen >= 0) { 84 char ch = chars[cstart + visLen]; 85 86 if (ch == '\n') { 87 --visLen; 88 break; 89 } 90 91 if (ch != ' ' && ch != '\t') { 92 break; 93 } 94 } 95 ++visLen; 96 if (visLen != len) { 97 ++runCount; 98 } 99 } 100 101 if (runCount == 1 && minLevel == baseLevel) { 102 // we're done, only one run on this line 103 if ((minLevel & 1) != 0) { 104 return Layout.DIRS_ALL_RIGHT_TO_LEFT; 105 } 106 return Layout.DIRS_ALL_LEFT_TO_RIGHT; 107 } 108 109 int[] ld = new int[runCount * 2]; 110 int maxLevel = minLevel; 111 int levelBits = minLevel << Layout.RUN_LEVEL_SHIFT; 112 { 113 // Start of first pair is always 0, we write 114 // length then start at each new run, and the 115 // last run length after we're done. 116 int n = 1; 117 int prev = lstart; 118 curLevel = minLevel; 119 for (int i = lstart, e = lstart + visLen; i < e; ++i) { 120 int level = levels[i]; 121 if (level != curLevel) { 122 curLevel = level; 123 if (level > maxLevel) { 124 maxLevel = level; 125 } else if (level < minLevel) { 126 minLevel = level; 127 } 128 // XXX ignore run length limit of 2^RUN_LEVEL_SHIFT 129 ld[n++] = (i - prev) | levelBits; 130 ld[n++] = i - lstart; 131 levelBits = curLevel << Layout.RUN_LEVEL_SHIFT; 132 prev = i; 133 } 134 } 135 ld[n] = (lstart + visLen - prev) | levelBits; 136 if (visLen < len) { 137 ld[++n] = visLen; 138 ld[++n] = (len - visLen) | (baseLevel << Layout.RUN_LEVEL_SHIFT); 139 } 140 } 141 142 // See if we need to swap any runs. 143 // If the min level run direction doesn't match the base 144 // direction, we always need to swap (at this point 145 // we have more than one run). 146 // Otherwise, we don't need to swap the lowest level. 147 // Since there are no logically adjacent runs at the same 148 // level, if the max level is the same as the (new) min 149 // level, we have a series of alternating levels that 150 // is already in order, so there's no more to do. 151 // 152 boolean swap; 153 if ((minLevel & 1) == baseLevel) { 154 minLevel += 1; 155 swap = maxLevel > minLevel; 156 } else { 157 swap = runCount > 1; 158 } 159 if (swap) { 160 for (int level = maxLevel - 1; level >= minLevel; --level) { 161 for (int i = 0; i < ld.length; i += 2) { 162 if (levels[ld[i]] >= level) { 163 int e = i + 2; 164 while (e < ld.length && levels[ld[e]] >= level) { 165 e += 2; 166 } 167 for (int low = i, hi = e - 2; low < hi; low += 2, hi -= 2) { 168 int x = ld[low]; ld[low] = ld[hi]; ld[hi] = x; 169 x = ld[low+1]; ld[low+1] = ld[hi+1]; ld[hi+1] = x; 170 } 171 i = e + 2; 172 } 173 } 174 } 175 } 176 return new Directions(ld); 177 } 178 runBidi(int dir, char[] chs, byte[] chInfo, int n, boolean haveInfo)179 private native static int runBidi(int dir, char[] chs, byte[] chInfo, int n, boolean haveInfo); 180 }