How to resize JPanel at Runtime ??

Question

Hi,
Our Project me t a problem as below, we hope to resize JPanel at Runtime , not at design time, ie, when we first click the button called "Move JPanel" , then we click the JPanel, then we can drag it around within main panel, but we hope to resize the size of this JPanel when we point to the border of this JPanel then drag its border to zoom in or zoom out this JPanel.
Please advice how to do that??
Thanks in advance.
import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;
import java.util.Vector;
import javax.swing.*;
import javax.swing.border.LineBorder;
import javax.swing.event.*;
public class ResizeJPanels extends JPanel
    protected JLabel label1, label2, label3, label4, labeltmp;
    protected JLabel[] labels;
    protected JPanel[] panels;
    protected JPanel selectedJPanel;
    protected JButton btn  = new JButton("Move JPanel");
    int cx, cy;
    protected Vector order = new Vector();      
     public static void main(String[] args)
        JFrame f = new JFrame("Test");
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.getContentPane().add(new ResizeJPanels().GroupJLabels());
        f.setSize(600,700);
        f.setLocation(200,200);
        f.setVisible(true);
     private MouseListener ml = new MouseAdapter() {  
          public void mousePressed(MouseEvent e) {   
               Point p = e.getPoint();      
               JPanel jp = new JPanel();
               jp.setLayout(null);
               Component[] c = ((JPanel)e.getSource()).getComponents();
               System.out.println("c.length = " + c.length);      
               for(int j = 0; j < c.length; j++) {        
                    if(c[j].getBounds().contains(p)) {     
                         if(selectedJPanel != null && selectedJPanel != (JPanel)c[j])
                              selectedJPanel.setBorder(BorderFactory.createEtchedBorder());
                         selectedJPanel = (JPanel)c[j];            
                         selectedJPanel.setBorder(BorderFactory.createLineBorder(Color.green));
                         break;             
                    add(jp);
                    revalidate();
public JPanel GroupJLabels ()
          setLayout(null);
        addLabels();
        label1.setBounds( 125,  150, 125, 25);
        label2.setBounds(425,  150, 125, 25);
        label3.setBounds( 125, 575, 125, 25);
        label4.setBounds(425, 575, 125, 25);
        //add(btn);
        btn.setBounds(10, 5, 205, 25);
            add(btn);
       determineCenterOfComponents();
        ComponentMover mover = new ComponentMover();
         ActionListener lst = new ActionListener() {
             public void actionPerformed(ActionEvent e) {
                 ComponentMover mover = new ComponentMover();
                       addMouseListener(mover);
                       addMouseMotionListener(mover);
          btn.addActionListener(lst);
          addMouseListener(ml); 
          return this;
    public void paintComponent(final Graphics g)
         super.paintComponent(g);
        Graphics2D g2 = (Graphics2D)g;
        g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,RenderingHints.VALUE_ANTIALIAS_ON);
         Point[] p;
        g2.setStroke(new BasicStroke(4f));
       for(int i = 0 ; i < order.size()-1; i++) {
            JPanel l1 = (JPanel)order.elementAt(i);
            JPanel l2 = (JPanel)order.elementAt(i+1);
            p = getCenterPoints(l1, l2);
            g2.setColor(Color.black);
           // g2.draw(new Line2D.Double(p[0], p[1]));            
    private Point[] getCenterPoints(Component c1, Component c2)
        Point
            p1 = new Point(),
            p2 = new Point();
        Rectangle
            r1 = c1.getBounds(),
            r2 = c2.getBounds();
             p1.x = r1.x + r1.width/2;
             p1.y = r1.y + r1.height/2;
             p2.x = r2.x + r2.width/2;
             p2.y = r2.y + r2.height/2;
        return new Point[] {p1, p2};
    private void determineCenterOfComponents()
        int
            xMin = Integer.MAX_VALUE,
            yMin = Integer.MAX_VALUE,
            xMax = 0,
            yMax = 0;
        for(int i = 0; i < labels.length; i++)
            Rectangle r = labels.getBounds();
if(r.x < xMin)
xMin = r.x;
if(r.y < yMin)
yMin = r.y;
if(r.x + r.width > xMax)
xMax = r.x + r.width;
if(r.y + r.height > yMax)
yMax = r.y + r.height;
cx = xMin + (xMax - xMin)/2;
cy = yMin + (yMax - yMin)/2;
private class ComponentMover extends MouseInputAdapter
Point offsetP = new Point();
boolean dragging;
public void mousePressed(MouseEvent e)
Point p = e.getPoint();
for(int i = 0; i < panels.length; i++)
Rectangle r = panels[i].getBounds();
if(r.contains(p))
selectedJPanel = panels[i];
order.addElement(panels[i]);
offsetP.x = p.x - r.x;
offsetP.y = p.y - r.y;
dragging = true;
repaint(); //added
break;
public void mouseReleased(MouseEvent e)
dragging = false;
public void mouseDragged(MouseEvent e)
if(dragging)
Rectangle r = selectedJPanel.getBounds();
r.x = e.getX() - offsetP.x;
r.y = e.getY() - offsetP.y;
selectedJPanel.setBounds(r.x, r.y, r.width, r.height);
//determineCenterOfComponents();
repaint();
private void addLabels()
label1 = new JLabel("Label 1");
label2 = new JLabel("Label 2");
label3 = new JLabel("Label 3");
label4 = new JLabel("Label 4");
labels = new JLabel[] {
label1, label2, label3, label4
JLabel jl = new JLabel("This is resizeable JPanel at Runtime");
jl.setBackground(Color.green);
jl.setOpaque(true);
          jl.setFont(new Font("Helvetica", Font.BOLD, 18));
JPanel jp = new JPanel();
jp.setLayout(new BorderLayout());
panels = new JPanel[]{jp};
          jp.setBorder(new LineBorder(Color.black, 3, false));
jp.setPreferredSize(new Dimension(400,200));
jp.add(jl, BorderLayout.NORTH);
for(int i = 0; i < labels.length; i++)
labels[i].setHorizontalAlignment(SwingConstants.CENTER);
labels[i].setBorder(BorderFactory.createEtchedBorder());
jp.add(labels[i], BorderLayout.CENTER);
jp.setBounds(100, 100, 400,200);
add(jp);

Answer 1

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.border.*;
import javax.swing.event.MouseInputAdapter;
public class Resizing extends JPanel {
    public Resizing() {
        super(null);
        addPanel();
        PanelControlAdapter control = new PanelControlAdapter(this);
        addMouseListener(control);
        addMouseMotionListener(control);
    private void addPanel() {
        JLabel jl = new JLabel("This is resizeable JPanel at Runtime");
        jl.setBackground(Color.green);
        jl.setOpaque(true);
        jl.setFont(new Font("Helvetica", Font.BOLD, 18));
        JPanel jp = new JPanel();
        jp.setLayout(new BorderLayout());
        jp.setBorder(new LineBorder(Color.black, 3, false));
        jp.add(jl, BorderLayout.NORTH);
        jp.setBounds(50,50,400,200);
        add(jp);
    public static void main(String[] args) {
        JFrame f = new JFrame("Test");
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.getContentPane().add(new Resizing());
        f.setSize(500,400);
        f.setLocation(100,100);
        f.setVisible(true);
class PanelControlAdapter extends MouseInputAdapter {
    Resizing host;
    Component selectedComponent;
    LineBorder black;
    LineBorder green;
    Point offset = new Point();
    Point start = new Point();
    boolean dragging = false;
    boolean resizing = false;
    public PanelControlAdapter(Resizing r) {
        host = r;
        black = new LineBorder(Color.black, 3, false);
        green = new LineBorder(Color.green, 3, false);
    public void mouseMoved(MouseEvent e) {
        Point p = e.getPoint();
        boolean hovering = false;
        Component c = host.getComponent(0);
        Rectangle r = c.getBounds();
        if(r.contains(p)) {
            hovering = true;
            if(selectedComponent != c) {
                if(selectedComponent != null)  // reset
                    ((JComponent)selectedComponent).setBorder(black);
                selectedComponent = c;
                ((JComponent)selectedComponent).setBorder(green);
            if(overBorder(p))
                setCursor(p);
            else if(selectedComponent.getCursor() != Cursor.getDefaultCursor())
                selectedComponent.setCursor(Cursor.getDefaultCursor());
        if(!hovering && selectedComponent != null) {
            ((JComponent)selectedComponent).setBorder(black);
            selectedComponent = null;
    private boolean overBorder(Point p) {
        Rectangle r = selectedComponent.getBounds();
        JComponent target = (JComponent)selectedComponent;
        Insets insets = target.getBorder().getBorderInsets(target);
        // Assume uniform border insets.
        r.grow(-insets.left, -insets.top);
        return !r.contains(p);
    private void setCursor(Point p) {
        JComponent target = (JComponent)selectedComponent;
        AbstractBorder border = (AbstractBorder)target.getBorder();
        Rectangle r = target.getBounds();
        Rectangle ir = border.getInteriorRectangle(target, r.x, r.y, r.width, r.height);
        int outcode = ir.outcode(p.x, p.y);
        Cursor cursor;
        switch(outcode) {
            case Rectangle.OUT_TOP:
                cursor = Cursor.getPredefinedCursor(Cursor.N_RESIZE_CURSOR);
                break;
            case Rectangle.OUT_TOP + Rectangle.OUT_LEFT:
                cursor = Cursor.getPredefinedCursor(Cursor.NW_RESIZE_CURSOR);
                break;
            case Rectangle.OUT_LEFT:
                cursor = Cursor.getPredefinedCursor(Cursor.W_RESIZE_CURSOR);
                break;
            case Rectangle.OUT_LEFT + Rectangle.OUT_BOTTOM:
                cursor = Cursor.getPredefinedCursor(Cursor.SW_RESIZE_CURSOR);
                break;
            case Rectangle.OUT_BOTTOM:
                cursor = Cursor.getPredefinedCursor(Cursor.S_RESIZE_CURSOR);
                break;
            case Rectangle.OUT_BOTTOM + Rectangle.OUT_RIGHT:
                cursor = Cursor.getPredefinedCursor(Cursor.SE_RESIZE_CURSOR);
                break;
            case Rectangle.OUT_RIGHT:
                cursor = Cursor.getPredefinedCursor(Cursor.E_RESIZE_CURSOR);
                break;
            case Rectangle.OUT_RIGHT + Rectangle.OUT_TOP:
                cursor = Cursor.getPredefinedCursor(Cursor.NE_RESIZE_CURSOR);
                break;
            default:
                cursor = Cursor.getDefaultCursor();
        selectedComponent.setCursor(cursor);
    public void mousePressed(MouseEvent e) {
        Point p = e.getPoint();
        if(selectedComponent != null) {
            Rectangle r = selectedComponent.getBounds();
            if(selectedComponent.getCursor() == Cursor.getDefaultCursor()) {
                offset.x = p.x - r.x;
                offset.y = p.y - r.y;
                dragging = true;
            } else {
                start = p;
                resizing = true;
    public void mouseReleased(MouseEvent e) {
        dragging = false;
        resizing = false;
    public void mouseDragged(MouseEvent e) {
        Point p = e.getPoint();
        if(dragging || resizing) {
            Rectangle r = selectedComponent.getBounds();
            if(dragging) {
                r.x = p.x - offset.x;
                r.y = p.y - offset.y;
                selectedComponent.setLocation(r.x, r.y);
            } else if(resizing) {
                int type = selectedComponent.getCursor().getType();
                switch(type) {
                    case Cursor.N_RESIZE_CURSOR:
                        r.height -= p.y - start.y;
                        r.y = p.y;
                        break;
                    case Cursor.NW_RESIZE_CURSOR:
                        r.width -= p.x - start.x;
                        r.x = p.x;
                        r.height -= p.y - start.y;
                        r.y = p.y;
                        break;
                    case Cursor.W_RESIZE_CURSOR:
                        r.width -= p.x - start.x;
                        r.x = p.x;
                        break;
                    case Cursor.SW_RESIZE_CURSOR:
                        r.width -= p.x - start.x;
                        r.x = p.x;
                        r.height += p.y - start.y;
                        break;
                    case Cursor.S_RESIZE_CURSOR:
                        r.height += p.y - start.y;
                        break;
                    case Cursor.SE_RESIZE_CURSOR:
                        r.width += p.x - start.x;
                        r.height += p.y - start.y;
                        break;
                    case Cursor.E_RESIZE_CURSOR:
                        r.width += p.x - start.x;
                        break;
                    case Cursor.NE_RESIZE_CURSOR:
                        r.width += p.x - start.x;
                        r.height -= p.y - start.y;
                        r.y = p.y;
                        break;
                    default:
                        System.out.println("Unexpected resize type: " + type);
                selectedComponent.setBounds(r.x, r.y, r.width, r.height);
                start = p;
}