Shapes return 0's as coordinates, width & height

[Veronique Kus]

Hi,
the code below is supposed to allow me to draw mutliple shapes.
Currently I'm trying to implement selecting shapes by clicking on them (to be able to drag them to a different location).
In the mouseClicked() method, I check whether the user just clicked inside a shape. However, it never returns true.
In the mouseExited() method I print width, height and class name of each of the shapes contained in the shapeList (which contains
all shapes drawn by the user). As it turns out, all shapes return zero values for width, height, central point coordinates etc. and I have no idea why?
My shape class extends the Rectangle2D.Double class so I don't know why methods like getHeight() etc. don't work properly on my shapes... If I override these methods
in my Shape implementation, they return correct values but I want to use the standard implementations contained in the Rectangle2D.Double class.

I would be veeery grateful for help with this!

 
import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;
import java.util.ArrayList;
import java.util.Iterator;

import javax.swing.*;

public class MapTab extends Tab {
	private DrawingCanvas drawingCanvas;

	public MapTab(JTabbedPane tabbedPane, String title) {
		super(tabbedPane, title);	
		this.setLayout(new GridLayout());
		addDrawingCanvas();	
	}
	
	private void addDrawingCanvas() {
		drawingCanvas = new DrawingCanvas();
		addMouseListener(drawingCanvas);
		addMouseMotionListener(drawingCanvas);
		add(drawingCanvas);
	    drawingCanvas.setOpaque(true);
	    drawingCanvas.setVisible(true);
	}
	
	public void drawShape(Shape shape){
		drawingCanvas.setShape(shape);
	}
	
	class DrawingCanvas extends JPanel implements MouseListener, MouseMotionListener {
		private ArrayList<Shape> shapeList;
		private Point sPoint = null;
	    private Point ePoint = null;
	    private Shape currentShape = null;
	    private Shape newShape = null;
	    private ArrayList list = new ArrayList();
	    
		public DrawingCanvas() {
			shapeList = new ArrayList<Shape>();
			this.setBackground(Color.WHITE);
		}
		
		@Override
		public void paintComponent(Graphics g)
		{
			super.paintComponent(g);
			Graphics2D g2 = (Graphics2D)g;
			//g2.setColor(Color.green);
			for(Shape s : shapeList){
				s.draw(g2);
			}
			if(currentShape != null){
				currentShape.draw(g2);
			}
		}
		
		public void setShape(Shape shape)
		{
		    this.currentShape = shape;
		}
		
		// Mouse events handling
		public void mouseClicked(MouseEvent e) {
			Point pointClicked = e.getPoint();
			System.out.println(pointClicked.getX() + " " + pointClicked.getY());
			for(Shape s : shapeList){
				if(s.contains(pointClicked)==true){
					System.out.println("Clicked inside shape");
				}
			}
		}
		
		public void mouseEntered(MouseEvent e){}
		public void mouseExited(MouseEvent e){
			for(Shape s : shapeList){
				System.out.println(s.getWidth() + " " + s.getHeight() + " " + s.getClass().getName());
			}
		}
		public void mousePressed(MouseEvent e) {
			if(currentShape != null) {
			    sPoint = e.getPoint();
			    ePoint = e.getPoint();
			    currentShape.setPoints(sPoint, ePoint);
			}
		}
		public void mouseReleased(MouseEvent e) {
			if(currentShape != null) {
			    ePoint = e.getPoint();
			    /* If shape not drawn from upper left to bottom right,
			     swap relevant coordinates */
			    swapPointsIfRequired();
			    /* Create a new shape instance with the point coordinates
			     * obtained and add the newly drawn shape to the shapeLsit.
			     */
			    if(currentShape instanceof RectangleShape){
			    	newShape = new RectangleShape(sPoint, ePoint);
			    	shapeList.add(newShape);
			    }else if(currentShape instanceof OvalShape){
			    	newShape = new OvalShape(sPoint, ePoint);
			    	shapeList.add(newShape);
			    }
			    
			    ePoint = null;
		    	sPoint = null;
			    repaint();
			}
	    }

		@Override
		public void mouseMoved(MouseEvent e) {
		    //saySomething("Mouse moved", e);
		}

		@Override
		public void mouseDragged(MouseEvent e) {
			if(currentShape != null) {
				ePoint = e.getPoint();
				//swapPointsIfRequired();
				//Grab the last shape from the shapeList - the current shape's outline
				//int i = shapeList.size() - 1;
				//Shape s = shapeList.get(i);
				currentShape.setEndPoint(ePoint);
				
				repaint();
			}
		}

		void saySomething(String eventDescription, MouseEvent e) {
		   System.out.println(eventDescription + " (" + e.getX() + "," + e.getY() + ")" + " detected on "
		        + e.getComponent().getClass().getName() + "\n");
		}
		
		public void swapPointsIfRequired() {
			if(ePoint.getX() < sPoint.getX())
		    {
		      Point temp = ePoint;
		      ePoint = sPoint;
		      sPoint = temp;
		    }
		    if(ePoint.getY() < sPoint.getY())
		    {
		      int temp = (int)ePoint.getY();
		      ePoint.y = (int)sPoint.getY();
		      sPoint.y = temp;
		    }
		}
	}	
	
}

import java.awt.*;
import java.awt.geom.Rectangle2D;

public abstract class Shape extends Rectangle2D.Double
{
	protected Point startPoint;
	protected Point endPoint;
	
  /**
   * Draw the shape.
   * @void
   */
  public abstract void draw(Graphics2D g);
  
  public void setPoints(Point p1, Point p2) {
	  startPoint = p1;
	  endPoint = p2;
  }
  
  public void setStartPoint(Point p){
		endPoint = p;
  }
  
  public void setEndPoint(Point p){
		endPoint = p;
  }
  
  public Point getStartPoint(){
	  return startPoint;
  }
  
  public Point getEndPoint(){
	  return endPoint;
  }
  
  /*public double getWidth(){
	  return endPoint.getX() - startPoint.getY();
  }*/
  
  public void swapPointsIfRequired() {
		if(endPoint.getX() < startPoint.getX())
	    {
	      Point temp = endPoint;
	      endPoint = startPoint;
	      startPoint = temp;
	    }
	   if(endPoint.getY() < startPoint.getY())
	    {
	      int temp = (int)endPoint.getY();
	      endPoint.y = (int)startPoint.getY();
	      startPoint.y = temp;
	    }
  }
}

class RectangleShape extends Shape
{	
	public RectangleShape() {
	}
	
	public RectangleShape(Point p1, Point p2) {
		super.startPoint = p1;
		this.endPoint = p2;
		//this.setFrameFromDiagonal(p1, p2);
	}
	
	@Override
	public void draw(Graphics2D g) {
		g.drawRect((int)startPoint.getX(), (int)startPoint.getY(), (int)(endPoint.getX()-startPoint.getX()),
			      (int)(endPoint.getY()-startPoint.getY()));
	}
  
}//rectangle

class OvalShape extends Shape
{	
	public OvalShape() {
	}
	
	public OvalShape(Point p1, Point p2) {
		this.startPoint = p1;
		this.endPoint = p2;
	}
	
	@Override
	public void draw(Graphics2D g) {
		g.drawOval((int)startPoint.getX(), (int)startPoint.getY(), (int)(endPoint.getX()-startPoint.getX()),
			      (int)(endPoint.getY()-endPoint.getY()));
		
	}
}

[Ernest Friedman-Hill]

Those "standard implementations" operate on the data held inside the Rect2D.Double class. Your subclass defines its own data, and it's only your own data that is initialized in your constructors. Instead, your implementation must use the member variables already defined in the superclass, and your constructors must make sure that data is initialized by calling the proper superclass constructors.

[Veronique Kus]

Forgot about an obvious thing, thank you.