TiledPatternGenerator.java

package edu.stanford.hci.r3.pattern;

import java.io.File;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import edu.stanford.hci.r3.PaperToolkit;
import edu.stanford.hci.r3.units.Units;
import edu.stanford.hci.r3.util.DebugUtils;

public class TiledPatternGenerator {

        private static final int BUFFER = 30;

        public static final String DEFAULT_PATTERN_PACKAGE_NAME = "default";

        private Map<String, PatternPackage> availablePackages;

        private int lastDotUsedX = 0;

        private int lastDotUsedY = 0;

        private int maxOfRecentHeightsInDots = 0;

        private int numTimesGetPatternCalled = 0;

        private int patternFileNumber = 0;

        private PatternPackage patternPackage;

        private File patternPath;

        public TiledPatternGenerator() {
                this(PaperToolkit.getPatternPath());
        }

        public TiledPatternGenerator(File patternPathLocation) {
                patternPath = patternPathLocation;
                availablePackages = PatternPackage.getAvailablePatternPackages(patternPath);
                setPackage(DEFAULT_PATTERN_PACKAGE_NAME);
        }

        public void displayTilingInformation(Units horizontal, Units vertical) {
                long numDotsX = Math.round(horizontal.getValueInPatternDots());
                long numDotsY = Math.round(vertical.getValueInPatternDots());

                // System.out.println(numDotsX + " " + numDotsY);

                int numTilesNeededX = 0;
                int numTilesNeededY = 0;

                int numDotsRemainingX = (int) numDotsX;
                int numDotsRemainingY = (int) numDotsY;

                final int numPatternColsPerFile = patternPackage.getNumPatternColsPerFile();
                final int numPatternRowsPerFile = patternPackage.getNumPatternRowsPerFile();

                while (numDotsRemainingX > 0) {
                        // use up one tile, and subtract an appropriate number of columns...
                        numDotsRemainingX -= numPatternColsPerFile;
                        numTilesNeededX++;
                }
                final int numDotsXFromRightMostTiles = numDotsRemainingX + numPatternColsPerFile;

                while (numDotsRemainingY > 0) {
                        // use up one tile, and subtract an appropriate number of rows...
                        numDotsRemainingY -= numPatternRowsPerFile;
                        numTilesNeededY++;
                }
                final int numDotsYFromBottomMostTiles = numDotsRemainingY + numPatternRowsPerFile;

                // the tiling is...
                // numTilesNeededX, numTilesNeededY
                // numDotsXFromRightMostTiles, numDotsYFromBottomMostTiles
                System.out.println("Tiling Information (" + horizontal + ", " + vertical + ") {");
                System.out.println("\t" + numTilesNeededX + " Tile(s) in X, with " + numDotsXFromRightMostTiles
                                + " horizontal dots from the rightmost tiles.");
                System.out.println("\t" + numTilesNeededY + " Tile(s) in Y, with " + numDotsYFromBottomMostTiles
                                + " vertical dots from the bottommost tiles.");
                System.out.println("}");
        }

        public PatternPackage getCurrentPatternPackage() {
                return patternPackage;
        }

        public TiledPattern getPattern(Units width, Units height) {
                DebugUtils.println("getPattern Called " + ++numTimesGetPatternCalled + " times...");

                final long numDotsX = Math.round(width.getValueInPatternDots());
                final long numDotsY = Math.round(height.getValueInPatternDots());

                // System.out.println(numDotsX + " " + numDotsY);

                int numTilesNeededX = 0;
                int numTilesNeededY = 0;

                int numDotsRemainingX = (int) numDotsX;
                int numDotsRemainingY = (int) numDotsY;

                final int numPatternColsPerFile = patternPackage.getNumPatternColsPerFile();
                final int numPatternRowsPerFile = patternPackage.getNumPatternRowsPerFile();

                // figure out how many horizontal dots we need
                while (numDotsRemainingX > 0) {
                        // use up one tile, and subtract an appropriate number of columns...
                        numDotsRemainingX -= numPatternColsPerFile;
                        numTilesNeededX++;
                }
                final int numDotsXFromRightMostTiles = numDotsRemainingX + numPatternColsPerFile;

                // figure out how many vertical dots we need
                while (numDotsRemainingY > 0) {
                        // use up one tile, and subtract an appropriate number of rows...
                        numDotsRemainingY -= numPatternRowsPerFile;
                        numTilesNeededY++;
                }
                final int numDotsYFromBottomMostTiles = numDotsRemainingY + numPatternRowsPerFile;

                // if we only need one tile....
                // we would like to stay on the same pattern file if we still have space
                // calculate this from numDotsXFromRightMostTiles and numDotsYFromBottomMostTiles...
                // DebugUtils.println("NumTilesNeeded: " + numTilesNeededX + ", " + numTilesNeededY);
                if (numTilesNeededX == 1 && numTilesNeededY == 1) {
                        // DebugUtils.println("DotsNeeded: x: " + numDotsXFromRightMostTiles + ", "
                        // + numDotsYFromBottomMostTiles);
                        // if we WILL exceed the horizontal bounds....
                        if (lastDotUsedX + numDotsXFromRightMostTiles + BUFFER >= numPatternColsPerFile) {

                                // wrap back to the left side of the page
                                lastDotUsedX = 0;
                                lastDotUsedY += maxOfRecentHeightsInDots + BUFFER;
                        }

                        // if we WILL exceed the height bounds...
                        if (lastDotUsedY + numDotsYFromBottomMostTiles + BUFFER >= numPatternRowsPerFile) {
                                lastDotUsedY = 0;
                                // next time, get pattern from a new file!
                                patternFileNumber++;
                        }
                } else {
                        // we need more than one tile...
                        // CROSS OUR FINGERS for now. =)
                }

                // create and return the tiled pattern
                final TiledPattern pattern = new TiledPattern(patternPackage, patternFileNumber, //
                                lastDotUsedX, lastDotUsedY, //
                                numTilesNeededX, numTilesNeededY, //
                                numDotsXFromRightMostTiles, numDotsYFromBottomMostTiles); //
                patternFileNumber = pattern.getLastPatternFileUsed();

                // try to shift everything right
                // we are still tiling horizontally
                // maintain our tallest Y to date
                lastDotUsedX += numDotsXFromRightMostTiles + BUFFER;
                maxOfRecentHeightsInDots = Math.max(maxOfRecentHeightsInDots, numDotsYFromBottomMostTiles + BUFFER);

                return pattern;
        }

        public PatternPackage getPatternPackageByName(String name) {
                return availablePackages.get(name);
        }

        public List<String> listAvailablePatternPackageNames() {
                return new ArrayList<String>(availablePackages.keySet());
        }

        public void resetUniquePatternTracker() {
                patternFileNumber = 0;
                lastDotUsedY = 0;
                lastDotUsedX = 0;
        }

        private void setPackage(String packageName) {
                PatternPackage pkg = availablePackages.get(packageName);
                if (pkg == null) {
                        pkg = new ArrayList<PatternPackage>(availablePackages.values()).get(0);
                        System.err.println("Warning: " + packageName
                                        + " does not exist. Setting Pattern Package to the first one available (" + pkg.getName()
                                        + ").");
                }
                patternPackage = pkg;
        }

        public void setPatternFileNumber(int num) {
                resetUniquePatternTracker();
                patternFileNumber = num;
        }

}

---