InkPanel.java

package edu.stanford.hci.r3.components;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.geom.AffineTransform;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;

import javax.swing.JPanel;

import edu.stanford.hci.r3.pen.ink.Ink;
import edu.stanford.hci.r3.render.ink.InkRenderer;
import edu.stanford.hci.r3.util.graphics.GraphicsUtils;

public class InkPanel extends JPanel {

        private Ink currentInk;

        private double inkScale = 1.0;

        protected List<Ink> inkWell = Collections.synchronizedList(new LinkedList<Ink>());

        private boolean invertInkColors = false;

        private InkRenderer renderer;

        public InkPanel() {
                this(new InkRenderer(), Color.WHITE);
        }

        public InkPanel(InkRenderer inkRenderer, Color bgColor) {
                setBackground(bgColor);
                renderer = inkRenderer;
        }

        public void addInk(Ink ink) {
                currentInk = ink;
                inkWell.add(ink);
                repaint();
        }

        public Ink addNewInk() {
                currentInk = new Ink();
                inkWell.add(currentInk);
                repaint();
                return currentInk;
        }

        public void clear() {
                inkWell.clear();
                repaint();
        }

        public void displayInvertedInkColor() {
                invertInkColors = true;
        }

        public List<Ink> getAllInk() {
                return inkWell;
        }

        public double getScale() {
                return inkScale;
        }

        @Override
        protected void paintComponent(Graphics g) {
                super.paintComponent(g);
                final Graphics2D g2d = (Graphics2D) g;
                g2d.setRenderingHints(GraphicsUtils.getBestRenderingHints());

                final AffineTransform transform = g2d.getTransform();
                g2d.scale(inkScale, inkScale);

                // the drawing of ink is "atomic" with respect to
                // adding and removing from the inkWell
                synchronized (inkWell) {
                        for (Ink ink : inkWell) {
                                renderer.setInk(ink);
                                renderer.useInvertedInkColors();
                                renderer.renderToG2D(g2d);
                        }
                }
                g2d.setTransform(transform);
        }

        public void removeLastBatchOfInk() {
                synchronized (inkWell) {
                        if (inkWell.size() > 0) {
                                inkWell.remove(inkWell.size() - 1);
                                repaint();
                        }
                }
        }

        public void setAllInk(List<Ink> theInk) {
                inkWell = theInk;
                repaint();
        }

        public void setRenderer(InkRenderer r) {
                renderer = r;
        }

        public void setScale(double theScale) {
                inkScale = theScale;
        }
}

---