Resizing, Dragging and Rotating

[Jonathan Johansen]

Hello everyone! I will try to explain myself and I apologize ahead of time in case I don't accomplish it(English is not my first language).
Well, I am trying to create a component which can be rotated, re-sized and dragged (almost got it working). The problem is the following, I re-size it and it re-sizes as much as I drag it, however, it need to re-size to the size of the diagonal so when it rotates is still visible. If you were so kind to compile the code I have attached and see it working so you get a better idea of I am saying. Thanks everyone for your time and help!


This is my main class

import javax.swing.event.*;
import java.awt.event.*;
import javax.swing.*;
import java.awt.*;

public class Demo extends JFrame
{
	private JPanel container =  new JPanel(null);
	private GeometricShape shape = new GeometricShape(175, 250);
	private JButton rotator = new JButton("Rotate To ");
	
	public static void main(String ... args)
	{
		new Demo();
	}
	public Demo()
	{
		rotator.addActionListener(new ActionListener()
		{
			double degrees = 0;
			public void actionPerformed(ActionEvent e)
			{
				shape.rotateCounterClockwiseInDegrees(degrees+=15);	
			}
		});
		
		shape.addMouseMotionListener(Mouse.createRelocatorHandler());
		
		
		container.add(rotator).setBounds(250, 0, 100, 25);
		container.add(shape).setBounds(0, 0, 175, 250);
		//shape.setRectBounds(0, 0, 175, 250);
		container.setBackground(Color.white);
		
		this.setLocationRelativeTo(null);
		this.add(container, "Center");
		this.setSize(600, 400);
		this.setVisible(true);
	}
}

This is the class definition of the component that is rotated

import java.awt.RenderingHints;
import java.awt.Component;
import java.awt.Graphics2D;
import java.awt.Graphics;
import java.awt.Rectangle;
import java.awt.Color;
import java.awt.FontMetrics;
import java.awt.GradientPaint;
import java.awt.BasicStroke;
import java.awt.Font;

import java.awt.Shape;
import java.awt.geom.RoundRectangle2D;
import java.awt.geom.Ellipse2D;

public class GeometricShape extends Component
{	
	private final int RECTANGLE = 0;
	private final int OVAL = 1;
	
	private Font font = new Font("PLAIN", Font.BOLD, 20);
	private String text = new String("Message");
	private boolean marked = true;
	private double diagonal = 0;
	private double radians = 0;
	private int selection = 1;
	private int height = 0;
	private int width = 0;
	private Shape border;
	private Shape shape;
	
	
	public GeometricShape(int w, int h)
	{
		createComponent(0, 0, w, h);
	}
	private void createComponent(int x, int y, int w, int h)
	{
		border = createShape(x, y, --w, --h);
		shape = createShape(x, y, --w, --h);
	}
	public void rotateCounterClockwiseInDegrees(double degrees)
	{
		rotate(-Math.toRadians(degrees));
	}
	public void rotateCounterClockwiseInRadians(int radians)
	{
		rotate(-radians);
	}
	public void rotateClockwiseInDegrees(double degrees)
	{
		rotate(Math.toRadians(degrees));
	}
	public void rotateClockwiseInRadians(double radians)
	{
		rotate(radians);
	}
	public void rotate(double radians)
	{
		this.radians = (radians % (2 * Math.PI));
		repaint();
	}
	@Override
	public void setBounds(int x, int y, int w, int h)
	{	
		diagonal = computeDiagonal(x, y, w, h);
		super.setBounds(x, y, w, h);
		this.height = h;
		this.width = w;
	}
	@Override
	public boolean contains(int x, int y)
	{
		return shape.contains(x, y);
	}
	private double computeDiagonal(int x, int y, int w, int h)
	{
		return Math.ceil(Math.sqrt(
					Math.pow(w, 2) + 
						Math.pow(h, 2)));
	}
	
 	public Shape createShape(float x, float y, float w, float h)
 	{
 		switch(selection)
 		{
 			case OVAL:
 				return new Ellipse2D.Float(x, y, w, h);
        		
 			case RECTANGLE:
        		return new RoundRectangle2D.Float(x, y, w, h, 3, 3);			
 		}
 		return null;
 	}
	@Override
    public void paint(Graphics g) 
    {
        Graphics2D g2d = (Graphics2D) g;

		//width = this.getWidth();
		//height = this.getHeight();

		createComponent(0, 0, width, height);
		
		Rectangle rect = shape.getBounds();
		
		g2d.drawLine(0, 0, 0, height);
		g2d.drawLine(width-1, 0, width-1, height);
		
     	g2d.setPaint(new GradientPaint((width / 2), (height / 2), 
     					Color.cyan, (width / 2), height, Color.gray, true));
     					
		g2d.setRenderingHint(
			RenderingHints.KEY_ANTIALIASING, 
				RenderingHints.VALUE_ANTIALIAS_ON);
		
		g2d.setStroke(new BasicStroke(3.0f, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
		
		
		//if(radians != -1)
		{
	        g2d.translate(width / 2, height / 2);
	        
	        g2d.rotate(radians);
	        
	        g2d.translate(-rect.width / 2, -rect.height/ 2);
	        
		}        	
        g2d.fill(shape);
        
        
        g2d.setFont(font);
        g2d.setColor(Color.black);
        
        FontMetrics fm = g2d.getFontMetrics();
		g2d.drawString(text, 
			(rect.width / 2) - (fm.stringWidth(text) / 2), 
				(rect.height / 2) + (fm.getHeight() / 4));
				
		g2d.draw(border);
				
		if(marked)
		{
			g2d.setColor(Color.red);
			
			int rw = (int)(rect.width * .25);
			int rh = (int)(rect.height * .25);
	        
	        g2d.drawLine(rect.x + rw, rect.y + rh, 
	        	rect.x + rect.width - rw, rect.y + rect.height - rh);
	        	
	       	g2d.drawLine(rect.x + rw, rect.y + rect.height - rh, 
	       		rect.x + rect.width - rw, rect.y + rh);	
		}       		
    }
}

This is the MouseListener

import java.awt.event.MouseMotionAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.MouseAdapter;
import java.awt.Component;
import java.awt.Point;
import java.awt.Container;
import java.awt.Rectangle;
import java.awt.Cursor;

public class Mouse //extends MouseAdapter 
{
	public static final int RESIZE_REALLOCATE = 2;
	public static final int REALLOCATE = 1;
	public static final int RESIZE = 0;
	public static int ACTION_TYPE = 2;
	
    // Give user some leeway for selections.
    private static final int PROX_DIST = 7;
    private static final int min_h = 50;	
    private static final int min_w = 75;

    
    protected static Component component;
    protected static Container parent;
    protected static int type;
    
    
    public static Relocator createRelocatorHandler()
    {
    	return new Relocator();
    }
    public static class Relocator extends MouseMotionAdapter
    {
		/*
		 *	Determine the teask to be performed by mouse depending on if-then
		 *	
		 *	#see relocateComponent(MouseEvent)
		 *	#see resize(MouseEvent)
		 */
	    public void mouseDragged(MouseEvent e) 
	    {
	    	parent = component.getParent();
			switch((type = ((component.getCursor()).getType())))
			{
	        	case Cursor.SE_RESIZE_CURSOR:
	        	case Cursor.NE_RESIZE_CURSOR:
	        	case Cursor.SW_RESIZE_CURSOR:
	        	case Cursor.NW_RESIZE_CURSOR:
	        	case Cursor.N_RESIZE_CURSOR:
	        	case Cursor.S_RESIZE_CURSOR:
	        	case Cursor.W_RESIZE_CURSOR:
	        	case Cursor.E_RESIZE_CURSOR:
	        		resizeComponent(e);
	        		break;
				case Cursor.MOVE_CURSOR:
	        		relocateComponent(e);
	        		break;	
	        	case Cursor.DEFAULT_CURSOR:
	        		break;
			}    	
			parent.setComponentZOrder(component, 0);
	    }
	    /*
	     *	
	     */
	    public void mouseMoved(MouseEvent e) 
	    {
	 		component = e.getComponent();
	 		parent = component.getParent();
			parent.setComponentZOrder(component, 0);
			component.setCursor(Cursor.getDefaultCursor());
	 		switch(ACTION_TYPE)
	 		{
	 			case RESIZE_REALLOCATE:
	 				if(!mouseAtCenter(e))
	 					mouseOverEdge(e);	
	 				break;
	 			case REALLOCATE:
	 				mouseAtCenter(e);
	 				break;
	 			case RESIZE:
	 				mouseOverEdge(e);
	 				break;
	 		}
	    } 	
	   	public void mouseOverEdge(MouseEvent e)
	   	{
	        Point p = new Point(e.getX() + component.getX(), e.getY() + component.getY());
	        if(isOverRect(p)) 
	        {
	        
		        Rectangle r = component.getBounds();
		        switch(getOutcode(p)) 
		        {
		            case Rectangle.OUT_TOP:
		                if(Math.abs(p.y - r.y) < PROX_DIST) 
		                {
		                    component.setCursor(Cursor.getPredefinedCursor(
		                                        Cursor.N_RESIZE_CURSOR));
		                }
		                break;
		            case Rectangle.OUT_TOP + Rectangle.OUT_LEFT:
		                if(Math.abs(p.y - r.y) < PROX_DIST 
		                && Math.abs(p.x - r.x) < PROX_DIST) 
		                {
		                    component.setCursor(Cursor.getPredefinedCursor(
		                                        Cursor.NW_RESIZE_CURSOR));
		                }
		                break;
		            case Rectangle.OUT_LEFT:
		                if(Math.abs(p.x - r.x) < PROX_DIST) 
		                {
		                    component.setCursor(Cursor.getPredefinedCursor(
		                                        Cursor.W_RESIZE_CURSOR));
		                }
		                break;
		            case Rectangle.OUT_LEFT + Rectangle.OUT_BOTTOM:
		                if(Math.abs(p.x - r.x) < PROX_DIST 
		                && Math.abs(p.y - (r.y + r.height)) < PROX_DIST) 
		                {
		                    component.setCursor(Cursor.getPredefinedCursor(
		                                        Cursor.SW_RESIZE_CURSOR));
		                }
		                break;
		            case Rectangle.OUT_BOTTOM:
		                if(Math.abs(p.y - (r.y + r.height)) < PROX_DIST) 
		                {
		                    component.setCursor(Cursor.getPredefinedCursor(
		                                        Cursor.S_RESIZE_CURSOR));
		                }
		                break;
		            case Rectangle.OUT_BOTTOM + Rectangle.OUT_RIGHT:
		                if(Math.abs(p.x - (r.x + r.width)) < PROX_DIST 
		                && Math.abs(p.y - (r.y + r.height)) < PROX_DIST) 
		                {
		                    	component.setCursor(Cursor.getPredefinedCursor(
		                                        		Cursor.SE_RESIZE_CURSOR));
		                }
		                break;
		            case Rectangle.OUT_RIGHT:
		                if(Math.abs(p.x - (r.x + r.width)) < PROX_DIST) 
		                {
		                    component.setCursor(Cursor.getPredefinedCursor(
		                                        Cursor.E_RESIZE_CURSOR));
		                }
		                break;
		            case Rectangle.OUT_RIGHT + Rectangle.OUT_TOP:
		                if(Math.abs(p.x - (r.x + r.width)) < PROX_DIST 
		                && Math.abs(p.y - r.y) < PROX_DIST) 
		                {
		                    component.setCursor(Cursor.getPredefinedCursor(
		                                        Cursor.NE_RESIZE_CURSOR));
		                }
		                break;
		        }
		  	}
	   	}
	   	public boolean mouseAtCenter(MouseEvent e)
	   	{
	   		Rectangle r = component.getBounds();
		    Point p = new Point(e.getX() + component.getX(), e.getY() + component.getY());
        	if(isOverRect(p, -(int)Math.floor(r.width / 2.25), -(int)Math.floor(r.height / 2.25)))
        	{
        		component.setCursor(Cursor.getPredefinedCursor(
        							Cursor.MOVE_CURSOR));
				return true;            		
        	}
            component.setCursor(Cursor.getDefaultCursor());	
            return false;
	   	}
	    /*
     *	
     */
	 	private void resizeComponent(MouseEvent e)
	 	{
	
	        Point moc = e.getPoint();
	        Point mos = e.getLocationOnScreen();       	
	       	Point pos = parent.getLocationOnScreen();
	       	
	 		Rectangle c = component.getBounds(); 
	 		Rectangle p = parent.getBounds();
	        
	        int h = 0;//component.getHeight();
	        int w = 0;//component.getWidth();
	 		
	 		int x = mos.x - pos.x;
	 		int y = mos.y - pos.y;
	        
	        switch(type) 
	        {
	            case Cursor.E_RESIZE_CURSOR:
	            	w = x - c.x < min_w ? min_w : (x < p.width ? x - c.x : p.width - c.x);
	            	
	                component.setBounds(c.x, 
	                					c.y, 
	                					w, 
	                					c.height);
	                break;
	            case Cursor.S_RESIZE_CURSOR:
					h = y - c.y < min_h ? min_h : (y < p.height ? y - c.y : p.height - c.y);
					
	                component.setBounds(c.x, 
	                					c.y, 
	                					c.width, 
	                					h);
	                break;
	            case Cursor.SE_RESIZE_CURSOR:
					h = y - c.y < min_h ? min_h : (y < p.height ? y - c.y : p.height - c.y);                
	            	w = x - c.x < min_w ? min_w : (x < p.width ? x - c.x : p.width - c.x);
	                component.setBounds(c.x, 
	                					c.y, 
	                					w,
	                					h);
	                break;
	                
	                
	                /*
	                 *	All cases starting from here could be improved
	                 */
	                
	            case Cursor.NE_RESIZE_CURSOR:
					y = y < 0 ? 0 : (c.height + c.y - y > min_h ? y : c.y);
					h = y < 0 ? c.height : (c.height + c.y - y >= min_h ? c.height + c.y - y : min_h);//????
		            w = x - c.x < min_w ? min_w : (x < p.width ? x - c.x : p.width - c.x);
	               	
	               	component.setBounds(c.x, 
	               						y, 
	               						w, 
	               						h);//c.height + c.y - y);
	                break;
	                
	            case Cursor.NW_RESIZE_CURSOR:
				    x = x < 0 ? 0 : (c.width + c.x - x > min_w ? x : c.x);
				    w = x < 0 ? c.width : (c.width + c.x - x >= min_w ? c.width + c.x - x : min_w);
					y = y < 0 ? 0 : (c.height + c.y - y > min_h ? y : c.y);
					h = y < 0 ? c.height : (c.height + c.y - y >= min_h ? c.height + c.y - y : min_h);
					
	                component.setBounds(x, 
	                					y,  
	                					w, //c.width + c.x - x, 
	                					h);//c.height + c.y - y);
	                break;
	            case Cursor.N_RESIZE_CURSOR:
					y = y < 0 ? 0 : (c.height + c.y - y > min_h ? y : c.y);
					h = y < 0 ? c.height : (c.height + c.y - y >= min_h ? c.height + c.y - y : min_h);
	                
	                component.setBounds(c.x, 
	                					y, 
	                					c.width, 
	                					h);//c.height + c.y - y);
	                break;
	            case Cursor.W_RESIZE_CURSOR:
				    x = x < 0 ? 0 : (c.width + c.x - x > min_w ? x : c.x);
				    w = x < 0 ? c.width : (c.width + c.x - x >= min_w ? c.width + c.x - x : min_w);
	            	
	            	component.setBounds(x, 
	            						c.y, 
	            						w, //c.width + c.x - x, 
	            						c.height);
	                break;            
	            
	            case Cursor.SW_RESIZE_CURSOR:
				    x = x < 0 ? 0 : (c.width + c.x - x > min_w ? x : c.x);
				    w = x < 0 ? c.width : (c.width + c.x - x >= min_w ? c.width + c.x - x : min_w);
					h = y - c.y < min_h ? min_h : (y < p.height ? y - c.y : p.height - c.y);            		
	            	component.setBounds(x, 
	            						c.y, 
	            						w,//c.width + c.x - x, 
	            						h);//moc.y);                
	                break;
	            default:
	                System.out.println("unexpected type: " + type);
	        } 		
	 	}
	    protected void relocateComponent(MouseEvent e)
	    {
		    Point p = e.getPoint();
			Rectangle w = parent.getBounds();
			Rectangle c = component.getBounds();
			
				
			if((c.x + p.x) - (c.width / 2) >= 0 && (c.y + p.y) - (c.height / 2) >= 0 
			&& (c.x + p.x) + (c.width / 2) <= w.width && (c.y + p.y) + (c.height / 2) <= w.height)
				component.setLocation((c.x + p.x) - (c.width / 2), (c.y + p.y) - (c.height / 2));
			
			
			else if((c.x + p.x) + (c.width / 2) > w.width && (c.y + p.y) - (c.height / 2) < 0)
				component.setLocation(w.width - c.width ,0);
	
			else if((c.x + p.x) - (c.width / 2) < 0 && (c.y + p.y) - (c.height / 2) < 0)
				component.setLocation(0, 0);				
				
			else if ((c.x + p.x) - (c.width / 2) < 0 && (c.y + p.y) + (c.height / 2) > w.height)		
				component.setLocation(0, w.height - c.height);
				
			else if((c.x + p.x) + (c.width / 2) > w.width && (c.y + p.y) + (c.height / 2) > w.height)
				component.setLocation(w.width - c.width, w.height - c.height);
				
			
			
			
			else if ((c.x + p.x) - (c.width / 2) < 0) 											
				component.setLocation(0, (c.y + p.y) - (c.height / 2));
	
			else if ((c.y + p.y) - (c.height / 2) < 0) 
				component.setLocation((c.x + p.x) - (c.width / 2), 0);
			
			else if ((c.y + p.y) + (c.height / 2) > w.height) 
				component.setLocation((c.x + p.x) - (c.width / 2), w.height - c.height);	
			
			else if((c.x + p.x) + (c.width / 2) > w.width)	
				component.setLocation(w.width - c.width, (c.y + p.y) - (c.height / 2));
				
	    }

	    /**
	     * Make a smaller Rectangle and use it to locate the
	     * cursor relative to the Rectangle center.
	     */
	    private int getOutcode(Point p) 
	    {
	        Rectangle r = (Rectangle)(component.getBounds()).clone();
	        r.grow(-PROX_DIST, -PROX_DIST);
	        return r.outcode(p.x, p.y);        
	    }
		private boolean isOverRect(Point p, int xoffset, int yoffset)
	    {
	        Rectangle r = (Rectangle)(component.getBounds()).clone();
	        r.grow(xoffset, yoffset);
	        return r.contains(p);    	
	    }
	    /**
	     * Make a larger Rectangle and check to see if the
	     * cursor is over it.
	     */
	    private boolean isOverRect(Point p) 
	    {
			return isOverRect(p, PROX_DIST, PROX_DIST);
	    }
	    public void setActionType(int action)
	    {
	    	ACTION_TYPE = action;
	    }
    }
}