Application.java

package edu.stanford.hci.r3;

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

import javax.swing.filechooser.FileSystemView;

import edu.stanford.hci.r3.devices.Device;
import edu.stanford.hci.r3.paper.Sheet;
import edu.stanford.hci.r3.pattern.coordinates.PatternLocationToSheetLocationMapping;
import edu.stanford.hci.r3.pen.PenInput;
import edu.stanford.hci.r3.pen.batch.BatchedEventHandler;
import edu.stanford.hci.r3.render.SheetRenderer;
import edu.stanford.hci.r3.tools.debug.DebuggingEnvironment;
import edu.stanford.hci.r3.util.DebugUtils;

public class Application {

        private List<BatchedEventHandler> batchEventHandlers = new ArrayList<BatchedEventHandler>();

        private DebuggingEnvironment debuggingEnvironment;

        private List<Device> devices = new ArrayList<Device>();

        private PaperToolkit host = null;

        private boolean isRunning = false;

        private String name;

        private List<PenInput> penInputDevices = new ArrayList<PenInput>();

        private List<Sheet> sheets = new ArrayList<Sheet>();

        private boolean userChoosesPDFDestination = false;

        public Application(String theName) {
                name = theName;
        }

        public void addBatchEventHandler(BatchedEventHandler beh) {
                batchEventHandlers.add(beh);
        }

        public void addDevice(Device dev) {
                devices.add(dev);
        }

        public void addPenInput(PenInput penInputDevice) {
                penInputDevices.add(penInputDevice);
        }

        public void addSheet(Sheet sheet) {
                // ensure that a mapping object is created
                final PatternLocationToSheetLocationMapping mapping = sheet
                                .getPatternLocationToSheetLocationMapping();
                addSheetObjectToInternalList(sheet);
                registerMappingWithEventEngineDuringRuntime(mapping);

                sheet.setParentApplication(this);
        }

        public void addSheet(Sheet sheet, File patternInfoFile) {
                // ensure that a mapping object is created from this file
                PatternLocationToSheetLocationMapping mapping = sheet
                                .getPatternLocationToSheetLocationMapping(patternInfoFile);
                addSheetObjectToInternalList(sheet);
                registerMappingWithEventEngineDuringRuntime(mapping);
        }

        public void addSheet(Sheet sheet, PatternLocationToSheetLocationMapping patternToSheetMapping) {
                sheet.setPatternLocationToSheetLocationMapping(patternToSheetMapping);
                addSheetObjectToInternalList(sheet);
                registerMappingWithEventEngineDuringRuntime(patternToSheetMapping);
        }

        private void addSheetObjectToInternalList(Sheet sheet) {
                if (sheets.contains(sheet)) {
                        DebugUtils.println("Already added this sheet: " + sheet);
                } else {
                        DebugUtils.println("Adding Sheet: " + sheet);
                        sheets.add(sheet);
                }
        }

        public List<BatchedEventHandler> getBatchEventHandlers() {
                return batchEventHandlers;
        }

        public DebuggingEnvironment getDebuggingEnvironment() {
                return debuggingEnvironment;
        }

        public PaperToolkit getHostToolkit() {
                return host;
        }

        public String getName() {
                return name;
        }

        public Collection<PatternLocationToSheetLocationMapping> getPatternMaps() {
                Collection<PatternLocationToSheetLocationMapping> map = new ArrayList<PatternLocationToSheetLocationMapping>();
                for (Sheet s : getSheets()) {
                        map.add(s.getPatternLocationToSheetLocationMapping());
                }
                return map;
        }

        public List<PenInput> getPenInputDevices() {
                return penInputDevices;
        }

        public List<Sheet> getSheets() {
                return sheets;
        }

        protected void initializeBeforeStarting() {
                // do nothing, unless it is overridden.
        }

        public boolean isRunning() {
                return isRunning;
        }

        public boolean isUserChoosingDestinationForPDF() {
                return userChoosesPDFDestination;
        }

        private void registerMappingWithEventEngineDuringRuntime(PatternLocationToSheetLocationMapping mapping) {
                if (isRunning) {
                        // tell the already-running event engine to be aware of this new pattern mapping!
                        getHostToolkit().getEventEngine().registerPatternMapForEventHandling(mapping);
                }
        }

        public void removeAllSheets() {
                sheets.clear();
        }

        public void removeBatchEventHandler(BatchedEventHandler beh) {
                batchEventHandlers.remove(beh);
        }

        public void removeSheet(Sheet sheet) {
                if (sheets.contains(sheet)) {
                        sheets.remove(sheet);
                }

                // unregister this sheet's mapping information
                // so that the EventEngine won't dispatch events to this sheet.
                if (isRunning) {
                        getHostToolkit().getEventEngine().unregisterPatternMapForEventHandling(
                                        sheet.getPatternLocationToSheetLocationMapping());
                }
        }

        public void renderToPDF() {
                renderToPDF(FileSystemView.getFileSystemView().getHomeDirectory(), getName());
        }

        public void renderToPDF(File parentDirectory, String fileNameWithoutExtension) {
                if (sheets.size() == 1) {
                        DebugUtils.println("Rendering PDF...");
                        final Sheet sheet = sheets.get(0);
                        final File destPDFFile = new File(parentDirectory, fileNameWithoutExtension + ".pdf");
                        System.out.println("Rendering: " + destPDFFile.getAbsolutePath());
                        final SheetRenderer renderer = sheet.getRenderer();
                        renderer.renderToPDF(destPDFFile);
                } else {
                        DebugUtils.println("Rendering PDFs...");
                        for (int i = 0; i < sheets.size(); i++) {
                                final Sheet sheet = sheets.get(i);
                                final File destPDFFile = new File(parentDirectory, fileNameWithoutExtension + "_Sheet_" + i
                                                + ".pdf");
                                System.out.println("Rendering: " + destPDFFile.getAbsolutePath());
                                final SheetRenderer renderer = sheet.getRenderer();
                                renderer.renderToPDF(destPDFFile);
                        }
                }

        }

        public void setDebuggingEnvironment(DebuggingEnvironment debugEnvironment) {
                debuggingEnvironment = debugEnvironment;
        }

        public void setHostToolkit(PaperToolkit toolkit) {
                host = toolkit;
                if (host != null) {
                        setRunning(true);
                } else {
                        setRunning(false);
                }
        }

        private void setRunning(boolean flag) {
                isRunning = flag;
        }

        public void setUserChoosesPDFDestinationFlag(boolean flag) {
                userChoosesPDFDestination = flag;
        }

        public String toString() {
                return name + " Application";
        }
}

---