Back to index...

	/*
	* 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;
	}
	}
	}

Back to index...