Sheet.java

package edu.stanford.hci.r3.paper;

import java.io.File;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import edu.stanford.hci.r3.Application;
import edu.stanford.hci.r3.PaperToolkit;
import edu.stanford.hci.r3.pattern.coordinates.PatternLocationToSheetLocationMapping;
import edu.stanford.hci.r3.render.SheetRenderer;
import edu.stanford.hci.r3.tools.design.acrobat.RegionConfiguration;
import edu.stanford.hci.r3.units.Inches;
import edu.stanford.hci.r3.units.Size;
import edu.stanford.hci.r3.units.Units;
import edu.stanford.hci.r3.units.coordinates.Coordinates;

public class Sheet {

        private static final String INDENT = "   ";

        private Set<File> configurationPaths = new HashSet<File>();

        private String name = "A Sheet";

        private PatternLocationToSheetLocationMapping patternLocationToSheetLocationMapping;

        private Map<String, Region> regionNameToRegionObject = new HashMap<String, Region>();

        private List<Region> regions = new ArrayList<Region>();

        private Map<Region, Coordinates> regionsAndRelativeLocations = new HashMap<Region, Coordinates>();

        private Size size = new Size();

        private Application parentApp;

        public Sheet() {
                this(new Inches(8.5), new Inches(11.0));
        }

        public Sheet(double widthInches, double heightInches) {
                this(new Inches(widthInches), new Inches(heightInches));
        }

        public Sheet(Units w, Units h) {
                setSize(w, h);
        }

        public void addConfigurationPath(File configPath) {
                // register the fact that we loaded a configuration file from this directory
                configurationPaths.add(configPath);
                // DebugUtils.println("Configuration Paths: " + configurationPaths);
        }

        public void addRegion(Region r) {
                regions.add(r);
                regionNameToRegionObject.put(r.getName(), r);
                r.setParentSheet(this);
        }

        public void addRegion(Region r, Units xOffset, Units yOffset) {
                addRegion(r);
                setRegionOffset(r, xOffset, yOffset);
        }

        public void addRegions(File regionConfigurationFile) {
                final RegionConfiguration rc = (RegionConfiguration) PaperToolkit.fromXML(regionConfigurationFile);

                // make sure the size of the sheet matches this object...
                // otherwise, raise a warning flag
                if (!rc.getHeight().equals(getHeight()) || !rc.getWidth().equals(getWidth())) {
                        System.err.println("Sheet::addRegions(regionConfigurationFile): Warning! "
                                        + "This region configuration file was made for a sheet of a different size. "
                                        + "RegionConfiguration: [" + rc.getWidth() + "," + rc.getHeight() + "] versus "
                                        + "This Sheet: [" + getWidth() + "," + getHeight() + "]");
                        System.err.println("We will proceed.... but you have been warned. =)");
                }

                final List<Region> theRegions = rc.getRegions();
                for (Region r : theRegions) {
                        addRegion(r);
                }

                addConfigurationPath(regionConfigurationFile.getParentFile());
        }

        public boolean containsRegion(Region r) {
                return regions.contains(r);
        }

        public Set<File> getConfigurationPaths() {
                return configurationPaths;
        }

        public Units getHeight() {
                return size.getHeight();
        }

        public String getName() {
                return name;
        }

        public PatternLocationToSheetLocationMapping getPatternLocationToSheetLocationMapping() {
                if (patternLocationToSheetLocationMapping == null) {
                        // in case no one has set this object, we will ensure that it is not null...
                        setPatternLocationToSheetLocationMapping(new PatternLocationToSheetLocationMapping(this));
                }
                return patternLocationToSheetLocationMapping;
        }

        public PatternLocationToSheetLocationMapping getPatternLocationToSheetLocationMapping(File patternInfoFile) {
                setPatternLocationToSheetLocationMapping(new PatternLocationToSheetLocationMapping(this,
                                patternInfoFile));
                return patternLocationToSheetLocationMapping;
        }

        public Region getRegion(String regionName) {
                return regionNameToRegionObject.get(regionName);
        }

        public List<String> getRegionNames() {
                final List<String> names = new ArrayList<String>();
                for (Region r : regions) {
                        names.add(r.getName());
                }
                return names;
        }

        public Coordinates getRegionOffset(Region r) {
                final Coordinates coordinates = regionsAndRelativeLocations.get(r);
                if (coordinates == null) {
                        return new Coordinates(new Inches(0), new Inches(0));
                }
                return coordinates;
        }

        public List<Region> getRegions() {
                return regions;
        }

        public SheetRenderer getRenderer() {
                return new SheetRenderer(this);
        }

        public Size getSize() {
                return size.clone();
        }

        public Units getWidth() {
                return size.getWidth();
        }

        public void setName(String n) {
                name = n;
        }

        public void setPatternLocationToSheetLocationMapping(PatternLocationToSheetLocationMapping mapping) {
                patternLocationToSheetLocationMapping = mapping;
        }

        public void setRegionOffset(Region r, Units xOffset, Units yOffset) {
                regionsAndRelativeLocations.put(r, new Coordinates(xOffset, yOffset));
        }

        protected void setSize(Units width, Units height) {
                size.setSize(width, height);
        }

        public String toDetailedString() {
                final StringBuilder sb = new StringBuilder();

                // the indent
                String i = INDENT;

                sb.append("Sheet {\n");
                sb.append(i + "Size: " + getWidth() + " x " + getHeight() + "\n");

                sb.append(i + "Regions: " + regions.size() + " {\n");

                // indent twice
                i = INDENT + INDENT;

                for (Region r : regions) {
                        sb.append(i + r.toString() + "\n");
                }

                i = INDENT;

                sb.append(i + "}\n");
                sb.append("}\n");
                return sb.toString();
        }

        public String toString() {
                return "Sheet { name: [" + name + "] size: [" + getWidth() + " x " + getHeight() + "] numRegions: ["
                                + regions.size() + "]}";
        }

        public String toXML() {
                return PaperToolkit.toXML(this);
        }

        public void setParentApplication(Application application) {
                parentApp = application;
        }
        public Application getParentApplication() {
                return parentApp;
        }
}

---