Programming a Pencil Tool on Paint?

Question

Here's my code for Scribble(a pencil tool) and its superclass Shape. Basically, my program remembers where the mouse has been and draws a line from the previous point to the current point. However, the scribble doesn't show up (occasionally you will see a small line at the very end) I think the problem is that each Scribble object only has one previous and one current. Therefore, there is only 1 line left at the end. How can I correct this?
Thanks in advance!
Note: this doesn't run since there are about 5 other classes needed. I guess can post them if you want? xD
import java.awt.*;
public class Scribble extends Shape{
     protected Point startpt, endpt;
     protected Point previous, current;
     int count = 0;
    public Scribble(Point start, DrawingCanvas dcanvas){
     super();
     System.out.println("SCRIBBLE CREATED!!!!!!!\n\n");
     startpt = start;
     current = start;
     endpt = start;
     canvas = dcanvas;
     bounds = new Rectangle(start);
    public void resize(Point anchor, Point end){
     super.resize(anchor, end);
     previous = current;
     startpt = anchor;
     current = end;
     endpt = end;
    public void translate(int dx, int dy){
     super.translate(dx, dy);
     previous.translate(dx, dy);
     current.translate(dx, dy);
     startpt.translate(dx, dy);
     endpt.translate(dx, dy);
    public void draw(Graphics g, Rectangle regionToDraw){
          count++;
          System.out.println(count);
     if (!bounds.intersects(regionToDraw)){
         return;
     g.setColor(super.getColor());
     g.drawLine((int)previous.getX(), (int)previous.getY(), (int)current.getX(), (int)current.getY());
     if (isSelected) { // if selected, draw the resizing knobs
                       // along the 4 corners
         Rectangle[] knobs = getKnobRects();
         for (int i = 0; i < knobs.length; i++)
          g.fillRect(knobs.x, knobs[i].y,
               knobs[i].width, knobs[i].height);
protected Rectangle[] getKnobRects(){
     Rectangle[] knobs = new Rectangle[2];
     knobs[0] = new Rectangle((int)startpt.getX() - KNOB_SIZE/2,
                    (int)startpt.getY() - KNOB_SIZE/2, KNOB_SIZE, KNOB_SIZE);
     knobs[1] = new Rectangle((int)endpt.getX() - KNOB_SIZE/2,
                    (int)endpt.getY()- KNOB_SIZE/2, KNOB_SIZE, KNOB_SIZE);
     return knobs;
protected int getKnobContainingPoint(Point pt){
     if (!isSelected) return NONE;
     Rectangle[] knobs = getKnobRects();
     for (int i = 0; i < knobs.length; i++)
     if (knobs[i].contains(pt))
          return i;
     return NONE;
}import java.awt.*;
import java.util.*;
import java.io.*;
public abstract class Shape implements Serializable, Cloneable{
     private Color color;
protected Rectangle bounds;
protected boolean isSelected;
public DrawingCanvas canvas;
protected static final int KNOB_SIZE = 6;
protected static final int NONE = -1;
protected static final int NW = 0;
protected static final int SW = 1;
protected static final int SE = 2;
protected static final int NE = 3;
     Shape(){
          color = Color.darkGray;
     public Color getColor(){
     return color;
     public Object clone(){
          try{
          Shape copy = (Shape)super.clone();
          copy.setBounds(bounds);
          return copy;
          catch(CloneNotSupportedException c){
               return null;
     public void setColor(Color newColor){
     color = newColor;
     canvas.repaint();
     /** The "primitive" for all resizing/moving/creating operations that
     * affect the rect bounding box. The current implementation just resets
     * the bounds variable and triggers a re-draw of the union of the old &
     * new rectangles. This will redraw the shape in new size and place and
     * also "erase" if bounds are now smaller than before.
     protected void setBounds(Rectangle newBounds){
          Rectangle oldBounds = bounds;
          bounds = newBounds;
          updateCanvas(oldBounds.union(bounds));
     /** The resize operation is called when first creating a rect, as well as
     * when later resizing by dragging one of its knobs. The two parameters
     * are the points that define the new bounding box. The anchor point
     * is the location of the mouse-down event during a creation operation
     * or the opposite corner of the knob being dragged during a resize
     * operation. The end is the current location of the mouse.
     public void resize(Point anchor, Point end){
          Rectangle newRect = new Rectangle(anchor);
          // creates smallest rectange which
          // includes both anchor & end
          newRect.add(end);
          // reset bounds & redraw affected areas
          setBounds(newRect);
          canvas.repaint();
     /** The translate operation is called when moving a shape by dragging in
     * the canvas. The two parameters are the delta-x and delta-y to move
     * by. Note that either or both can be negative. Create a new rectangle
     * from our bounds and translate and then go through the setBounds()
     * primitive to change it.
     public void translate(int dx, int dy){
          Rectangle newRect = new Rectangle(bounds);
          newRect.translate(dx, dy);
          setBounds(newRect);
          canvas.repaint();
     /** Used to change the selected state of the shape which will require
     * updating the affected area of the canvas to add/remove knobs.
     public void setSelected(boolean newState){
          isSelected = newState;
          // need to erase/add knobs
          // including extent of extended bounds
          updateCanvas(bounds, true);
          canvas.repaint();
     /** The updateCanvas() methods are used when the state has changed
     * in such a way that it needs to be refreshed in the canvas to properly
     * reflect the new settings. The shape should take responsibility for
     * messaging the canvas to properly update itself. The appropriate AWT/JFC
     * way to re-draw a component is to send it the repaint() method with the
     * rectangle that needs refreshing. This will cause an update() event to
     * be sent to the component which in turn will call paint(), where the
     * real drawing implementation goes. See the paint() method in
     * DrawingCanvas to see how it is implemented.
     protected void updateCanvas(Rectangle areaOfChange, boolean enlargeForKnobs){
               System.out.println("canvas2 updated");
          Rectangle toRedraw = new Rectangle(areaOfChange);
          if (enlargeForKnobs)
          toRedraw.grow(KNOB_SIZE/2, KNOB_SIZE/2);
          canvas.repaint(toRedraw);
     protected void updateCanvas(Rectangle areaOfChange){
               System.out.println("canvas updated");
          updateCanvas(areaOfChange, isSelected);
          public Rectangle getBounds(){
               return bounds;
     /** When the DrawingCanvas needs to determine which shape is under
     * the mouse, it asks the shape to determine if a point is "inside".
     * This method should returns true if the given point is inside the
     * region for this shape. For a rectangle, any point within the
     * bounding box is inside the shape.
     public boolean inside(Point pt){
          return bounds.contains(pt);
     /** When needed, we create the array of knob rectangles on demand. This
     * does mean we create and discard the array and rectangles repeatedly.
     * These are small objects, so perhaps it is not a big deal, but
     * a valid alternative would be to store the array of knobs as an
     * instance variable of the Shape and and update the knobs as the bounds
     * change. This means a little more memory overhead for each Shape
     * (since it is always storing the knobs, even when not being used) and
     * having that redundant data opens up the possibility of bugs from
     * getting out of synch (bounds move but knobs didn't, etc.) but you may
     * find that a more appealing way to go. Either way is fine with us.
     * Note this method provides a nice unified place for one override from
     * a shape subclass to substitute fewer or different knobs.
     protected Rectangle[] getKnobRects(){
               System.out.println("knobs gotten");
          Rectangle[] knobs = new Rectangle[4];
          knobs[NW] = new Rectangle(bounds.x - KNOB_SIZE/2,
                         bounds.y - KNOB_SIZE/2, KNOB_SIZE, KNOB_SIZE);
          knobs[SW] = new Rectangle(bounds.x - KNOB_SIZE/2,
                         bounds.y + bounds.height - KNOB_SIZE/2,
                         KNOB_SIZE, KNOB_SIZE);
          knobs[SE] = new Rectangle(bounds.x + bounds.width - KNOB_SIZE/2,
                         bounds.y + bounds.height - KNOB_SIZE/2,
                         KNOB_SIZE, KNOB_SIZE);
          knobs[NE] = new Rectangle(bounds.x + bounds.width - KNOB_SIZE/2,
                         bounds.y - KNOB_SIZE/2,
                         KNOB_SIZE, KNOB_SIZE);
          return knobs;
     /** Helper method to determine if a point is within one of the resize
     * corner knobs. If not selected, we have no resize knobs, so it can't
     * have been a click on one. Otherwise, we calculate the knob rects and
     * then check whether the point falls in one of them. The return value
     * is one of NW, NE, SW, SE constants depending on which knob is found,
     * or NONE if the click doesn't fall within any knob.
     protected int getKnobContainingPoint(Point pt){
               System.out.println("resize knobs");
          // if we aren't selected, the knobs
          // aren't showing and thus there are no knobs to check
          if (!isSelected) return NONE;
          Rectangle[] knobs = getKnobRects();
          for (int i = 0; i < knobs.length; i++)
          if (knobs[i].contains(pt))
               return i;
          return NONE;
     /** Method used by DrawingCanvas to determine if a mouse click is starting
     * a resize event. In order for it to be a resize, the click must have
     * been within one of the knob rects (checked by the helper method
     * getKnobContainingPoint) and if so, we return the "anchor" ie the knob
     * opposite this corner that will remain fixed as the user drags the
     * resizing knob of the other corner around. During the drag actions of a
     * resize, that fixed anchor point and the current mouse point will be
     * passed to the resize method, which will reset the bounds in response
     * to the movement. If the mouseLocation wasn't a click in a knob and
     * thus not the beginning of a resize event, null is returned.
public Point getAnchorForResize(Point mouseLocation){
          System.out.println("is it a resize?");
int whichKnob = getKnobContainingPoint(mouseLocation);
if (whichKnob == NONE) // no resize knob is at this location
return null;
Rectangle[] knobs = getKnobRects();
whichKnob = Math.abs(whichKnob - (int)(knobs.length / 2));
return (new Point(knobs[whichKnob].x + knobs[whichKnob].width /2,
knobs[whichKnob].y + knobs[whichKnob].height/2));
public abstract void draw(Graphics g, Rectangle regionToDraw);

Answer 1

line left at the end. How can I correct this?java.awt.Polygon (or Polygon2D)
Here are a few of my thoughts
#1 There is a Shape interface in core java already, as well as plenty of very useful shapes (Rectangle, Ellipse2D, Area). Shape has some really nice features like contains(...) and intersects(...). By creating a separate class for your Shape objects, you ensure that the two will be incompatible.
#2 As tempting as it is, it is a bad idea to include a Color with a shape. What if you want it to have more than one Color? What if you want the insides of the shape to be filled by an Image? I just created and posted a class on the java forums called Renderable, which combines a java.awt.Shape with a java.awt.Paint.
#3 Below is my PaintArea class. It "scribbles" on an Image. Maybe this will give you some ideas. To compile it, you will either have to find my MathUtils class (which I've posted here before) or reimplement the distance and angle methods. There is also a reference to WIndowUtilities... find that or remove it and put the PaintArea in a Frame and do setVisible(true)
You are welcome to use and modify this code, but please don't change the package and please make sure that you add attribution if you submit this in an academic setting.
* Created on Jun 15, 2005 by @author Tom Jacobs
package tjacobs.ui.ex;
import java.awt.image.BufferedImage;
import java.awt.*;
import java.awt.event.*;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import javax.swing.ImageIcon;
import javax.swing.JComboBox;
import javax.swing.JComponent;
import javax.swing.JPanel;
import javax.swing.JToolBar;
import tjacobs.MathUtils;
import tjacobs.ui.util.WindowUtilities;
* PaintArea is a component that you can draw in similar to but
* much simpler than the windows paint program.
public class PaintArea extends JComponent {
     private static final long serialVersionUID = 0;
     BufferedImage mImg; //= new BufferedImage();
     int mBrushSize = 1;
     private boolean mSizeChanged = false;
     private Color mColor1, mColor2;
     static class PaintIcon extends ImageIcon {
          public static final long serialVersionUID = 0;
          int mSize;
          public PaintIcon(Image im, int size) {
               super(im);
               mSize = size;
     public PaintArea() {
          super();
          setCursor(Cursor.getPredefinedCursor(Cursor.CROSSHAIR_CURSOR));
          addComponentListener(new CListener());
          MListener ml = new MListener();
          addMouseListener(ml);
          addMouseMotionListener(ml);
          setBackground(Color.WHITE);
          setForeground(Color.BLACK);
     public void paintComponent(Graphics g) {
          if (mSizeChanged) {
               handleResize();
          //g.drawImage(mImg, mImg.getWidth(), mImg.getHeight(), null);
          g.drawImage(mImg, 0, 0, null);
          //super.paintComponent(g);
          //System.out.println("Image = " + mImg);
          //System.out.println("Size: " + mImg.getWidth() + "," + mImg.getHeight());
     public void setBackground(Color c) {
          super.setBackground(c);
          if (mImg != null) {
               Graphics g = mImg.getGraphics();
               g.setColor(c);
               g.fillRect(0, 0, mImg.getWidth(), mImg.getHeight());
               g.dispose();
     public void setColor1(Color c) {
          mColor1 = c;
     public void setColor2(Color c) {
          mColor2 = c;
     public Color getColor1() {
          return mColor1;
     public Color getColor2() {
          return mColor2;
     class ToolBar extends JToolBar {
          private static final long serialVersionUID = 1L;
          ToolBar() {
               final ColorButton fore = new ColorButton();
               fore.setToolTipText("Foreground Color");
               final ColorButton back = new ColorButton();
               back.setToolTipText("Background Color");
               JComboBox brushSize = new JComboBox();
               //super.createImage(1, 1).;
               FontMetrics fm = new FontMetrics(getFont()) {
                    private static final long serialVersionUID = 1L;};
               //int ht = fm.getHeight();
               int useheight = fm.getHeight() % 2 == 0 ? fm.getHeight() + 1 : fm.getHeight();
               final BufferedImage im1 = new BufferedImage(useheight, useheight, BufferedImage.TYPE_INT_RGB);
               Graphics g = im1.getGraphics();
               g.setColor(Color.WHITE);
               g.fillRect(0, 0, useheight, useheight);
               g.setColor(Color.BLACK);
               g.fillOval(useheight / 2, useheight / 2, 1, 1);
               g.dispose();
               //im1.setRGB(useheight / 2 + 1, useheight / 2 + 1, 0xFFFFFF);
               final BufferedImage im2 = new BufferedImage(useheight, useheight, BufferedImage.TYPE_INT_RGB);
               g = im2.getGraphics();
               g.setColor(Color.WHITE);
               g.fillRect(0, 0, useheight, useheight);
               g.setColor(Color.BLACK);
               g.fillOval(useheight / 2 - 1, useheight / 2 - 1, 3, 3);
               g.dispose();
//               im2.setRGB(useheight / 2 - 1, useheight / 2 - 1, 3, 3, new int[] {     0, 0xFFFFFF, 0,
//                                                            0xFFFFFF, 0xFFFFFFF, 0xFFFFFF,
//                                                            0, 0xFFFFFF, 0}, 0, 1);
               final BufferedImage im3 = new BufferedImage(useheight, useheight, BufferedImage.TYPE_INT_RGB);
               g = im3.getGraphics();
               g.setColor(Color.WHITE);
               g.fillRect(0, 0, useheight, useheight);
               g.setColor(Color.BLACK);
               g.fillOval(useheight / 2 - 2, useheight / 2 - 2, 5, 5);
               g.dispose();
//               im3.setRGB(useheight / 2 - 2, useheight / 2 - 2, 5, 5, new int[] {     0, 0, 0xFFFFFF, 0, 0, 
//                                                            0, 0xFFFFFF, 0xFFFFFFF, 0xFFFFFF, 0,
//                                                            0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF,
//                                                            0, 0xFFFFFF, 0xFFFFFFF, 0xFFFFFF, 0,
//                                                            0, 0, 0xFFFFFF, 0, 0}, 0, 1);
               //JLabel l1 = new JLabel("1 pt", new ImageIcon(im1), JLabel.LEFT);
               //JLabel l2 = new JLabel("3 pt", new ImageIcon(im2), JLabel.LEFT);
               //JLabel l3 = new JLabel("5 pt", new ImageIcon(im3), JLabel.LEFT);
               brushSize.addItem(new PaintIcon(im1, 1));
               brushSize.addItem(new PaintIcon(im2, 3));
               brushSize.addItem(new PaintIcon(im3, 5));
               //brushSize.addItem("Other");
               add(fore);
               add(back);
               add(brushSize);
               PropertyChangeListener pl = new PropertyChangeListener() {
                    public void propertyChange(PropertyChangeEvent ev) {
                         Object src = ev.getSource();
                         if (src != fore && src != back) {
                              return;
                         Color c = (Color) ev.getNewValue();
                         if (ev.getSource() == fore) {
                              mColor1 = c;
                         else {
                              mColor2 = c;
               fore.addPropertyChangeListener("Color", pl);
               back.addPropertyChangeListener("Color", pl);
               fore.changeColor(Color.BLACK);
               back.changeColor(Color.WHITE);
               brushSize.addItemListener(new ItemListener() {
                    public void itemStateChanged(ItemEvent ev) {
                         System.out.println("ItemEvent");
                         if (ev.getID() == ItemEvent.DESELECTED) {
                              return;
                         System.out.println("Selected");
                         Object o = ev.getItem();
                         mBrushSize = ((PaintIcon) o).mSize;
               //Graphics g = im1.getGraphics();
               //g.fillOval(0, 0, 1, 1);
               //BufferedImage im1 = new BufferedImage();
               //BufferedImage im1 = new BufferedImage();
     protected class MListener extends MouseAdapter implements MouseMotionListener {
          Point mLastPoint;
          public void mouseDragged(MouseEvent me) {
               Graphics g = mImg.getGraphics();
               if ((me.getModifiers() & InputEvent.BUTTON1_MASK) != 0) {
                    g.setColor(mColor1);
               } else {
                    g.setColor(mColor2);
               Point p = me.getPoint();
               if (mLastPoint == null) {
                    g.fillOval(p.x - mBrushSize / 2, p.y - mBrushSize / 2, mBrushSize, mBrushSize);
                    //g.drawLine(p.x, p.y, p.x, p.y);
               else {
                    g.drawLine(mLastPoint.x, mLastPoint.y, p.x, p.y);
                    //g.fillOval(p.x - mBrushSize / 2, p.y - mBrushSize / 2, mBrushSize, mBrushSize);
                    double angle = MathUtils.angle(mLastPoint, p);
                    if (angle < 0) {
                         angle += 2 * Math.PI;
                    @SuppressWarnings("unused")
                    double distance = MathUtils.distance(mLastPoint, p) * 1.5;
                    if (angle < Math.PI / 4 || angle > 7 * Math.PI / 4 || Math.abs(Math.PI - angle) < Math.PI / 4) {
                         for (int i = 0; i < mBrushSize / 2; i ++) {
                              g.drawLine(mLastPoint.x, mLastPoint.y + i, p.x, p.y + i);
                              g.drawLine(mLastPoint.x, mLastPoint.y - i, p.x, p.y - i);
//                              System.out.println("y");
//                              System.out.println("angle = " + angle / Math.PI * 180);
                    else {
                         for (int i = 0; i < mBrushSize / 2; i ++) {
                              g.drawLine(mLastPoint.x + i, mLastPoint.y, p.x + i, p.y);
                              g.drawLine(mLastPoint.x  - i, mLastPoint.y, p.x - i, p.y);
//                              System.out.println("x");
//                    System.out.println("new = " + PaintUtils.printPoint(p));
//                    System.out.println("last = " + PaintUtils.printPoint(mLastPoint));
                    //System.out.println("distance = " + distance);
                    //Graphics2D g2 = (Graphics2D) g;
                    //g2.translate(mLastPoint.x + mBrushSize / 2, mLastPoint.y);
                    //g2.rotate(angle);
                    //g2.fillRect(0, 0, (int) Math.ceil(distance), mBrushSize);
                    //g2.rotate(-angle);
                    //g2.translate(-mLastPoint.x + mBrushSize / 2, -mLastPoint.y);
//                    g.setColor(Color.RED);
//                    g.drawRect(p.x, p.y, 1, 1);
               mLastPoint = p;
               g.dispose();
               repaint();
          public void mouseMoved(MouseEvent me) {}
          public void mouseReleased(MouseEvent me) {
               mLastPoint = null;
     private void handleResize() {
          Dimension size = getSize();
          mSizeChanged = false;
          if (mImg == null) {
               mImg = new BufferedImage(size.width, size.height, BufferedImage.TYPE_INT_RGB);
               Graphics g = mImg.getGraphics();
               g.setColor(getBackground());
               g.fillRect(0, 0, mImg.getWidth(), mImg.getHeight());
               g.dispose();
          else {
               int newWidth = Math.max(mImg.getWidth(),getWidth());
               int newHeight = Math.max(mImg.getHeight(),getHeight());
               if (newHeight == mImg.getHeight() && newWidth == mImg.getWidth()) {
                    return;
               BufferedImage bi2 = new BufferedImage(newWidth, newHeight, BufferedImage.TYPE_INT_RGB);
               Graphics g = bi2.getGraphics();
               g.setColor(getBackground());
               g.fillRect(0, 0, bi2.getWidth(), bi2.getHeight());
               g.drawImage(mImg, mImg.getWidth(), mImg.getHeight(), null);
               g.dispose();
               mImg = bi2;
     public JToolBar getToolBar() {
          if (mToolBar == null) {
               mToolBar = new ToolBar();
          return mToolBar;
     private ToolBar mToolBar;
     public static void main (String args[]) {
          PaintArea pa = new PaintArea();
          JPanel parent = new JPanel();
          parent.setLayout(new BorderLayout());
          parent.add(pa, BorderLayout.CENTER);
          pa.setPreferredSize(new Dimension(150, 150));
          parent.add(pa.getToolBar(), BorderLayout.NORTH);
          WindowUtilities.visualize(parent);
     protected class CListener extends ComponentAdapter {
          public void componentResized(ComponentEvent ce) {
               mSizeChanged = true;
}