Drawing text inside a Graphics2D shape

[Veronique Kus]

My application allows the user to draw shapes. Say I've got a rectangle (subclass of Rectangle2D.Double) drawn, now I want to allow the user to double click on the rectangle and a text field with flashing cursor should appear. The user can type in the desired text and pressed enter or click outside the shape to stop editing text. The text gets displayed inside the shape.

I was wondering if anyone could point me in the right direction for achieving the result described. For a start I don't want to get preoccupied with the flashing cursor, I just jneed the editable 2D text... My own ideas include creating a new inner class inside the shape class that would represent the text area and would extend the KeyAdapter class... or extend JTextArea... I thought about it but I'm not convinced to any of my ideas and I'm not even completely sure how I could go about implementing them. Would really appreciate some help.

Let me know if any more information is needed.

[Ulf Dittmer]

Extending JTextField or JTextArea sounds like a good idea, if those two classes don't provide the necessary functionality out of the box. Being Swing components, they can be positioned at a position of your choosing. And you can add a KeyListener to them in order to provide whatever behavior is desirable in response to keystrokes.

[Veronique Kus]

Ok thanks. I'm still not sure though about the specifics of the implementation... for example, how do I make the text area appear inside the desired shape? I mean, I don't think I can just add a JTextArea to a Rectangle2D object?

[Ulf Dittmer]

No, but you can put it at an absolute position. Since you know where the Rectangle2D object is (right?), you can calculate where the text field should be.

[Veronique Kus]

Ok I tried but for some reason it does not work. I'm posting below my DrawingCanvas class which is where all the shapes are drawn and where the JTextArea should also be drawn.

   
package code_tests;

import java.awt.Color;
import java.awt.Cursor;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.util.ArrayList;

import javax.swing.AbstractAction;
import javax.swing.ImageIcon;
import javax.swing.JMenuItem;
import javax.swing.JPanel;
import javax.swing.JPopupMenu;
import javax.swing.JTextArea;
import javax.swing.KeyStroke;

import mywordmaps.RectangularShape;
import mywordmaps.Shape;

public class DrawingCanvas extends JPanel implements MouseListener, MouseMotionListener {
		public static enum ShapeType { RECTANGLE, OVAL, ROUNDED_RECTANGLE, LINE};
		private JPopupMenu popupMenu = new JPopupMenu( "Menu" );
		private ArrayList<Shape> shapeList;
		private ShapeType currentShapeTool = null;
	    private Shape selectedShape = null;
	    private Shape draggedShape = null;
	    private Shape resizedShape = null;
	    private Shape newShape = null;
	    private Point mouseDown,  mouseHere, previousHere;
	    private boolean selected;
	    private Color currentFillColour = Color.orange;
	    private Color currentBorderColour = Color.black;
	    
		private static final int DELETE_KEY = 127;
	    private static final double RESIZE_AREA = 8.00;    	   
	    
		public DrawingCanvas() {
			shapeList = new ArrayList<Shape>();
			this.setBackground(Color.WHITE);
			selected = false;
			addKeyEvents();
			createPopupMenu();
		}
		
		private void createPopupMenu(){
			// Create some menu items for the popup
			JMenuItem moveForwards = new JMenuItem("Move forwards", new ImageIcon("icons/front24.png"));
			JMenuItem moveBackwards = new JMenuItem("Move backwards", new ImageIcon("icons/back24.png") );
			JMenuItem deleteElement = new JMenuItem("Delete", new ImageIcon("icons/trash.png") );
		
			moveForwards.addActionListener(new ActionListener(){
				public void actionPerformed(ActionEvent e) {
					moveElementForward();
				}
			});
			moveBackwards.addActionListener(new ActionListener(){
				public void actionPerformed(ActionEvent e) {
					moveElementBack();
				}
			});
			deleteElement.addActionListener(new ActionListener(){
				public void actionPerformed(ActionEvent e) {
					deleteSelectedElement();
				}
			});
			
			// Create a popup menu
			popupMenu.add( moveForwards );
			popupMenu.add( moveBackwards );
			popupMenu.add( deleteElement );
			this.add(popupMenu);
		}
		
		/**
		 * @return the current colour used for filling.
		 */
		public Color getCurrentFillColour(){
			return currentFillColour;
		}
		/**
		 * Sets the current colour used for filling.
		 * @param c Color to be used
		 */
		public void setCurrentFillColour(Color c) {
			currentFillColour = c;
			if(selectedShape != null){
				selectedShape.setFillColour(c);
			}
			repaint();
		}
		/**
		 * @return the current colour used for stroking
		 */
		public Color getCurrentBorderColour(){
			return currentBorderColour;
		}
		/**
		 * Sets the current colour used for stroking.
		 * @param c Color to be used
		 */
		public void setCurrentBorderColour(Color c){
			currentBorderColour = c;
			if(selectedShape != null){
				selectedShape.setBorderColour(c);
			}
			repaint();
		}

		/*
		 * Adds key event handling to the instance of the 
		 * DrawingCanvas class.
		 */
		private void addKeyEvents(){
			getInputMap().put(KeyStroke.getKeyStroke(KeyEvent.VK_DELETE, 0),
            "deleteShape");
			getActionMap().put("deleteShape", new DeleteShapeAction());
		}
		
		@Override
		public void paintComponent(Graphics g)
		{
			super.paintComponent(g);
			Graphics2D g2 = (Graphics2D)g;
			for(Shape s : shapeList){
				s.draw(g2);
			}
			
			//Draw the outline of the shape currently being drawn
			if(currentShapeTool != null && newShape != null){
				newShape.draw(g2);
			}
		}
			
		/*
		 * Moves the selected element in specified direction (front/back)
		 * @param direction
		 */
		private void moveElementBack(){
			assert (shapeList.contains(selectedShape));
			assert (selected == true && selectedShape != null);
			
			int index = shapeList.indexOf(selectedShape);
			if(index >= 1){
				Shape temp = shapeList.get(index - 1);
				shapeList.set(index-1, selectedShape);
				shapeList.set(index, temp);
				repaint();
			}
		}
		
		private void moveElementForward(){
			assert (shapeList.contains(selectedShape));
			assert (selected == true && selectedShape != null);
			
			int index = shapeList.indexOf(selectedShape);
			if(index < shapeList.size()-1){
				Shape temp = shapeList.get(index + 1);
				shapeList.set(index+1, selectedShape);
				shapeList.set(index, temp);
				repaint();
			}
		}
		
		/*
		 * Removes the selected elements (if there is one selected).
		 */
		private void trashElement(){
			deleteSelectedElement();
		}
		
		protected void deleteSelectedElement(){
			if(selectedShape != null && selected == true){
				  shapeList.remove(selectedShape);
				  selected = false;
				  repaint();
			  }
		}
		/**
		 * Sets the currently used map drawing tool.
		 * @param shape String which describes the shape
		 * to be set as the currently used.
		 */
		public void setCurrentMapTool(String shape)
		{
			if(shape.equals("Cursor")) {
				currentShapeTool = null;
			}else if(shape.equals("Rectangle")){
				currentShapeTool = ShapeType.RECTANGLE;
			}else if(shape.equals("RoundedRectangle")){
				currentShapeTool = ShapeType.ROUNDED_RECTANGLE;
			}else if(shape.equals("Oval")){
				currentShapeTool = ShapeType.OVAL;
			}else if(shape.equals("Line")){
				currentShapeTool = ShapeType.LINE;
			}  
		}
		
		/** 
		 * @return The currently used drawing tool.
		 */
		public ShapeType getCurrentShape() {
			return currentShapeTool;
		}
		
		/*
		 * Checks whether the mouse event passed to it should
		 * cause an element of the map to be selected/deselected.
		 * @param e
		 */
		private void reviewSelections(MouseEvent e){
			/*To start with, unselect all shapes*/
			for(Shape s : shapeList){
				s.setSelected(false);
			}
			selected = false;
			selectedShape = null;
			
			//Selections can only be made when the selection tool is active
			//if(currentShapeTool == null) {
			
			/* On mouse release after dragging/resizing,
			 * the shape should remain selected
			 */
			if(e.getID() == MouseEvent.MOUSE_RELEASED){
				if(resizedShape != null){
					selected = true;
					selectedShape = resizedShape;
					resizedShape.setSelected(true);
					repaint();
					return;
				}else if(draggedShape != null){
					selected = true;
					selectedShape = draggedShape;
					draggedShape.setSelected(true);
					repaint();
					return;
				}else{
					return;
				}
			}
			
			/* 
			 * Traverse the shape list to the end, the last shape 
			 * which contains the point given will be the most
			 * frontmost of all shapes which contain this point
			 * (shapes more to the front are located closer to the end 
			 * of the list of shapes). This frontmost of all shapes is
			 * the one that should get selected.
			 */
			for(Shape s : shapeList){
				if( s.contains(e.getPoint()) == true ){
					selectedShape = s;
				}
			}
			if(selectedShape != null){
				selected = true;
				selectedShape.setSelected(true);
				/*if(e.getID() == MouseEvent.MOUSE_CLICKED){
					//TODO - make it so that buttons are pressed/unpressed
					currentShapeTool = null;
				}*/
			}
			repaint();
		}
		
		/**
		 * Changes the cursor to move_cursor if it is hovered over the current selection outline.
		 * Otherwise sets cursor to default .
		 * @param e
		 */
		public void checkIfChangeCursor(MouseEvent e){
			if(selected == true && selectedShape != null) {
				if(selectedShape.getShapeType()==ShapeType.RECTANGLE ||
						selectedShape.getShapeType()==ShapeType.ROUNDED_RECTANGLE ||
						selectedShape.getShapeType()==ShapeType.OVAL){
						if(((RectangularShape) selectedShape).insideResizeArea(e.getPoint())){
							resizedShape = selectedShape;
							setCursor(Cursor.getPredefinedCursor(Cursor.SE_RESIZE_CURSOR));
							return;
						}
				}
			}

			setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
		}
		
		/******************************************************************************
		 ************************	MOUSE EVENT HANDLING ****************************** 
		 ******************************************************************************/
		
		public void mouseEntered(MouseEvent e){}
		public void mouseExited(MouseEvent e){}
		
		/**
		 * Sets the focus on the current map and checks whether
		 * a shape has been clicked and so should be selected.
		 */
		public void mouseClicked(MouseEvent e) {
			requestFocus(false);
			reviewSelections(e);
			checkIfChangeCursor(e);
			if (e.getClickCount() == 2 && e.getButton() == MouseEvent.BUTTON1) {
				if(selectedShape != null){
					//selectedShape.setText();
					this.add(new JTextArea("hello!!!"));
				}
			}
		}
		
		/**
		 * Checks whether any shape should be selected and whether
		 * any shape should be marked as being dragged.
		 * Records the coordinates of the location of the mouse press event.
		 */
		public void mousePressed(MouseEvent e) {
			if( e.isPopupTrigger() )
			{
				if(selected == true && selectedShape != null
						&& shapeList.size() >= 1){
					popupMenu.show(this,
									e.getX(), e.getY() );
				}
			}
			
			draggedShape = null;
			resizedShape = null;
			mouseDown = e.getPoint();
			reviewSelections(e);
			
			//Shape drawing mode
			if(currentShapeTool == ShapeType.RECTANGLE ||
				currentShapeTool == ShapeType.OVAL ||
				currentShapeTool == ShapeType.ROUNDED_RECTANGLE) {
			    newShape = new RectangularShape(e.getPoint(), e.getPoint(), 
			    		currentShapeTool, currentFillColour);
			//Line drawing mode
			}else if (currentShapeTool == ShapeType.LINE){
				Shape n = null;
				//go to the end and pick the frontmost shape
				for(Shape s : shapeList){
					if( s.contains(e.getPoint()) == true ){ 
						n = s;
					}
				}
				// Mouse pressed inside a selected shape
				if(selected == true) { 
					System.out.println("Center: " + n.getCenter().getX());
					newShape = new RectangularShape(n.getCenter(), e.getPoint(), 
				    		currentShapeTool, currentFillColour);
				}
			//Selection mode (cursor tool)
			}else if (currentShapeTool == null){
				Shape n = null;
				//go to the end and pick the frontmost shape
				for(Shape s : shapeList){
					if( s.contains(e.getPoint()) == true ){ 
						n = s;
					}
				}
				if(n != null){
					// Mouse pressed inside a selected shape
					if(selected == true &&
							getCursor() == Cursor.getPredefinedCursor(Cursor.SE_RESIZE_CURSOR)) { 
						resizedShape = n;
						mouseDown = e.getPoint();
						return;
					}else{
						// Mouse pressed inside an unselected shape
						/*this caused selection of multiple shapes
						selectedShape = s;
						s.setSelected(true);
						selected = true;*/
						draggedShape = n;
						mouseDown = e.getPoint();
						draggedShape.setOffset(mouseDown);
					}
				}
			}
		}
		
		/**
		 * Checks whether a shape should remain selected and whether
		 * any new shapes should be added to the list of shapes drawn.
		 */
		public void mouseReleased(MouseEvent e) {
			if( e.isPopupTrigger() )
			{
				if(selected == true && selectedShape != null
						&& shapeList.size() >= 1){
					popupMenu.show(this,
									e.getX(), e.getY() );
				}
			}
			
			if(currentShapeTool != null) {
			    /*Create a new shape only if it's not a single point*/
				if(newShape != null){
				    if(!newShape.getStartPoint().equals(newShape.getEndPoint())){
					    shapeList.add(newShape);
					    repaint();
				    }
				}
			}
			newShape = null;
			mouseDown = null;
			mouseHere = null;
			reviewSelections(e);
	    }

		@Override
		public void mouseMoved(MouseEvent e) {
			checkIfChangeCursor(e);
		}

		@Override
		public void mouseDragged(MouseEvent e) {
			if(mouseHere!=null){
				previousHere = mouseHere;
				mouseHere = e.getPoint();
			}else{
				previousHere = mouseHere = e.getPoint();
			}
		
			//Drawing new shape
			if(currentShapeTool == ShapeType.RECTANGLE ||
			currentShapeTool == ShapeType.OVAL ||
			currentShapeTool == ShapeType.ROUNDED_RECTANGLE) {
				if(newShape != null){
					/*Swap shape coordinates if required
					i.e. if shape is not drawn from upper-left 
					to bottom-right corner*/
					double downX = mouseDown.getX();
		            double downY = mouseDown.getY();
		            double hereX = mouseHere.getX();
		            double hereY = mouseHere.getY();
		 
		            double startX = Math.min(downX, hereX);
		            double startY = Math.min(downY, hereY);
		            double w = Math.abs(downX - hereX);
		            double h = Math.abs(downY - hereY);
					double endX = startX + w;
					double endY = startY + h;
	
					newShape.setStartPoint(new Point((int)startX, (int)startY));
					newShape.setEndPoint(new Point((int)endX, (int)endY));
				}
			//Drawing new line
			}else if (currentShapeTool == ShapeType.LINE){
				if(newShape != null){
					newShape.setEndPoint(mouseHere);
				}
			}else{
			//Cursor tool
				mouseHere = e.getPoint();
				//Dragging
				if(draggedShape != null){
					draggedShape.setLocation(mouseHere);
				}
				//Resizing
				if(resizedShape != null){					
					int cursor = getCursor().getType();
					if(cursor == Cursor.SE_RESIZE_CURSOR) {
						Point end1 = resizedShape.getEndPoint();
						Point center = resizedShape.getCenter();
                    	
                    	//start point goes in the other direction
                    	double x = resizedShape.getStartPoint().getX();
                    	double y = resizedShape.getStartPoint().getY();
                    	double offsetX = Math.abs(previousHere.getX()-mouseHere.getX());
                    	double offsetY = Math.abs(previousHere.getY()-mouseHere.getY());
                    	int newX = 0;
                    	int newY = 0;
                    	if(resizedShape.getEndPoint().getX()<end1.getX() ||
                    			resizedShape.getEndPoint().getY()<end1.getY()){
                    		newX = (int) (x + offsetX);
                        	newY = (int) (y + offsetY);
                    	}else{
                    		newX = (int) Math.abs(x - offsetX);
                        	newY = (int) Math.abs(y - offsetY);
                    	}

                    	resizedShape.setStartPoint(new Point(newX, newY));    
                    	//resizedShape.setEndPoint(mouseHere);
                    	resizedShape.setFrameFromCenter(center, mouseHere);
					}	
				}
			}
			repaint();
		}
		
		class DeleteShapeAction extends AbstractAction {
		    public DeleteShapeAction() {
		    }
		    public void actionPerformed(ActionEvent e) {
				  deleteSelectedElement();
		    }
		}
	}
 

So in the mouseClicked() method I'm trying to display a JTextArea anywhere (for now) on the drawingCanvas object but it doesn't appear when I double click (and I've got a shape selected). Is there something wrong with this call? The task looks pretty simple, I must be not seeing something obvious...

if (e.getClickCount() == 2 && e.getButton() == MouseEvent.BUTTON1) {
				if(selectedShape != null){
					//selectedShape.setText();
					this.add(new JTextArea("hello!!!"));
				}
			}    

[Veronique Kus]

If anyone would like to run this code I'm posting the other classes needed:

    
import java.awt.*;
import mywordmaps.RectangularShape.ShapeType;

public interface Shape
{	
	void draw(Graphics2D g);
	void setPoints(Point p1, Point p2);
	void setStartPoint(Point p);
	void setStartPoint(double x, double y);
	Point getStartPoint();
	void setEndPoint(Point p);
	Point getEndPoint();
	void setLocation(Point p);
	void setText();
	void setX(double x);
	double getX();
	void setY(double y);
	double getY();
	void setFillColour(Color c);
	void setBorderColour(Color c);
	void setSelected(boolean b);
	void setOffset(Point p); //for dragging
	boolean contains(Point pointClicked);
	
	int TEXTAREA_OFFSET = 25;
	int SELECTION_OFFSET = 5;
	final float dash1[] = {2.0f};
    final BasicStroke dashed = new BasicStroke(1.0f, 
            BasicStroke.CAP_BUTT, 
            BasicStroke.JOIN_MITER, 
            10.0f, dash1, 0.0f);
    final BasicStroke defaultStroke = new BasicStroke();
	
	void setWidth(double w);
	void setHeight(double h);
	abstract double getWidth();
	abstract double getHeight();
	ShapeType getShapeType();
	Point getCenter();
	void setFrameFromCenter(Point p1, Point p2);
}	

   
import java.awt.*;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.geom.Line2D;
import java.awt.geom.Rectangle2D;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;
import javax.swing.JTextArea;

public class RectangularShape extends Rectangle2D.Double implements Shape{
	public static enum ShapeType { RECTANGLE, OVAL, ROUNDED_RECTANGLE, LINE};
	
	private Point offset = new Point();
	private String text = "l";
	private Color fillColour;
	private Color borderColour = Color.black;
	private Color textColour = Color.black;
	private boolean selected = false;
	private ShapeType shapeType = null;
	private int ARC_WIDTH = 10;
	private int ARC_HEIGHT = 10;
	private int resizeArea_x1 = 0;
	private int resizeArea_y1 = 0;
	private int resizeSquare_size = 4;
	private int borderSize = 1;
	BufferedImage resizeIcon = null;
	private TextField textField = new TextField();
	
	public RectangularShape(Point p1, Point p2, ShapeType s, Color c) {
		super(p1.getX(), p1.getY(), p2.getX()-p1.getX(), p2.getY()-p1.getY());
		shapeType = s;
		fillColour = c;
		selected = false;
	}
	
	public RectangularShape(double x, double y, double w, double h, ShapeType s, Color c) {
		super(x,y,w,h);
		shapeType = s;
		fillColour = c;
		selected = false;
	}
	
	public RectangularShape(ShapeType s) { 
		shapeType = s;
		selected = false;
		fillColour = Color.yellow;
	}
	
	public ShapeType getShapeType(){
		return shapeType;
	}
	
	@Override
	public void draw(Graphics2D g2) {
		//TODO g2 vs g?
		g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, 
				RenderingHints.VALUE_ANTIALIAS_ON);
		g2.setStroke(defaultStroke);
		switch (shapeType) {
			case RECTANGLE: 
				g2.setColor(borderColour);
				g2.drawRect((int)super.x, (int)super.y, 
						(int)super.width, (int)super.height);
				g2.setColor(fillColour);
				g2.fillRect((int)super.x+borderSize, (int)super.y+borderSize, 
						(int)super.width-borderSize, (int)super.height-borderSize);
				break;	
			case OVAL:
				g2.setColor(borderColour);
				g2.drawOval((int)super.x, (int)super.y, 
						(int)super.width, (int)super.height);
				g2.setColor(fillColour);
				g2.fillOval((int)super.x+borderSize, (int)super.y+borderSize, 
						(int)super.width-borderSize, 
						(int)super.height-borderSize);
				break;
			case ROUNDED_RECTANGLE:
				g2.setColor(borderColour);
				g2.drawRoundRect((int)super.x, (int)super.y, (int)super.width, 
						(int)super.height, ARC_WIDTH, ARC_HEIGHT);
				g2.setColor(fillColour);
				g2.fillRoundRect((int)super.x+borderSize, (int)super.y+borderSize, 
						(int)super.width-borderSize, (int)super.height-borderSize, 
						ARC_WIDTH, ARC_HEIGHT);
				break;	
			case LINE:
				g2.setColor(fillColour);
				g2.draw(new Line2D.Double((int)super.x, (int)super.y, 
						(int)getEndPoint().getX(), (int)getEndPoint().getY()));
				break;	
		}
		
		if(shapeType != ShapeType.LINE){
			//Draw the resize button
			if(selected){
				try {
					resizeIcon = ImageIO.read(new File("icons/resize.png"));
					resizeArea_x1 = (int)(super.x + super.width) - resizeIcon.getWidth();
					resizeArea_y1 = (int)(super.y+super.height) - resizeIcon.getHeight();
					//draw white background for the icon only if the shape is black
					if(fillColour.equals(Color.black)){
						g2.drawImage(resizeIcon, resizeArea_x1, resizeArea_y1, 
								Color.white, null);
					}else{
						g2.drawImage(resizeIcon, resizeArea_x1, resizeArea_y1, 
								null, null);
					}
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				/*Rectangle2D.Double r = new Rectangle2D.Double(x1-5, y1-5, 10, 10);
				g2.setColor(Color.black);
				g2.drawRect(x1-5, y1-5, 10, 10);
				g2.setColor(Color.white);
				g2.fill(r);*/
			}
			//g2.drawLine(x1-2, y1-2, x1+2, y1+2);
			g2.setColor(fillColour);
			
			//Draw text
			if(text != null){
				g2.setColor(textColour);
				g2.drawString(textField.getText(), (int)super.x + TEXTAREA_OFFSET, 
						(int)super.y + TEXTAREA_OFFSET); 
				g2.setColor(fillColour);
			}
			if(selected){
				int selectionX = (int) (getStartPoint().getX() - SELECTION_OFFSET);
				int selectionY = (int) (getStartPoint().getY() - SELECTION_OFFSET);
				int selectionWidth = (int) (getWidth() + 2*SELECTION_OFFSET);
				int selectionHeight = (int) (getHeight() + 2*SELECTION_OFFSET);
				g2.setColor(Color.black);
				g2.setStroke(dashed);
				g2.drawRect(selectionX, selectionY, selectionWidth, selectionHeight);
				g2.setColor(fillColour);
				g2.setStroke(defaultStroke);
			}
		}else{
			if(selected){
				g2.setColor(Color.black);
				g2.drawRect((int)x - resizeSquare_size, (int)y - resizeSquare_size, 
						resizeSquare_size, resizeSquare_size);
				g2.drawRect((int)getEndPoint().getX(), (int)getEndPoint().getY(), 
						resizeSquare_size, resizeSquare_size);
				g2.setColor(fillColour);
			}
		}
	}
	
	public boolean insideResizeArea(Point p){
		Rectangle2D.Double r = new Rectangle2D.Double();
		if(resizeIcon!=null){
			r = new Rectangle2D.Double(resizeArea_x1,resizeArea_y1,
				resizeIcon.getWidth(),resizeIcon.getHeight());
		}
		if(r.contains(p)){
			return true;
		}else{
			return false;
		}
	}
	
	public void setText(){
		textField.requestFocusInWindow();
		textField.setVisible(true);
	}
	
	@Override
	public boolean contains(Point p) {
		return super.contains(p);
	}
	
	@Override
	public void setEndPoint(Point p) {
		width = p.getX() - x;
		height = p.getY() - y;	
	}
	
	@Override
	public Point getEndPoint() {
		double x = this.x + width;
		double y = this.y + height;
		Point p = new Point((int)x, (int)y);
		return p;
	}
	
	@Override
	public Point getStartPoint() {
		Point p = new Point((int)x, (int)y);
		return p;	
	}
	
	@Override
	public void setStartPoint(Point p) {
		x = p.getX();
		y = p.getY();
	}
	
	@Override
	public void setPoints(Point p1, Point p2) {
		x = p1.getX();
		y = p1.getY();
		width = p2.getX()-p1.getX();
		height = p2.getY()-p1.getY();
	}

	@Override
	public void setWidth(double w) {
		this.width = w;	
	}
	@Override
	public double getWidth(){
		return width;	
	}
	
	@Override
	public void setHeight(double h) {
		this.height = h;	
	}
	public double getHeight(){
		return height;	
	}
	
	@Override
	public void setStartPoint(double x, double y) {
		this.x = x;
		this.y = y;
	}
 
    public void setOffset(Point p) {
       offset.x = p.x - (int) x;
       offset.y = p.y - (int) y;
    }

    public void setLocation(Point p) {
       x = p.x - offset.x;
       y = p.y - offset.y;
    }
    
    @Override
	public void setX(double x) {
		this.x = x;
	}
    
    public double getX(){
    	return x;
    }
    
	@Override
	public void setY(double y) {
		this.y = y;
	}
	
	public double getY(){
	    return y;
	}
	
	@Override
	public void setFillColour(Color c) {
		this.fillColour = c;
	}

	@Override
	public void setBorderColour(Color c) {
		this.borderColour = c;
	}
	
	@Override
	public void setSelected(boolean b) {
		selected = b;
	}

	@Override
	public Point getCenter() {
		return new Point((int)super.getCenterX(), (int)super.getCenterY());
	}
	
	public void setFrameFromCenter(Point p, Point end) {
		super.setFrameFromCenter(p, end);
	}
}
 

[Ulf Dittmer]

You need to call a setLayout(null) on the JPanel, and you also need to call setBounds on the JTextArea with the coordinates where it should be placed (and then possibly call repaint). This explains it: Doing Without a Layout Manager (Absolute Positioning)

[pete stein]

Suggestions unrelated to your original problem but which I tripped over on reading your code:

1) Don't mix AWT components (i.e., TextField) with Swing components (everything else).
2) I'd rename Shape to be some other name as it conflicts with the Shape interface in the AWT library.
3) Don't declare your enum as several static inner classes. Use one single enum in its own file.

Hopefully more to come,... but it's a lot of code.
4) Simplify your code so that the current code is for testing and solving your current problem only and that's it. Get rid of all unrelated code. This unrelated code may be necessary to the final product sure, but it's only getting in the way of your and our understanding of the problem at hand.

Much luck!

[Veronique Kus]

Wow, you guys are fast with replying!
Ulf, I'll try it out in a sec.
Pete, thanks for the suggestions. I was also wondering... don't you think it's a little bit weird that drawing lines is also handled by the RectangularShape class? I had some serious problems trying to think of a good design for handling the shapes... I need all shapes to share a common interface since all of them are stores in one ArrayList (so that they can all be painted together). But I'm thinking maybe I should have two or more lists from which different kinds of shapes would be drawn....
this would mean though that I would have to check for different classes when handling shapes (because, for example, a line would not have a getCenter() method and rectangular shapes would) and I don't know which would be better - awkward design and a single list or more reasonable desing and more than one list containing different classes of shapes.

[Veronique Kus]

Ok, so this works, thank you. However, I'm still wondering if there's any way of creating text inside shapes using the graphics' drawString method? It sounds more appealing to me because I would be able to draw the string when the shape is drawn, so they would be bound together. In case of JTextAreas, I need to record the shape which the text area belongs to and the position of the text area... Maybe a text area could appear only for editing and then the text would be recorded and drawn using the drawString() method - do you thing this would be a good approach?

[Ulf Dittmer]

However, I'm still wondering if there's any way of creating text inside shapes using the graphics' drawString method? It sounds more appealing to me because I would be able to draw the string when the shape is drawn, so they would be bound together. In case of JTextAreas, I need to record the shape which the text area belongs to and the position of the text area... Maybe a text area could appear only for editing and then the text would be recorded and drawn using the drawString() method - do you thing this would be a good approach?

Yes, absolutely. The JTextArea is for entering the text, and then it should be drawn using drawString, and the JTextArea removed. I actually assumed that's what you had in mind.

[Rob Spoor]

Veronique Kus wrote:Maybe a text area could appear only for editing and then the text would be recorded and drawn using the drawString() method - do you thing this would be a good approach?

That's probably what I would have done. You can even use one single JTextField (or JTextArea for multilines) and reuse it. You create and add it at the start of the program but hide it (setVisible(false)). When you double click on a shape you move it to the right position (setBounds), show it (setVisible(true)) and use it. When done* get its text, store it with the shape, and hide the field again. The shape will then use drawString to draw its text.

* using a FocusListener. With JTextField you can also use an ActionListener to listen for enter presses.