fop-core/src/main/java/org/apache/fop/area/inline/WordArea.java - xmlgraphics-fop - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 /* $Id$ */

 package org.apache.fop.area.inline;

 import java.util.Arrays;
 import java.util.List;

 import org.apache.fop.complexscripts.bidi.InlineRun;
 import org.apache.fop.complexscripts.util.CharMirror;

 /**
  * A string of characters without spaces
  */
 public class WordArea extends InlineArea {

     private static final long serialVersionUID = 6444644662158970942L;

     /** The text for this word area */
     protected String word;

     /** An array of width for adjusting the individual letters (optional) */
     protected int[] letterAdjust;

     /**
      * An array of resolved bidirectional levels corresponding to each character
      * in word (optional)
      */
     protected int[] levels;

     /**
      * An array of glyph positioning adjustments to apply to each glyph 'char' in word (optional)
      */
     protected int[][] gposAdjustments;

     /**
      * A flag indicating whether the content of word is reversed in relation to
      * its original logical order.
      */
     protected boolean reversed;
     private boolean nextIsSpace;

     /**
      * Create a word area
      * @param blockProgressionOffset the offset for this area
      * @param level the bidirectional embedding level (or -1 if not defined) for word as a group
      * @param word the word string
      * @param letterAdjust the letter adjust array (may be null)
      * @param levels array of per-character (glyph) bidirectional levels,
      * in case word area is heterogenously leveled
      * @param gposAdjustments array of general position adjustments or null if none apply
      * @param reversed true if word is known to be reversed at construction time
      */
     public WordArea(int blockProgressionOffset, int level, String word, int[] letterAdjust, int[] levels,
           int[][] gposAdjustments, boolean reversed, boolean nextIsSpace) {
         super(blockProgressionOffset, level);
         int length = (word != null) ? word.length() : 0;
         this.word = word;
         this.letterAdjust = maybeAdjustLength(letterAdjust, length);
         this.levels = maybePopulateLevels(levels, level, length);
         this.gposAdjustments = maybeAdjustLength(gposAdjustments, length);
         this.reversed = reversed;
         this.nextIsSpace = nextIsSpace;
     }

     public WordArea(int blockProgressionOffset, int level, String word, int[] letterAdjust, int[] levels,
             int[][] gposAdjustments, boolean reversed) {
         this(blockProgressionOffset, level, word, letterAdjust, levels, gposAdjustments, reversed, false);
     }

     /**
      * Create a word area
      * @param blockProgressionOffset the offset for this area
      * @param level the bidirectional embedding level (or -1 if not defined) for word as a group
      * @param word the word string
      * @param letterAdjust the letter adjust array (may be null)
      * @param levels array of per-character (glyph) bidirectional levels,
      * in case word area is heterogenously leveled
      * @param gposAdjustments array of general position adjustments or null if none apply
      */
     public WordArea(
     int blockProgressionOffset, int level, String word, int[] letterAdjust, int[] levels,
       int[][] gposAdjustments) {
         this (blockProgressionOffset, level, word, letterAdjust, levels, gposAdjustments, false);
     }

     /** @return Returns the word. */
     public String getWord() {
         return word;
     }

     /** @return the array of letter adjust widths */
     public int[] getLetterAdjustArray() {
         return this.letterAdjust;
     }

     /**
      * Obtain per-character (glyph) bidi levels.
      * @return a (possibly empty) array of levels or null (if none resolved)
      */
     public int[] getBidiLevels() {
         return levels;
     }

     /**
      * <p>Obtain per-character (glyph) bidi levels over a specified subsequence.</p>
      * <p>If word has been reversed, then the subsequence is over the reversed word.</p>
      * @param start starting (inclusive) index of subsequence
      * @param end ending (exclusive) index of subsequence
      * @return a (possibly null) array of per-character (glyph) levels over the specified
      * sequence
      */
     public int[] getBidiLevels(int start, int end) {
         assert start <= end;
         if (this.levels != null) {
             int n = end - start;
             int[] levels = new int [ n ];
             System.arraycopy(this.levels, start + 0, levels, 0, n);
             return levels;
         } else {
             return null;
         }
     }

     /**
      * <p>Obtain per-character (glyph) level at a specified index position.</p>
      * <p>If word has been reversed, then the position is relative to the reversed word.</p>
      * @param position the index of the (possibly reversed) character from which to obtain the
      * level
      * @return a resolved bidirectional level or, if not specified, then -1
      */
     public int bidiLevelAt(int position) {
         if (position > word.length()) {
             throw new IndexOutOfBoundsException();
         } else if (levels != null) {
             return levels [ position ];
         } else {
             return -1;
         }
     }

     @Override
     public List collectInlineRuns(List runs) {
         assert runs != null;
         InlineRun r;
         int[] levels = getBidiLevels();
         if ((levels != null) && (levels.length > 0)) {
             r = new InlineRun(this, levels);
         } else {
             r = new InlineRun(this, getBidiLevel(), word.length());
         }
         runs.add(r);
         return runs;
     }

     /**
      * Obtain per-character (glyph) position adjustments.
      * @return a (possibly empty) array of adjustments, each having four elements, or null
      * if no adjustments apply
      */
     public int[][] getGlyphPositionAdjustments() {
         return gposAdjustments;
     }

     /**
      * <p>Obtain per-character (glyph) position adjustments at a specified index position.</p>
      * <p>If word has been reversed, then the position is relative to the reversed word.</p>
      * @param position the index of the (possibly reversed) character from which to obtain the
      * level
      * @return an array of adjustments or null if none applies
      */
     public int[] glyphPositionAdjustmentsAt(int position) {
         if (position > word.length()) {
             throw new IndexOutOfBoundsException();
         } else if (gposAdjustments != null) {
             return gposAdjustments [ position ];
         } else {
             return null;
         }
     }

     /**
      * <p>Reverse characters and corresponding per-character levels and glyph position
      * adjustments.</p>
      * @param mirror if true, then perform mirroring if mirrorred characters
      */
     public void reverse(boolean mirror) {
         if (word.length() > 0) {
             word = ((new StringBuffer(word)) .reverse()) .toString();
             if (levels != null) {
                 reverse(levels);
             }
             if (gposAdjustments != null) {
                 reverse(gposAdjustments);
             }
             reversed = !reversed;
             if (mirror) {
                 word = CharMirror.mirror(word);
             }
         }
     }

     /**
      * <p>Perform mirroring on mirrorable characters.</p>
      */
     public void mirror() {
         if (word.length() > 0) {
             word = CharMirror.mirror(word);
         }
     }

     /**
      * <p>Determined if word has been reversed (in relation to original logical order).</p>
      * <p>If a word is reversed, then both its characters (glyphs) and corresponding per-character
      * levels are in reverse order.</p>
      * <p>Note: this information is used in order to process non-spacing marks during rendering as
      * well as provide hints for caret direction.</p>
      * @return true if word is reversed
      */
     public boolean isReversed() {
         return reversed;
     }

     public boolean isNextIsSpace() {
         return nextIsSpace;
     }

     /*
      * If int[] array is not of specified length, then create
      * a new copy of the first length entries.
      */
     private static int[] maybeAdjustLength(int[] ia, int length) {
         if (ia != null) {
             if (ia.length == length) {
                 return ia;
             } else {
                 int[] iaNew = new int [ length ];
                 for (int i = 0, n = ia.length; i < n; i++) {
                     if (i < length) {
                         iaNew [ i ] = ia [ i ];
                     } else {
                         break;
                     }
                 }
                 return iaNew;
             }
         } else {
             return ia;
         }
     }

     /*
      * If int[][] matrix is not of specified length, then create
      * a new shallow copy of the first length entries.
      */
     private static int[][] maybeAdjustLength(int[][] im, int length) {
         if (im != null) {
             if (im.length == length) {
                 return im;
             } else {
                 int[][] imNew = new int [ length ][];
                 for (int i = 0, n = im.length; i < n; i++) {
                     if (i < length) {
                         imNew [ i ] = im [ i ];
                     } else {
                         break;
                     }
                 }
                 return imNew;
             }
         } else {
             return im;
         }
     }

     private static int[] maybePopulateLevels(int[] levels, int level, int count) {
         if ((levels == null) && (level >= 0)) {
             levels = new int[count];
             Arrays.fill(levels, level);
         }
         return maybeAdjustLength(levels, count);
     }

     private static void reverse(int[] a) {
         for (int i = 0, n = a.length, m = n / 2; i < m; i++) {
             int k = n - i - 1;
             int t = a [ k ];
             a [ k ] = a [ i ];
             a [ i ] = t;
         }
     }

     private static void reverse(int[][] aa) {
         for (int i = 0, n = aa.length, m = n / 2; i < m; i++) {
             int k = n - i - 1;
             int[] t = aa [ k ];
             aa [ k ] = aa [ i ];
             aa [ i ] = t;
         }
     }

 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	/* $Id$ */

	package org.apache.fop.area.inline;

	import java.util.Arrays;
	import java.util.List;

	import org.apache.fop.complexscripts.bidi.InlineRun;
	import org.apache.fop.complexscripts.util.CharMirror;

	/**
	* A string of characters without spaces
	*/
	public class WordArea extends InlineArea {

	private static final long serialVersionUID = 6444644662158970942L;

	/** The text for this word area */
	protected String word;

	/** An array of width for adjusting the individual letters (optional) */
	protected int[] letterAdjust;

	/**
	* An array of resolved bidirectional levels corresponding to each character
	* in word (optional)
	*/
	protected int[] levels;

	/**
	* An array of glyph positioning adjustments to apply to each glyph 'char' in word (optional)
	*/
	protected int[][] gposAdjustments;

	/**
	* A flag indicating whether the content of word is reversed in relation to
	* its original logical order.
	*/
	protected boolean reversed;
	private boolean nextIsSpace;

	/**
	* Create a word area
	* @param blockProgressionOffset the offset for this area
	* @param level the bidirectional embedding level (or -1 if not defined) for word as a group
	* @param word the word string
	* @param letterAdjust the letter adjust array (may be null)
	* @param levels array of per-character (glyph) bidirectional levels,
	* in case word area is heterogenously leveled
	* @param gposAdjustments array of general position adjustments or null if none apply
	* @param reversed true if word is known to be reversed at construction time
	*/
	public WordArea(int blockProgressionOffset, int level, String word, int[] letterAdjust, int[] levels,
	int[][] gposAdjustments, boolean reversed, boolean nextIsSpace) {
	super(blockProgressionOffset, level);
	int length = (word != null) ? word.length() : 0;
	this.word = word;
	this.letterAdjust = maybeAdjustLength(letterAdjust, length);
	this.levels = maybePopulateLevels(levels, level, length);
	this.gposAdjustments = maybeAdjustLength(gposAdjustments, length);
	this.reversed = reversed;
	this.nextIsSpace = nextIsSpace;
	}

	public WordArea(int blockProgressionOffset, int level, String word, int[] letterAdjust, int[] levels,
	int[][] gposAdjustments, boolean reversed) {
	this(blockProgressionOffset, level, word, letterAdjust, levels, gposAdjustments, reversed, false);
	}

	/**
	* Create a word area
	* @param blockProgressionOffset the offset for this area
	* @param level the bidirectional embedding level (or -1 if not defined) for word as a group
	* @param word the word string
	* @param letterAdjust the letter adjust array (may be null)
	* @param levels array of per-character (glyph) bidirectional levels,
	* in case word area is heterogenously leveled
	* @param gposAdjustments array of general position adjustments or null if none apply
	*/
	public WordArea(
	int blockProgressionOffset, int level, String word, int[] letterAdjust, int[] levels,
	int[][] gposAdjustments) {
	this (blockProgressionOffset, level, word, letterAdjust, levels, gposAdjustments, false);
	}

	/** @return Returns the word. */
	public String getWord() {
	return word;
	}

	/** @return the array of letter adjust widths */
	public int[] getLetterAdjustArray() {
	return this.letterAdjust;
	}

	/**
	* Obtain per-character (glyph) bidi levels.
	* @return a (possibly empty) array of levels or null (if none resolved)
	*/
	public int[] getBidiLevels() {
	return levels;
	}

	/**
	* <p>Obtain per-character (glyph) bidi levels over a specified subsequence.</p>
	* <p>If word has been reversed, then the subsequence is over the reversed word.</p>
	* @param start starting (inclusive) index of subsequence
	* @param end ending (exclusive) index of subsequence
	* @return a (possibly null) array of per-character (glyph) levels over the specified
	* sequence
	*/
	public int[] getBidiLevels(int start, int end) {
	assert start <= end;
	if (this.levels != null) {
	int n = end - start;
	int[] levels = new int [ n ];
	System.arraycopy(this.levels, start + 0, levels, 0, n);
	return levels;
	} else {
	return null;
	}
	}

	/**
	* <p>Obtain per-character (glyph) level at a specified index position.</p>
	* <p>If word has been reversed, then the position is relative to the reversed word.</p>
	* @param position the index of the (possibly reversed) character from which to obtain the
	* level
	* @return a resolved bidirectional level or, if not specified, then -1
	*/
	public int bidiLevelAt(int position) {
	if (position > word.length()) {
	throw new IndexOutOfBoundsException();
	} else if (levels != null) {
	return levels [ position ];
	} else {
	return -1;
	}
	}

	@Override
	public List collectInlineRuns(List runs) {
	assert runs != null;
	InlineRun r;
	int[] levels = getBidiLevels();
	if ((levels != null) && (levels.length > 0)) {
	r = new InlineRun(this, levels);
	} else {
	r = new InlineRun(this, getBidiLevel(), word.length());
	}
	runs.add(r);
	return runs;
	}

	/**
	* Obtain per-character (glyph) position adjustments.
	* @return a (possibly empty) array of adjustments, each having four elements, or null
	* if no adjustments apply
	*/
	public int[][] getGlyphPositionAdjustments() {
	return gposAdjustments;
	}

	/**
	* <p>Obtain per-character (glyph) position adjustments at a specified index position.</p>
	* <p>If word has been reversed, then the position is relative to the reversed word.</p>
	* @param position the index of the (possibly reversed) character from which to obtain the
	* level
	* @return an array of adjustments or null if none applies
	*/
	public int[] glyphPositionAdjustmentsAt(int position) {
	if (position > word.length()) {
	throw new IndexOutOfBoundsException();
	} else if (gposAdjustments != null) {
	return gposAdjustments [ position ];
	} else {
	return null;
	}
	}

	/**
	* <p>Reverse characters and corresponding per-character levels and glyph position
	* adjustments.</p>
	* @param mirror if true, then perform mirroring if mirrorred characters
	*/
	public void reverse(boolean mirror) {
	if (word.length() > 0) {
	word = ((new StringBuffer(word)) .reverse()) .toString();
	if (levels != null) {
	reverse(levels);
	}
	if (gposAdjustments != null) {
	reverse(gposAdjustments);
	}
	reversed = !reversed;
	if (mirror) {
	word = CharMirror.mirror(word);
	}
	}
	}

	/**
	* <p>Perform mirroring on mirrorable characters.</p>
	*/
	public void mirror() {
	if (word.length() > 0) {
	word = CharMirror.mirror(word);
	}
	}

	/**
	* <p>Determined if word has been reversed (in relation to original logical order).</p>
	* <p>If a word is reversed, then both its characters (glyphs) and corresponding per-character
	* levels are in reverse order.</p>
	* <p>Note: this information is used in order to process non-spacing marks during rendering as
	* well as provide hints for caret direction.</p>
	* @return true if word is reversed
	*/
	public boolean isReversed() {
	return reversed;
	}

	public boolean isNextIsSpace() {
	return nextIsSpace;
	}

	/*
	* If int[] array is not of specified length, then create
	* a new copy of the first length entries.
	*/
	private static int[] maybeAdjustLength(int[] ia, int length) {
	if (ia != null) {
	if (ia.length == length) {
	return ia;
	} else {
	int[] iaNew = new int [ length ];
	for (int i = 0, n = ia.length; i < n; i++) {
	if (i < length) {
	iaNew [ i ] = ia [ i ];
	} else {
	break;
	}
	}
	return iaNew;
	}
	} else {
	return ia;
	}
	}

	/*
	* If int[][] matrix is not of specified length, then create
	* a new shallow copy of the first length entries.
	*/
	private static int[][] maybeAdjustLength(int[][] im, int length) {
	if (im != null) {
	if (im.length == length) {
	return im;
	} else {
	int[][] imNew = new int [ length ][];
	for (int i = 0, n = im.length; i < n; i++) {
	if (i < length) {
	imNew [ i ] = im [ i ];
	} else {
	break;
	}
	}
	return imNew;
	}
	} else {
	return im;
	}
	}

	private static int[] maybePopulateLevels(int[] levels, int level, int count) {
	if ((levels == null) && (level >= 0)) {
	levels = new int[count];
	Arrays.fill(levels, level);
	}
	return maybeAdjustLength(levels, count);
	}

	private static void reverse(int[] a) {
	for (int i = 0, n = a.length, m = n / 2; i < m; i++) {
	int k = n - i - 1;
	int t = a [ k ];
	a [ k ] = a [ i ];
	a [ i ] = t;
	}
	}

	private static void reverse(int[][] aa) {
	for (int i = 0, n = aa.length, m = n / 2; i < m; i++) {
	int k = n - i - 1;
	int[] t = aa [ k ];
	aa [ k ] = aa [ i ];
	aa [ i ] = t;
	}
	}

	}