/* * Copyright (c) 2000, 2003, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. Oracle designates this * particular file as subject to the "Classpath" exception as provided * by Oracle in the LICENSE file that accompanied this code. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */ /* * (C) Copyright IBM Corp. 1999-2000 - All Rights Reserved * * The original version of this source code and documentation is * copyrighted and owned by IBM. These materials are provided * under terms of a License Agreement between IBM and Sun. * This technology is protected by multiple US and International * patents. This notice and attribution to IBM may not be removed. */ package sun.font; import java.text.Bidi; public final class BidiUtils { /** * Return the level of each character into the levels array starting at start. * This is a convenience method for clients who prefer to use an explicit levels * array instead of iterating over the runs. * * @param levels the array to receive the character levels * @param start the starting offset into the the array * @throws IndexOutOfBoundsException if <code>start</code> is less than 0 or * <code>start + getLength()</code> is greater than <code>levels.length</code>. */ public static void getLevels(Bidi bidi, byte[] levels, int start) { int limit = start + bidi.getLength(); if (start < 0 || limit > levels.length) { throw new IndexOutOfBoundsException("levels.length = " + levels.length + " start: " + start + " limit: " + limit); } int runCount = bidi.getRunCount(); int p = start; for (int i = 0; i < runCount; ++i) { int rlimit = start + bidi.getRunLimit(i); byte rlevel = (byte)bidi.getRunLevel(i); while (p < rlimit) { levels[p++] = rlevel; } } } /** * Return an array containing the resolved bidi level of each character, in logical order. * @return an array containing the level of each character, in logical order. */ public static byte[] getLevels(Bidi bidi) { byte[] levels = new byte[bidi.getLength()]; getLevels(bidi, levels, 0); return levels; } static final char NUMLEVELS = 62; /** * Given level data, compute a a visual to logical mapping. * The leftmost (or topmost) character is at visual index zero. The * logical index of the character is derived from the visual index * by the expression <code>li = map[vi];</code>. * @param levels the levels array * @return the mapping array from visual to logical */ public static int[] createVisualToLogicalMap(byte[] levels) { int len = levels.length; int[] mapping = new int[len]; byte lowestOddLevel = (byte)(NUMLEVELS + 1); byte highestLevel = 0; // initialize mapping and levels for (int i = 0; i < len; i++) { mapping[i] = i; byte level = levels[i]; if (level > highestLevel) { highestLevel = level; } if ((level & 0x01) != 0 && level < lowestOddLevel) { lowestOddLevel = level; } } while (highestLevel >= lowestOddLevel) { int i = 0; for (;;) { while (i < len && levels[i] < highestLevel) { i++; } int begin = i++; if (begin == levels.length) { break; // no more runs at this level } while (i < len && levels[i] >= highestLevel) { i++; } int end = i - 1; while (begin < end) { int temp = mapping[begin]; mapping[begin] = mapping[end]; mapping[end] = temp; ++begin; --end; } } --highestLevel; } return mapping; } /** * Return the inverse position map. The source array must map one-to-one (each value * is distinct and the values run from zero to the length of the array minus one). * For example, if <code>values[i] = j</code>, then <code>inverse[j] = i</code>. * @param values the source ordering array * @return the inverse array */ public static int[] createInverseMap(int[] values) { if (values == null) { return null; } int[] result = new int[values.length]; for (int i = 0; i < values.length; i++) { result[values[i]] = i; } return result; } /** * Return an array containing contiguous values from 0 to length * having the same ordering as the source array. If this would be * a canonical ltr ordering, return null. The data in values[] is NOT * required to be a permutation, but elements in values are required * to be distinct. * @param values an array containing the discontiguous values * @return the contiguous values */ public static int[] createContiguousOrder(int[] values) { if (values != null) { return computeContiguousOrder(values, 0, values.length); } return null; } /** * Compute a contiguous order for the range start, limit. */ private static int[] computeContiguousOrder(int[] values, int start, int limit) { int[] result = new int[limit-start]; for (int i=0; i < result.length; i++) { result[i] = i + start; } // now we'll sort result[], with the following comparison: // result[i] lessthan result[j] iff values[result[i]] < values[result[j]] // selection sort for now; use more elaborate sorts if desired for (int i=0; i < result.length-1; i++) { int minIndex = i; int currentValue = values[result[minIndex]]; for (int j=i; j < result.length; j++) { if (values[result[j]] < currentValue) { minIndex = j; currentValue = values[result[minIndex]]; } } int temp = result[i]; result[i] = result[minIndex]; result[minIndex] = temp; } // shift result by start: if (start != 0) { for (int i=0; i < result.length; i++) { result[i] -= start; } } // next, check for canonical order: int k; for (k=0; k < result.length; k++) { if (result[k] != k) { break; } } if (k == result.length) { return null; } // now return inverse of result: return createInverseMap(result); } /** * Return an array containing the data in the values array from start up to limit, * normalized to fall within the range from 0 up to limit - start. * If this would be a canonical ltr ordering, return null. * NOTE: This method assumes that values[] is a logical to visual map * generated from levels[]. * @param values the source mapping * @param levels the levels corresponding to the values * @param start the starting offset in the values and levels arrays * @param limit the limiting offset in the values and levels arrays * @return the normlized map */ public static int[] createNormalizedMap(int[] values, byte[] levels, int start, int limit) { if (values != null) { if (start != 0 || limit != values.length) { // levels optimization boolean copyRange, canonical; byte primaryLevel; if (levels == null) { primaryLevel = (byte) 0x0; copyRange = true; canonical = true; } else { if (levels[start] == levels[limit-1]) { primaryLevel = levels[start]; canonical = (primaryLevel & (byte)0x1) == 0; // scan for levels below primary int i; for (i=start; i < limit; i++) { if (levels[i] < primaryLevel) { break; } if (canonical) { canonical = levels[i] == primaryLevel; } } copyRange = (i == limit); } else { copyRange = false; // these don't matter; but the compiler cares: primaryLevel = (byte) 0x0; canonical = false; } } if (copyRange) { if (canonical) { return null; } int[] result = new int[limit-start]; int baseValue; if ((primaryLevel & (byte)0x1) != 0) { baseValue = values[limit-1]; } else { baseValue = values[start]; } if (baseValue == 0) { System.arraycopy(values, start, result, 0, limit-start); } else { for (int j=0; j < result.length; j++) { result[j] = values[j+start] - baseValue; } } return result; } else { return computeContiguousOrder(values, start, limit); } } else { return values; } } return null; } /** * Reorder the objects in the array into visual order based on their levels. * This is a utility function to use when you have a collection of objects * representing runs of text in logical order, each run containing text * at a single level. The elements in the objects array will be reordered * into visual order assuming each run of text has the level provided * by the corresponding element in the levels array. * @param levels an array representing the bidi level of each object * @param objects the array of objects to be reordered into visual order */ public static void reorderVisually(byte[] levels, Object[] objects) { int len = levels.length; byte lowestOddLevel = (byte)(NUMLEVELS + 1); byte highestLevel = 0; // initialize mapping and levels for (int i = 0; i < len; i++) { byte level = levels[i]; if (level > highestLevel) { highestLevel = level; } if ((level & 0x01) != 0 && level < lowestOddLevel) { lowestOddLevel = level; } } while (highestLevel >= lowestOddLevel) { int i = 0; for (;;) { while (i < len && levels[i] < highestLevel) { i++; } int begin = i++; if (begin == levels.length) { break; // no more runs at this level } while (i < len && levels[i] >= highestLevel) { i++; } int end = i - 1; while (begin < end) { Object temp = objects[begin]; objects[begin] = objects[end]; objects[end] = temp; ++begin; --end; } } --highestLevel; } }}
/*
* Copyright (c) 2000, 2003, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/*
* (C) Copyright IBM Corp. 1999-2000 - All Rights Reserved
*
* The original version of this source code and documentation is
* copyrighted and owned by IBM. These materials are provided
* under terms of a License Agreement between IBM and Sun.
* This technology is protected by multiple US and International
* patents. This notice and attribution to IBM may not be removed.
*/
package sun.font;
import java.text.Bidi;
public final class BidiUtils {
/**
* Return the level of each character into the levels array starting at start.
* This is a convenience method for clients who prefer to use an explicit levels
* array instead of iterating over the runs.
*
* @param levels the array to receive the character levels
* @param start the starting offset into the the array
* @throws IndexOutOfBoundsException if <code>start</code> is less than 0 or
* <code>start + getLength()</code> is greater than <code>levels.length</code>.
*/
public static void getLevels(Bidi bidi, byte[] levels, int start) {
int limit = start + bidi.getLength();
if (start < 0 || limit > levels.length) {
throw new IndexOutOfBoundsException("levels.length = " + levels.length +
" start: " + start + " limit: " + limit);
}
int runCount = bidi.getRunCount();
int p = start;
for (int i = 0; i < runCount; ++i) {
int rlimit = start + bidi.getRunLimit(i);
byte rlevel = (byte)bidi.getRunLevel(i);
while (p < rlimit) {
levels[p++] = rlevel;
}
}
}
/**
* Return an array containing the resolved bidi level of each character, in logical order.
* @return an array containing the level of each character, in logical order.
*/
public static byte[] getLevels(Bidi bidi) {
byte[] levels = new byte[bidi.getLength()];
getLevels(bidi, levels, 0);
return levels;
}
static final char NUMLEVELS = 62;
/**
* Given level data, compute a a visual to logical mapping.
* The leftmost (or topmost) character is at visual index zero. The
* logical index of the character is derived from the visual index
* by the expression <code>li = map[vi];</code>.
* @param levels the levels array
* @return the mapping array from visual to logical
*/
public static int[] createVisualToLogicalMap(byte[] levels) {
int len = levels.length;
int[] mapping = new int[len];
byte lowestOddLevel = (byte)(NUMLEVELS + 1);
byte highestLevel = 0;
// initialize mapping and levels
for (int i = 0; i < len; i++) {
mapping[i] = i;
byte level = levels[i];
if (level > highestLevel) {
highestLevel = level;
}
if ((level & 0x01) != 0 && level < lowestOddLevel) {
lowestOddLevel = level;
}
}
while (highestLevel >= lowestOddLevel) {
int i = 0;
for (;;) {
while (i < len && levels[i] < highestLevel) {
i++;
}
int begin = i++;
if (begin == levels.length) {
break; // no more runs at this level
}
while (i < len && levels[i] >= highestLevel) {
i++;
}
int end = i - 1;
while (begin < end) {
int temp = mapping[begin];
mapping[begin] = mapping[end];
mapping[end] = temp;
++begin;
--end;
}
}
--highestLevel;
}
return mapping;
}
/**
* Return the inverse position map. The source array must map one-to-one (each value
* is distinct and the values run from zero to the length of the array minus one).
* For example, if <code>values[i] = j</code>, then <code>inverse[j] = i</code>.
* @param values the source ordering array
* @return the inverse array
*/
public static int[] createInverseMap(int[] values) {
if (values == null) {
return null;
}
int[] result = new int[values.length];
for (int i = 0; i < values.length; i++) {
result[values[i]] = i;
}
return result;
}
/**
* Return an array containing contiguous values from 0 to length
* having the same ordering as the source array. If this would be
* a canonical ltr ordering, return null. The data in values[] is NOT
* required to be a permutation, but elements in values are required
* to be distinct.
* @param values an array containing the discontiguous values
* @return the contiguous values
*/
public static int[] createContiguousOrder(int[] values) {
if (values != null) {
return computeContiguousOrder(values, 0, values.length);
}
return null;
}
/**
* Compute a contiguous order for the range start, limit.
*/
private static int[] computeContiguousOrder(int[] values, int start,
int limit) {
int[] result = new int[limit-start];
for (int i=0; i < result.length; i++) {
result[i] = i + start;
}
// now we'll sort result[], with the following comparison:
// result[i] lessthan result[j] iff values[result[i]] < values[result[j]]
// selection sort for now; use more elaborate sorts if desired
for (int i=0; i < result.length-1; i++) {
int minIndex = i;
int currentValue = values[result[minIndex]];
for (int j=i; j < result.length; j++) {
if (values[result[j]] < currentValue) {
minIndex = j;
currentValue = values[result[minIndex]];
}
}
int temp = result[i];
result[i] = result[minIndex];
result[minIndex] = temp;
}
// shift result by start:
if (start != 0) {
for (int i=0; i < result.length; i++) {
result[i] -= start;
}
}
// next, check for canonical order:
int k;
for (k=0; k < result.length; k++) {
if (result[k] != k) {
break;
}
}
if (k == result.length) {
return null;
}
// now return inverse of result:
return createInverseMap(result);
}
/**
* Return an array containing the data in the values array from start up to limit,
* normalized to fall within the range from 0 up to limit - start.
* If this would be a canonical ltr ordering, return null.
* NOTE: This method assumes that values[] is a logical to visual map
* generated from levels[].
* @param values the source mapping
* @param levels the levels corresponding to the values
* @param start the starting offset in the values and levels arrays
* @param limit the limiting offset in the values and levels arrays
* @return the normlized map
*/
public static int[] createNormalizedMap(int[] values, byte[] levels,
int start, int limit) {
if (values != null) {
if (start != 0 || limit != values.length) {
// levels optimization
boolean copyRange, canonical;
byte primaryLevel;
if (levels == null) {
primaryLevel = (byte) 0x0;
copyRange = true;
canonical = true;
}
else {
if (levels[start] == levels[limit-1]) {
primaryLevel = levels[start];
canonical = (primaryLevel & (byte)0x1) == 0;
// scan for levels below primary
int i;
for (i=start; i < limit; i++) {
if (levels[i] < primaryLevel) {
break;
}
if (canonical) {
canonical = levels[i] == primaryLevel;
}
}
copyRange = (i == limit);
}
else {
copyRange = false;
// these don't matter; but the compiler cares:
primaryLevel = (byte) 0x0;
canonical = false;
}
}
if (copyRange) {
if (canonical) {
return null;
}
int[] result = new int[limit-start];
int baseValue;
if ((primaryLevel & (byte)0x1) != 0) {
baseValue = values[limit-1];
} else {
baseValue = values[start];
}
if (baseValue == 0) {
System.arraycopy(values, start, result, 0, limit-start);
}
else {
for (int j=0; j < result.length; j++) {
result[j] = values[j+start] - baseValue;
}
}
return result;
}
else {
return computeContiguousOrder(values, start, limit);
}
}
else {
return values;
}
}
return null;
}
/**
* Reorder the objects in the array into visual order based on their levels.
* This is a utility function to use when you have a collection of objects
* representing runs of text in logical order, each run containing text
* at a single level. The elements in the objects array will be reordered
* into visual order assuming each run of text has the level provided
* by the corresponding element in the levels array.
* @param levels an array representing the bidi level of each object
* @param objects the array of objects to be reordered into visual order
*/
public static void reorderVisually(byte[] levels, Object[] objects) {
int len = levels.length;
byte lowestOddLevel = (byte)(NUMLEVELS + 1);
byte highestLevel = 0;
// initialize mapping and levels
for (int i = 0; i < len; i++) {
byte level = levels[i];
if (level > highestLevel) {
highestLevel = level;
}
if ((level & 0x01) != 0 && level < lowestOddLevel) {
lowestOddLevel = level;
}
}
while (highestLevel >= lowestOddLevel) {
int i = 0;
for (;;) {
while (i < len && levels[i] < highestLevel) {
i++;
}
int begin = i++;
if (begin == levels.length) {
break; // no more runs at this level
}
while (i < len && levels[i] >= highestLevel) {
i++;
}
int end = i - 1;
while (begin < end) {
Object temp = objects[begin];
objects[begin] = objects[end];
objects[end] = temp;
++begin;
--end;
}
}
--highestLevel;
}
}
}