src/java/org/apache/fop/layoutmgr/inline/LineLayoutPossibilities.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.layoutmgr.inline;

 import java.util.List;

 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;

 /**
  * Line layout possibilities.
  */
 public class LineLayoutPossibilities {

     /** logger instance */
     private static final Log LOG = LogFactory.getLog(LineLayoutPossibilities.class);

     private final class Possibility {
         private int lineCount;
         private double demerits;
         private List<LineLayoutManager.LineBreakPosition> breakPositions;

         private Possibility(int lc, double dem) {
             lineCount = lc;
             demerits = dem;
             breakPositions = new java.util.ArrayList<LineLayoutManager.LineBreakPosition>(lc);
         }

         private int getLineCount() {
             return lineCount;
         }

         private double getDemerits() {
             return demerits;
         }

         private void addBreakPosition(LineLayoutManager.LineBreakPosition pos) {
             // Positions are always added with index 0 because
             // they are created backward, from the last one to
             // the first one
             breakPositions.add(0, pos);
         }

         private LineLayoutManager.LineBreakPosition getBreakPosition(int i) {
             return breakPositions.get(i);
         }
     }

     private List possibilitiesList;
     private List savedPossibilities;
     private int minimumIndex;
     private int optimumIndex;
     private int maximumIndex;
     private int chosenIndex;
     private int savedOptLineCount;

     /** default constructor */
     public LineLayoutPossibilities() {
         possibilitiesList = new java.util.ArrayList();
         savedPossibilities = new java.util.ArrayList();
         optimumIndex = -1;
     }

     /**
      * Add possibility.
      * @param ln line number
      * @param dem demerits
      */
     public void addPossibility(int ln, double dem) {
         possibilitiesList.add(new Possibility(ln, dem));
         if (possibilitiesList.size() == 1) {
             // first Possibility added
             minimumIndex = 0;
             optimumIndex = 0;
             maximumIndex = 0;
             chosenIndex = 0;
         } else {
             if (dem < ((Possibility)possibilitiesList.get(optimumIndex)).getDemerits()) {
                 optimumIndex = possibilitiesList.size() - 1;
                 chosenIndex = optimumIndex;
             }
             if (ln < ((Possibility)possibilitiesList.get(minimumIndex)).getLineCount()) {
                 minimumIndex = possibilitiesList.size() - 1;
             }
             if (ln > ((Possibility)possibilitiesList.get(maximumIndex)).getLineCount()) {
                 maximumIndex = possibilitiesList.size() - 1;
             }
         }
     }

     /**
      * Save in a different array the computed Possibilities,
      * so possibilitiesList is ready to store different Possibilities.
      * @param bSaveOptLineCount true if should save optimum line count
      */
     public void savePossibilities(boolean bSaveOptLineCount) {
         if (bSaveOptLineCount) {
             savedOptLineCount = getOptLineCount();
         } else {
             savedOptLineCount = 0;
         }
         savedPossibilities = possibilitiesList;
         possibilitiesList = new java.util.ArrayList();
     }

     /**
      * Replace the Possibilities stored in possibilitiesList with
      * the ones stored in savedPossibilities and having the same line number.
      */
     public void restorePossibilities() {
         int index = 0;
         while (savedPossibilities.size() > 0) {
             Possibility restoredPossibility = (Possibility) savedPossibilities.remove(0);
             if (restoredPossibility.getLineCount() < getMinLineCount()) {
                 // if the line number of restoredPossibility is less than the minimum one,
                 // add restoredPossibility at the beginning of the list
                 possibilitiesList.add(0, restoredPossibility);
                 // update minimumIndex
                 minimumIndex = 0;
                 // shift the other indexes;
                 optimumIndex++;
                 maximumIndex++;
                 chosenIndex++;
             } else if (restoredPossibility.getLineCount() > getMaxLineCount()) {
                 // if the line number of restoredPossibility is greater than the maximum one,
                 // add restoredPossibility at the end of the list
                 possibilitiesList.add(possibilitiesList.size(), restoredPossibility);
                 // update maximumIndex
                 maximumIndex = possibilitiesList.size() - 1;
                 index = maximumIndex;
             } else {
                 // find the index of the Possibility that will be replaced
                 while (index < maximumIndex
                        && getLineCount(index) < restoredPossibility.getLineCount()) {
                     index++;
                 }
                 if (getLineCount(index) == restoredPossibility.getLineCount()) {
                     possibilitiesList.set(index, restoredPossibility);
                 } else {
                     // this should not happen
                     LOG.error("LineLayoutPossibilities restorePossibilities(),"
                         + " min= " + getMinLineCount()
                         + " max= " + getMaxLineCount()
                         + " restored= " + restoredPossibility.getLineCount());
                     return;
                 }
             }
             // update optimumIndex and chosenIndex
             if (savedOptLineCount == 0
                 && getDemerits(optimumIndex) > restoredPossibility.getDemerits()
                 || savedOptLineCount != 0
                 && restoredPossibility.getLineCount() == savedOptLineCount) {
                 optimumIndex = index;
                 chosenIndex = optimumIndex;
             }
         }
         //log.debug(">> minLineCount = " + getMinLineCount()
         //  + " optLineCount = " + getOptLineCount() + " maxLineCount() = " + getMaxLineCount());
     }

     /**
      * @param pos a position
      * @param i an index into posibilities list
      */
     public void addBreakPosition(LineLayoutManager.LineBreakPosition pos, int i) {
         ((Possibility)possibilitiesList.get(i)).addBreakPosition(pos);
     }

     /** @return true if can use more lines */
     public boolean canUseMoreLines() {
         return (getOptLineCount() < getMaxLineCount());
     }

     /** @return true if can use fewer lines */
     public boolean canUseLessLines() {
         return (getMinLineCount() < getOptLineCount());
     }

     /** @return the line count of the minimum index */
     public int getMinLineCount() {
         return getLineCount(minimumIndex);
     }

     /** @return the line count of the optimum index */
     public int getOptLineCount() {
         return getLineCount(optimumIndex);
     }

     /** @return the line count of the maximum index */
     public int getMaxLineCount() {
         return getLineCount(maximumIndex);
     }

     /** @return the line count of the chosen index */
     public int getChosenLineCount() {
         return getLineCount(chosenIndex);
     }

     /**
      * @param i the posibilities list index
      * @return the line count
      */
     public int getLineCount(int i) {
         return ((Possibility)possibilitiesList.get(i)).getLineCount();
     }

     /** @return the demerits of the chosen index */
     public double getChosenDemerits() {
         return getDemerits(chosenIndex);
     }

     /**
      * @param i the posibilities list index
      * @return the demerits
      */
     public double getDemerits(int i) {
         return ((Possibility)possibilitiesList.get(i)).getDemerits();
     }

     /** @return the possibilities count */
     public int getPossibilitiesNumber() {
         return possibilitiesList.size();
     }

     /**
      * @param i the break position index
      * @return the chosen position
      */
     public LineLayoutManager.LineBreakPosition getChosenPosition(int i) {
         return ((Possibility)possibilitiesList.get(chosenIndex)).getBreakPosition(i);
     }

     /**
      * @param adj the adjustment
      * @return the adjustment or zero
      */
     public int applyLineCountAdjustment(int adj) {
         if (adj >= (getMinLineCount() - getChosenLineCount())
             && adj <= (getMaxLineCount() - getChosenLineCount())
             && getLineCount(chosenIndex + adj) == getChosenLineCount() + adj) {
             chosenIndex += adj;
             LOG.debug("chosenLineCount= " + (getChosenLineCount() - adj) + " adjustment= " + adj
                                + " => chosenLineCount= " + getLineCount(chosenIndex));
             return adj;
         } else {
             // this should not happen!
             LOG.warn("Cannot apply the desired line count adjustment.");
             return 0;
         }
     }

     /** print all */
     public void printAll() {
         System.out.println("++++++++++");
         System.out.println(" " + possibilitiesList.size() + " possibility':");
         for (int i = 0; i < possibilitiesList.size(); i++) {
             System.out.println("   " + ((Possibility)possibilitiesList.get(i)).getLineCount()
                                + (i == optimumIndex ? " *" : "")
                                + (i == minimumIndex ? " -" : "")
                                + (i == maximumIndex ? " +" : ""));
         }
         System.out.println("++++++++++");
     }
 }
	/*
	* 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.layoutmgr.inline;

	import java.util.List;

	import org.apache.commons.logging.Log;
	import org.apache.commons.logging.LogFactory;

	/**
	* Line layout possibilities.
	*/
	public class LineLayoutPossibilities {

	/** logger instance */
	private static final Log LOG = LogFactory.getLog(LineLayoutPossibilities.class);

	private final class Possibility {
	private int lineCount;
	private double demerits;
	private List<LineLayoutManager.LineBreakPosition> breakPositions;

	private Possibility(int lc, double dem) {
	lineCount = lc;
	demerits = dem;
	breakPositions = new java.util.ArrayList<LineLayoutManager.LineBreakPosition>(lc);
	}

	private int getLineCount() {
	return lineCount;
	}

	private double getDemerits() {
	return demerits;
	}

	private void addBreakPosition(LineLayoutManager.LineBreakPosition pos) {
	// Positions are always added with index 0 because
	// they are created backward, from the last one to
	// the first one
	breakPositions.add(0, pos);
	}

	private LineLayoutManager.LineBreakPosition getBreakPosition(int i) {
	return breakPositions.get(i);
	}
	}

	private List possibilitiesList;
	private List savedPossibilities;
	private int minimumIndex;
	private int optimumIndex;
	private int maximumIndex;
	private int chosenIndex;
	private int savedOptLineCount;

	/** default constructor */
	public LineLayoutPossibilities() {
	possibilitiesList = new java.util.ArrayList();
	savedPossibilities = new java.util.ArrayList();
	optimumIndex = -1;
	}

	/**
	* Add possibility.
	* @param ln line number
	* @param dem demerits
	*/
	public void addPossibility(int ln, double dem) {
	possibilitiesList.add(new Possibility(ln, dem));
	if (possibilitiesList.size() == 1) {
	// first Possibility added
	minimumIndex = 0;
	optimumIndex = 0;
	maximumIndex = 0;
	chosenIndex = 0;
	} else {
	if (dem < ((Possibility)possibilitiesList.get(optimumIndex)).getDemerits()) {
	optimumIndex = possibilitiesList.size() - 1;
	chosenIndex = optimumIndex;
	}
	if (ln < ((Possibility)possibilitiesList.get(minimumIndex)).getLineCount()) {
	minimumIndex = possibilitiesList.size() - 1;
	}
	if (ln > ((Possibility)possibilitiesList.get(maximumIndex)).getLineCount()) {
	maximumIndex = possibilitiesList.size() - 1;
	}
	}
	}

	/**
	* Save in a different array the computed Possibilities,
	* so possibilitiesList is ready to store different Possibilities.
	* @param bSaveOptLineCount true if should save optimum line count
	*/
	public void savePossibilities(boolean bSaveOptLineCount) {
	if (bSaveOptLineCount) {
	savedOptLineCount = getOptLineCount();
	} else {
	savedOptLineCount = 0;
	}
	savedPossibilities = possibilitiesList;
	possibilitiesList = new java.util.ArrayList();
	}

	/**
	* Replace the Possibilities stored in possibilitiesList with
	* the ones stored in savedPossibilities and having the same line number.
	*/
	public void restorePossibilities() {
	int index = 0;
	while (savedPossibilities.size() > 0) {
	Possibility restoredPossibility = (Possibility) savedPossibilities.remove(0);
	if (restoredPossibility.getLineCount() < getMinLineCount()) {
	// if the line number of restoredPossibility is less than the minimum one,
	// add restoredPossibility at the beginning of the list
	possibilitiesList.add(0, restoredPossibility);
	// update minimumIndex
	minimumIndex = 0;
	// shift the other indexes;
	optimumIndex++;
	maximumIndex++;
	chosenIndex++;
	} else if (restoredPossibility.getLineCount() > getMaxLineCount()) {
	// if the line number of restoredPossibility is greater than the maximum one,
	// add restoredPossibility at the end of the list
	possibilitiesList.add(possibilitiesList.size(), restoredPossibility);
	// update maximumIndex
	maximumIndex = possibilitiesList.size() - 1;
	index = maximumIndex;
	} else {
	// find the index of the Possibility that will be replaced
	while (index < maximumIndex
	&& getLineCount(index) < restoredPossibility.getLineCount()) {
	index++;
	}
	if (getLineCount(index) == restoredPossibility.getLineCount()) {
	possibilitiesList.set(index, restoredPossibility);
	} else {
	// this should not happen
	LOG.error("LineLayoutPossibilities restorePossibilities(),"
	+ " min= " + getMinLineCount()
	+ " max= " + getMaxLineCount()
	+ " restored= " + restoredPossibility.getLineCount());
	return;
	}
	}
	// update optimumIndex and chosenIndex
	if (savedOptLineCount == 0
	&& getDemerits(optimumIndex) > restoredPossibility.getDemerits()
	\|\| savedOptLineCount != 0
	&& restoredPossibility.getLineCount() == savedOptLineCount) {
	optimumIndex = index;
	chosenIndex = optimumIndex;
	}
	}
	//log.debug(">> minLineCount = " + getMinLineCount()
	// + " optLineCount = " + getOptLineCount() + " maxLineCount() = " + getMaxLineCount());
	}

	/**
	* @param pos a position
	* @param i an index into posibilities list
	*/
	public void addBreakPosition(LineLayoutManager.LineBreakPosition pos, int i) {
	((Possibility)possibilitiesList.get(i)).addBreakPosition(pos);
	}

	/** @return true if can use more lines */
	public boolean canUseMoreLines() {
	return (getOptLineCount() < getMaxLineCount());
	}

	/** @return true if can use fewer lines */
	public boolean canUseLessLines() {
	return (getMinLineCount() < getOptLineCount());
	}

	/** @return the line count of the minimum index */
	public int getMinLineCount() {
	return getLineCount(minimumIndex);
	}

	/** @return the line count of the optimum index */
	public int getOptLineCount() {
	return getLineCount(optimumIndex);
	}

	/** @return the line count of the maximum index */
	public int getMaxLineCount() {
	return getLineCount(maximumIndex);
	}

	/** @return the line count of the chosen index */
	public int getChosenLineCount() {
	return getLineCount(chosenIndex);
	}

	/**
	* @param i the posibilities list index
	* @return the line count
	*/
	public int getLineCount(int i) {
	return ((Possibility)possibilitiesList.get(i)).getLineCount();
	}

	/** @return the demerits of the chosen index */
	public double getChosenDemerits() {
	return getDemerits(chosenIndex);
	}

	/**
	* @param i the posibilities list index
	* @return the demerits
	*/
	public double getDemerits(int i) {
	return ((Possibility)possibilitiesList.get(i)).getDemerits();
	}

	/** @return the possibilities count */
	public int getPossibilitiesNumber() {
	return possibilitiesList.size();
	}

	/**
	* @param i the break position index
	* @return the chosen position
	*/
	public LineLayoutManager.LineBreakPosition getChosenPosition(int i) {
	return ((Possibility)possibilitiesList.get(chosenIndex)).getBreakPosition(i);
	}

	/**
	* @param adj the adjustment
	* @return the adjustment or zero
	*/
	public int applyLineCountAdjustment(int adj) {
	if (adj >= (getMinLineCount() - getChosenLineCount())
	&& adj <= (getMaxLineCount() - getChosenLineCount())
	&& getLineCount(chosenIndex + adj) == getChosenLineCount() + adj) {
	chosenIndex += adj;
	LOG.debug("chosenLineCount= " + (getChosenLineCount() - adj) + " adjustment= " + adj
	+ " => chosenLineCount= " + getLineCount(chosenIndex));
	return adj;
	} else {
	// this should not happen!
	LOG.warn("Cannot apply the desired line count adjustment.");
	return 0;
	}
	}

	/** print all */
	public void printAll() {
	System.out.println("++++++++++");
	System.out.println(" " + possibilitiesList.size() + " possibility':");
	for (int i = 0; i < possibilitiesList.size(); i++) {
	System.out.println(" " + ((Possibility)possibilitiesList.get(i)).getLineCount()
	+ (i == optimumIndex ? " *" : "")
	+ (i == minimumIndex ? " -" : "")
	+ (i == maximumIndex ? " +" : ""));
	}
	System.out.println("++++++++++");
	}
	}