Region.java

package edu.stanford.hci.r3.paper;

import java.awt.Color;
import java.awt.Shape;
import java.awt.geom.AffineTransform;
import java.awt.geom.GeneralPath;
import java.awt.geom.PathIterator;
import java.awt.geom.Rectangle2D;
import java.util.ArrayList;
import java.util.List;

import edu.stanford.hci.r3.events.EventHandler;
import edu.stanford.hci.r3.render.RegionRenderer;
import edu.stanford.hci.r3.units.Inches;
import edu.stanford.hci.r3.units.Units;
import edu.stanford.hci.r3.util.graphics.GraphicsUtils;

public class Region {

        private static final Color LIGHT_LIGHT_GRAY = new Color(240, 240, 240);

        private static final String WARNING_POST = " (see Region.java)";

        private static final String WARNING_PRE = "WARNING: Using Default Renderer for ";

        private boolean active = false;

        private List<EventHandler> eventHandlers = new ArrayList<EventHandler>();

        private Color fillColor = LIGHT_LIGHT_GRAY;

        private String name;

        private double opacity = 0;

        private Sheet parentSheet;

        protected Units referenceUnits;

        protected double scaleX = 1.0;

        protected double scaleY = 1.0;

        private Shape shape;

        private Color strokeColor = Color.BLACK;

        private boolean visible = true;

        public Region(String name, double xInches, double yInches, double wInches, double hInches) {
                this(name, new Rectangle2D.Double(xInches, yInches, wInches, hInches), Inches.ONE);
        }

        public Region(String theName, Shape s, Units u) {
                shape = s;
                referenceUnits = u;
                name = theName;
        }

        protected Region(String theName, Units u) {
                referenceUnits = u;
                name = theName;
        }

        public Region(String name, Units x, Units y, Units w, Units h) {
                this(name, new Rectangle2D.Double(x.getValue(), y.getValueIn(x), // assume a Rectangle2D
                                w.getValueIn(x), h.getValueIn(x)), x);
        }

        public void addEventHandler(EventHandler handler) {
                eventHandlers.add(handler);

                // tell the event handler that we are one of its parent regions
                // this allows code in event handling to determine which regions it might affect, at
                // runtime! :)
                handler.addParentRegion(this);

                active = true;
        }

        public List<EventHandler> getEventHandlers() {
                return eventHandlers;
        }

        public Color getFillColor() {
                return fillColor;
        }

        public Units getHeight() {
                return referenceUnits.getUnitsObjectOfSameTypeWithValue(shape.getBounds2D().getHeight()
                                * scaleY);
        }

        public String getIsActiveString() {
                return " [" + (isActive() ? "ACTIVE" : "STATIC") + "]";
        }

        public String getName() {
                return name;
        }

        public double getOpacity() {
                return opacity;
        }

        public Units getOriginX() {
                return referenceUnits.getUnitsObjectOfSameTypeWithValue(shape.getBounds2D().getX());
        }

        public Units getOriginY() {
                return referenceUnits.getUnitsObjectOfSameTypeWithValue(shape.getBounds2D().getY());
        }

        public Sheet getParentSheet() {
                return parentSheet;
        }

        public RegionRenderer getRenderer() {
                // subclasses should override this method
                // otherwise, you will get a warning
                if (!getClass().getSimpleName().equals("Region")) {
                        System.out.println(WARNING_PRE + this + WARNING_POST);
                }
                return new RegionRenderer(this);
        }

        public double getScaleX() {
                return scaleX;
        }

        public double getScaleY() {
                return scaleY;
        }

        public Shape getShape() {
                return shape;
        }

        public Color getStrokeColor() {
                return strokeColor;
        }

        public Units getUnits() {
                return referenceUnits;
        }

        public Rectangle2D getUnscaledBounds2D() {
                return shape.getBounds2D();
        }

        public Units getUnscaledBoundsHeight() {
                return referenceUnits.getUnitsObjectOfSameTypeWithValue(shape.getBounds2D().getHeight());
        }

        public Units getUnscaledBoundsWidth() {
                return referenceUnits.getUnitsObjectOfSameTypeWithValue(shape.getBounds2D().getWidth());
        }

        public Shape getUnscaledShapeCopy() {
                return new GeneralPath(shape);
        }

        public Units getWidth() {
                return referenceUnits.getUnitsObjectOfSameTypeWithValue(shape.getBounds2D().getWidth()
                                * scaleX);
        }

        public boolean isActive() {
                return active;
        }

        public boolean isVisible() {
                return visible;
        }

        private Object readResolve() {
                if (eventHandlers == null) {
                        System.err.println("Region.java:: [" + getName()
                                        + "]'s eventHandlers list was unexpectedly null upon "
                                        + "deserialization with XStream. Perhaps you need to "
                                        + "reserialize your Regions?");
                        eventHandlers = new ArrayList<EventHandler>();
                }
                return this;
        }

        public void resetScale() {
                setScale(1.0, 1.0);
        }

        public void scaleRegion(double sX, double sY) {
                scaleX = scaleX * sX;
                scaleY = scaleY * sY;
        }

        public void scaleRegionUniformly(double scale) {
                scaleRegion(scale, scale);
        }

        public void setActive(boolean isRegionActive) {
                active = isRegionActive;
        }

        public void setFillColor(Color theFillColor) {
                fillColor = theFillColor;
        }

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

        public void setOpacity(double theOpacityFrom0To1) {
                if (theOpacityFrom0To1 > 1) {
                        theOpacityFrom0To1 = 1;
                } else if (theOpacityFrom0To1 < 0) {
                        theOpacityFrom0To1 = 0;
                }
                opacity = theOpacityFrom0To1;
        }

        public void setParentSheet(Sheet sheet) {
                parentSheet = sheet;
        }

        public void setScale(double newScaleX, double newScaleY) {
                scaleX = newScaleX;
                scaleY = newScaleY;
        }

        protected void setShape(Shape s) {
                shape = s;
        }

        public void setStrokeColor(Color strokeCol) {
                strokeColor = strokeCol;
        }

        public void setVisible(boolean v) {
                visible = v;
        }

        public String toString() {
                final StringBuilder sb = new StringBuilder();
                final String className = shape.getClass().getName();
                sb.append(getName() + " of type ");
                sb.append(className.substring(className.lastIndexOf(".") + 1) + ": {");

                final PathIterator pathIterator = shape.getPathIterator(AffineTransform.getScaleInstance(
                                scaleX, scaleY));

                sb.append(GraphicsUtils.getPathAsString(pathIterator));

                sb.append("} in " + referenceUnits.getUnitName());
                sb.append(getIsActiveString());
                return sb.toString();
        }

}

---