Java tutorial
/* * 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.complexscripts.bidi; import java.util.Iterator; import java.util.List; import java.util.Vector; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.apache.fop.fo.CharIterator; import org.apache.fop.fo.FONode; import org.apache.fop.fo.FObj; import org.apache.fop.traits.Direction; import org.apache.fop.traits.WritingModeTraits; import org.apache.fop.traits.WritingModeTraitsGetter; import org.apache.fop.util.CharUtilities; // CSOFF: EmptyForIteratorPadCheck // CSOFF: InnerAssignmentCheck // CSOFF: LineLengthCheck // CSOFF: NoWhitespaceAfterCheck /** * The <code>DelimitedTextRange</code> class implements the "delimited text range" as described * by XML-FO 1.1 5.8, which contains a flattened sequence of characters. Any FO that generates * block areas serves as a delimiter. * * <p>This work was originally authored by Glenn Adams (gadams@apache.org).</p> */ public class DelimitedTextRange { private FONode fn; // node that generates this text range private StringBuffer buffer; // flattened character sequence of generating FO nodes private List intervals; // list of intervals over buffer of generating FO nodes /** * Primary constructor. * @param fn node that generates this text range */ public DelimitedTextRange(FONode fn) { this.fn = fn; this.buffer = new StringBuffer(); this.intervals = new Vector(); } /** * Obtain node that generated this text range. * @return node that generated this text range */ public FONode getNode() { return fn; } /** * Append interval using characters from character iterator IT. * @param it character iterator * @param fn node that generates interval being appended */ public void append(CharIterator it, FONode fn) { if (it != null) { int s = buffer.length(); int e = s; while (it.hasNext()) { char c = it.nextChar(); buffer.append(c); e++; } intervals.add(new TextInterval(fn, s, e)); } } /** * Append interval using character C. * @param c character * @param fn node that generates interval being appended */ public void append(char c, FONode fn) { if (c != 0) { int s = buffer.length(); int e = s + 1; buffer.append(c); intervals.add(new TextInterval(fn, s, e)); } } /** * Determine if range is empty. * @return true if range is empty */ public boolean isEmpty() { return buffer.length() == 0; } /** * Resolve bidirectional levels for this range. */ public void resolve() { WritingModeTraitsGetter tg; if ((tg = WritingModeTraits.getWritingModeTraitsGetter(getNode())) != null) { resolve(tg.getInlineProgressionDirection()); } } @Override public String toString() { StringBuffer sb = new StringBuffer( "DR: " + fn.getLocalName() + " { <" + CharUtilities.toNCRefs(buffer.toString()) + ">"); sb.append(", intervals <"); boolean first = true; for (Iterator it = intervals.iterator(); it.hasNext();) { TextInterval ti = (TextInterval) it.next(); if (first) { first = false; } else { sb.append(','); } sb.append(ti.toString()); } sb.append("> }"); return sb.toString(); } private void resolve(Direction paragraphEmbeddingLevel) { int[] levels; if ((levels = UnicodeBidiAlgorithm.resolveLevels(buffer, paragraphEmbeddingLevel)) != null) { assignLevels(levels); assignBlockLevel(paragraphEmbeddingLevel); assignTextLevels(); } } /** * <p>Assign resolved levels to all text intervals of this delimited text range.</p> * <p>Has a possible side effect of replacing the intervals array with a new array * containing new text intervals, such that each text interval is associated with * a single level run.</p> * @param levels array of levels each corresponding to each index of the delimited * text range */ private void assignLevels(int[] levels) { Vector intervalsNew = new Vector(intervals.size()); for (Iterator it = intervals.iterator(); it.hasNext();) { TextInterval ti = (TextInterval) it.next(); intervalsNew.addAll(assignLevels(ti, levels)); } if (!intervalsNew.equals(intervals)) { intervals = intervalsNew; } } /** * <p>Assign resolved levels to a specified text interval over this delimited text * range.</p> * <p>Returns a list of text intervals containing either (1) the single, input text * interval or (2) two or more new text intervals obtained from sub-dividing the input * text range into level runs, i.e., runs of text assigned to a single level.</p> * @param ti a text interval to which levels are to be assigned * @param levels array of levels each corresponding to each index of the delimited * text range * @return a list of text intervals as described above */ private static final Log log = LogFactory.getLog(BidiResolver.class); // CSOK: ConstantNameCheck private List assignLevels(TextInterval ti, int[] levels) { Vector tiv = new Vector(); FONode fn = ti.getNode(); int fnStart = ti.getStart(); // start of node's text in delimited text range for (int i = fnStart, n = ti.getEnd(); i < n;) { int s = i; // inclusive start index of interval in delimited text range int e = s; // exclusive end index of interval in delimited text range int l = levels[s]; // current run level while (e < n) { // skip to end of run level or end of interval if (levels[e] != l) { break; } else { e++; } } if ((ti.getStart() == s) && (ti.getEnd() == e)) { ti.setLevel(l); // reuse interval, assigning it single level } else { ti = new TextInterval(fn, fnStart, s, e, l); // subdivide interval } if (log.isDebugEnabled()) { log.debug("AL(" + l + "): " + ti); } tiv.add(ti); i = e; } return tiv; } /** * <p>Assign resolved levels for each interval to source #PCDATA in the associated FOText.</p> */ private void assignTextLevels() { for (Iterator it = intervals.iterator(); it.hasNext();) { TextInterval ti = (TextInterval) it.next(); ti.assignTextLevels(); } } private void assignBlockLevel(Direction paragraphEmbeddingLevel) { int defaultLevel = (paragraphEmbeddingLevel == Direction.RL) ? 1 : 0; for (Iterator it = intervals.iterator(); it.hasNext();) { TextInterval ti = (TextInterval) it.next(); assignBlockLevel(ti.getNode(), defaultLevel); } } private void assignBlockLevel(FONode node, int defaultLevel) { for (FONode fn = node; fn != null; fn = fn.getParent()) { if (fn instanceof FObj) { FObj fo = (FObj) fn; if (fo.isBidiRangeBlockItem()) { if (fo.getBidiLevel() < 0) { fo.setBidiLevel(defaultLevel); } break; } } } } }