How to group these JLabels?

[Michelle Wang]

Dear friends:

I have following code, see below:

    
package com.aa;
 
 
import java.awt.*;
import java.awt.event.*; 
import java.awt.geom.*;
import javax.swing.*;
import javax.swing.event.*;
 
public class ConnectingLine {
    public static void main(String[] args)
    {
        JFrame f = new JFrame("Connecting Lines");
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.getContentPane().add(new ConnectionPanel());
        f.setSize(400,300);
        f.setLocation(200,200);
        f.setVisible(true);
    }
}
 
class ConnectionPanel extends JPanel
{
    JLabel label1, label2, label3, label4;
    JLabel[] labels;
    JLabel selectedLabel;
    int cx, cy;
    boolean[] labelClick = {false,false,false,false}; //added  
 
    public ConnectionPanel()
    {
        setLayout(null);
        addLabels();
        label1.setBounds( 25,  50, 125, 25);
        label2.setBounds(225,  50, 125, 25);
        label3.setBounds( 25, 175, 125, 25);
        label4.setBounds(225, 175, 125, 25);
        determineCenterOfComponents();
        ComponentMover mover = new ComponentMover();
        addMouseListener(mover);
        addMouseMotionListener(mover);
    }
 
    public void paintComponent(Graphics g)
    {
        super.paintComponent(g);
        Graphics2D g2 = (Graphics2D)g;
        g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                            RenderingHints.VALUE_ANTIALIAS_ON);
        Point[] p;
        for(int i = 0; i < labels.length; i++)
         if(labelClick[i]) //added
            for(int j = 0 /*i + 1*/; j < labels.length; j++) //changed
            {
                p = getEndPoints(labels[i], labels[j]);
     
            }
    }
 
    private Point[] getEndPoints(Component c1, Component c2)
    {
        Point
            p1 = new Point(),
            p2 = new Point();
        Rectangle
            r1 = c1.getBounds(),
            r2 = c2.getBounds();
        int direction = r1.outcode(r2.x, r2.y);
 
        switch(direction)                        // r2 located < direction > of r1
        {
            case (Rectangle.OUT_LEFT):                           // West
                p1.x = r1.x;
                p1.y = r1.y;
                p2.x = r2.x + r2.width;
                p2.y = r2.y;
                if(r1.y > cy)
                {
                    p1.y = r1.y + r1.height;
                    p2.y = r2.y + r2.height;
                }
                break;
            case (Rectangle.OUT_TOP):                            // North
                p1.x = r1.x;
                p1.y = r1.y;
                p2.x = r2.x;
                p2.y = r2.y + r2.height;
                if(r1.x > cx && r2.x > cx)
                {
                    p1.x = r1.x + r1.width;
                    p2.x = r2.x + r2.width;
                }
                break;
            case (Rectangle.OUT_LEFT + Rectangle.OUT_TOP):       // NW
                p1.x = r1.x;
                p1.y = r1.y;
                p2.x = r2.x + r2.width;
                p2.y = r2.y;
                if(r1.y > r2.y + r2.height)
                    p2.y = r2.y + r2.height;
                break;
            case (Rectangle.OUT_RIGHT):                          // East
                p1.x = r1.x + r1.width;
                p1.y = r1.y;
                p2.x = r2.x;
                p2.y = r2.y;
                if(r1.y > cy)
                {
                    p1.y = r1.y + r1.height;
                    p2.y = r2.y + r2.height;
                }
                break;
            case (Rectangle.OUT_TOP + Rectangle.OUT_RIGHT):      // NE
                p1.x = r1.x + r1.width;
                p1.y = r1.y;
                p2.x = r2.x;
                p2.y = r2.y;
                if(r1.y > cy)
                {
                    p1.y = r1.y + r1.height;
                    p2.y = r2.y + r2.height;
                    if(r1.y > r2.y + r2.height)
                        p1.y = r1.y;
                }
                else
                {
                    if(r1.y > r2.y + r2.height)
                        p2.y = r2.y + r2.height;
                }
                break;
            case (Rectangle.OUT_BOTTOM):                         // South
                p1.x = r1.x;
                p1.y = r1.y + r1.height;
                p2.x = r2.x;
                p2.y = r2.y;
                if(r1.x > cx && r2.x > cx)
                {
                    p1.x = r1.x + r1.width;
                    p2.x = r2.x + r2.width;
                }
                break;
            case (Rectangle.OUT_RIGHT + Rectangle.OUT_BOTTOM):   // SE
                p1.x = r1.x + r1.width;
                p1.y = r1.y + r1.height;
                p2.x = r2.x;
                p2.y = r2.y;
                break;
            case (Rectangle.OUT_BOTTOM + Rectangle.OUT_LEFT):    // SW
                p1.x = r1.x;
                p1.y = r1.y + r1.height;
                p2.x = r2.x;
                p2.y = r2.y;
                if(r1.x > r2.x + r2.width)
                    p2.x = r2.x + r2.width;
                if(r1.x > cx && r2.x > cx)
                {
                    p1.x = r1.x + r1.width;
                    p2.x = r2.x + r2.width;
                }
        }
        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[i].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 < labels.length; i++)
            {
                Rectangle r = labels[i].getBounds();
                if(r.contains(p))
                {
                    selectedLabel = labels[i];
                    labelClick[i] = !labelClick[i]; //added
                    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 = selectedLabel.getBounds();
                r.x = e.getX() - offsetP.x;
                r.y = e.getY() - offsetP.y;
                selectedLabel.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
        };
        for(int i = 0; i < labels.length; i++)
        {
            labels[i].setHorizontalAlignment(SwingConstants.CENTER);
            labels[i].setBorder(BorderFactory.createEtchedBorder());
            add(labels[i]);
        }
    }
}
 

I hope to group 1, 2 or 3 or 4 JLabels together at my will, then I can move these whole group together as one JLabel, I am not sure I should use another JLabel to group or any other component to do this. but need:
[1]. all JLabels within this group should display
[2]. whole group can move as ONE JLabel
[3]. Each JLabel such as JLabel1, JLabel2, JLabel3 etc can move freely within this group JLabel Frame as they move before group. but cannot move out of boundary of group
[4]. I can add or remove this group JLabel at my will, after remove, all JLabels return to normal status.

If guru can advice some idea that will be wonderful.
Thanks

Michelle
[ June 05, 2007: Message edited by: girl sunny ]

[Gregg Bolinger]

Group them all within a JPanel.

[Michelle Wang]

good idea, but how to Drag and drop a JPanel to group them?
thanks

[Michelle Wang]

Hello sir,
I updated code as follows to group JLabels, seems short of something.

   
package aaaText;
import java.awt.*;
import java.awt.event.*; 
import java.awt.geom.*;
import java.util.Vector;
import javax.swing.*;
import javax.swing.event.*;
public class GroupJLabels extends JPanel
{
    protected JLabel label1, label2, label3, label4;
    protected JLabel[] labels;
    protected JLabel selectedLabel;
    protected JPanel  group = newJPanel();
    protected JButton btn  = new JButton("Draw Lines");
    protected JButton btn1 = new JButton("No Draw");
    protected JButton btn2 = new JButton("Group");
    protected boolean gp = false;
    int cx, cy;
    protected Vector order = new Vector();  
public static void main(String[] args)
    {
        JFrame f = new JFrame("Connecting Lines");
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.getContentPane().add(new 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();
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(selectedLabel != null && selectedLabel != (JLabel)c[j]) 
selectedLabel.setBorder(BorderFactory.createEtchedBorder());
selectedLabel = (JLabel)c[j];             
System.out.println("selectedLabel = " + selectedLabel.getText()); 
selectedLabel.setBorder(BorderFactory.createLineBorder(Color.green));
System.out.println("2. group button is pressed gp= " + gp); 
// Now that you know which label the user has selected with the   
// mouse you can get its properties and send them to the other  
// panel for display.               
if(gp){
remove(selectedLabel);
jp.add(selectedLabel);
System.out.println("3. selectedLabel was added into JP= " + selectedLabel.getText()); 
}



break;              
}   
add(jp);
}      
}   
};  
public 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, 105, 25);
        btn1.setBounds(105, 5, 105, 25);
        btn2.setBounds(205, 5, 105, 25);
       add(btn);
      add(btn1);
      add(btn2);
              
        determineCenterOfComponents();
        ComponentMover mover = new ComponentMover();
     ActionListener lst = new ActionListener() {
    public void actionPerformed(ActionEvent e) {
   ComponentMover mover = new ComponentMover();
         addMouseListener(mover);
         addMouseMotionListener(mover);
       }
     };
    ActionListener lst1 = new ActionListener() {
     public void actionPerformed(ActionEvent e) {
        }
      }; 
      
    ActionListener group = new ActionListener() {
      public void actionPerformed(ActionEvent e) {
      gp=true;
      System.out.println("group button is pressed gp= " + gp); 
         }
       }; 
 btn.addActionListener(lst);
btn1.addActionListener(lst1);
btn2.addActionListener(group);
addMouseListener(ml);  
    }
 
    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++) {
            JLabel l1 = (JLabel)order.elementAt(i);
            JLabel l2 = (JLabel)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[i].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 < labels.length; i++)
            {
                Rectangle r = labels[i].getBounds();
                if(r.contains(p))
                {
                    selectedLabel = labels[i];
                    order.addElement(labels[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 = selectedLabel.getBounds();
                r.x = e.getX() - offsetP.x;
                r.y = e.getY() - offsetP.y;
                selectedLabel.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
        };
        //add(btn);
        for(int i = 0; i < labels.length; i++)
        {
            labels[i].setHorizontalAlignment(SwingConstants.CENTER);
            labels[i].setBorder(BorderFactory.createEtchedBorder());
            add(labels[i]);
        }
    }
}
 

 

Actually I can select some labels here, but group not happen. what is wrong here??
thanks

[Michelle Wang]

Dear Friends:
I tried several days for this problem, but still cannot find solution.
can any guru throw some light??
Thanks

[Michelle Wang]

Greg's comment: "Group them all within a JPanel.", looks like not work properly after my many days trial. not sure use JPane or other component??
Thanks

[Craig Wood]

I hope to group 1, 2 or 3 or 4 JLabels together at my will, then I can move these whole
group together as one JLabel, I am not sure I should use another JLabel to group or any
other component to do this.
Since you probably want a non–opaque container I would try using a JComponent.
but need:
[1]. all JLabels within this group should display
[2]. whole group can move as ONE JLabel
[3]. Each JLabel such as JLabel1, JLabel2, JLabel3 etc can move freely within this group
JLabel Frame as they move before group.
Okay.
but cannot move out of boundary of group
I didn't do this but it is easy enough to implement. In the mouseDragged method you can
check to see if the new position puts the dragged label out of bounds of its parent and,
if so, do not update the position.
[4]. I can add or remove this group JLabel at my will, after remove, all JLabels return
to normal status.
I don't understand this.
Here's an exploration of what (I think) you are trying to do.
When the toggle button is selected you can select (click on) labels to add them to the
group container. De–selecting the toggle button ends the process. Since the group
container consumes mouse events for use in moving its children it must re–dispatch events
to its parent container to facilitate its being dragged inside the parent.

import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;
import javax.swing.*;
import javax.swing.event.MouseInputAdapter;
 
public class DraggingAGroup {
    JPanel panel;
 
    private JPanel getContent() {
        panel = new JPanel();
        panel.setLayout(null);
        panel.setBorder(BorderFactory.createEtchedBorder());
        int numComponents = 4;
        Rectangle r = new Rectangle(50, 75, 100, 35);
        for(int j = 0; j < numComponents; j++) {
            r.x = ((j+1)%2 == 0) ? 225 : 50;
            addLabel(panel, r, "Label " + (j+1));
            if(j%2 == 1)
                r.y += r.height + 75;
        }
        new LocalController(panel);
        return panel;
    }
 
     private void addLabel(Container c, Rectangle bounds, String id) {
        JLabel label = new JLabel(id, JLabel.CENTER);
        c.add(label);
        label.setBounds(bounds);
        label.setBorder(BorderFactory.createEtchedBorder());
    }
 
    private void resetComponents(Container parent) {
        Component[] c = extractComponents(parent);
        parent.removeAll();
        for(int j = 0; j < c.length; j++) {
            Rectangle r = c[j].getBounds();
            r.x = ((j+1)%2 == 0) ? 225 : 50;
            r.y = (j/2 == 0) ? 75 : 175;
            c[j].setBounds(r);
            parent.add(c[j]);
        }
        parent.repaint();
    }
 
    private Component[] extractComponents(Container parent) {
        Component[] gc = null;
        Component[] c = parent.getComponents();
        for(int j = 0; j < c.length; j++) {
            if(c[j] instanceof GroupComponent) {
                gc = ((GroupComponent)c[j]).getComponents();
                parent.remove(c[j]);
                break;
            }
        }
        if(gc == null)    // There was no GroupComponent.
            return c;
        // Gather up all the children.
        c = parent.getComponents();
        Component[] total = new Component[c.length + gc.length];
        for(int j = 0; j < total.length; j++) {
            if(j < c.length)
                total[j] = c[j];
            else
                total[j] = gc[j - c.length];
        }
        return total;
    }
 
    private JPanel getControls() {
        final JToggleButton select = new JToggleButton("Select Labels");
        final JButton reset = new JButton("Reset");
        ActionListener l = new ActionListener() {
            LocalController controller = null;
 
            public void actionPerformed(ActionEvent e) {
                AbstractButton button = (AbstractButton)e.getSource();
                if(button == select) {
                    if(select.isSelected()) {
                        GroupComponent groupComponent = new GroupComponent();
                        panel.add(groupComponent);
                        MouseListener[] mls = panel.getMouseListeners();
                        if(mls.length == 1 && mls[0] instanceof LocalController) {
                            controller = (LocalController)mls[0];
                            controller.setGroupComponent(groupComponent);
                        } else {
                            throw new IllegalStateException("multiple MouseListeners");
                        }
                    } else {
                        controller.setGroupComponent(null);
                        controller = null;
                    }
                }
                if(button == reset) {
                    resetComponents(panel);
                }
            }
        };
        select.addActionListener(l);
        reset.addActionListener(l);
        JPanel panel = new JPanel();
        panel.add(select);
        panel.add(reset);
        return panel;
    }
 
    public static void main(String[] args) {
        DraggingAGroup test = new DraggingAGroup();
        JFrame f = new JFrame();
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.getContentPane().add(test.getContent());
        f.getContentPane().add(test.getControls(), "Last");
        f.setSize(400,400);
        f.setLocation(200,200);
        f.setVisible(true);
    }
}
 
class LocalController extends MouseInputAdapter {
    JComponent host;
    GroupComponent groupComponent = null;
    Point offset = new Point();
    int selectedIndex;
    boolean dragging = false;
 
    public LocalController(JComponent host) {
        this.host = host;
        host.addMouseListener(this);
        host.addMouseMotionListener(this);
    }
 
    public void mousePressed(MouseEvent e) {
        Point p = e.getPoint();
        Component[] c = host.getComponents();
        for(int j = 0; j < c.length; j++) {
            Rectangle r = c[j].getBounds();
            if(r.contains(p)) {
                if(groupComponent != null && c[j] instanceof JLabel) {
                    host.remove(c[j]);
                    groupComponent.addChild(c[j], r);
                } else {
                    offset.x = p.x - r.x;
                    offset.y = p.y - r.y;
                    selectedIndex = j;
                    dragging = true;
                }
                break;
            }
        }
    }
 
    public void mouseReleased(MouseEvent e) {
        dragging = false;
    }
 
    public void mouseDragged(MouseEvent e) {
        if(dragging) {
            int x = e.getX() - offset.x;
            int y = e.getY() - offset.y;
            // Update the component location.
            Component c = host.getComponent(selectedIndex);
            c.setLocation(x, y);
        }
    }
 
    protected void setGroupComponent(GroupComponent gc) {
        this.groupComponent = gc;
    }
}
 
class GroupComponent extends JComponent {
 
    public GroupComponent() {
        setBorder(BorderFactory.createLineBorder(Color.black));
        LocalController controller = new LocalController(this);
        addMouseListener(controller);
        addMouseMotionListener(controller);
    }
 
    protected void processMouseEvent(MouseEvent e) {
        if(isMouseOverChild(e)) {
            super.processMouseEvent(e);
            return;
        }
        JComponent parent = (JComponent)getParent();
        MouseListener[] mls = parent.getMouseListeners();
        if(mls.length == 1 && mls[0] instanceof LocalController) {
            if(SwingUtilities.isLeftMouseButton(e)) {
                e = SwingUtilities.convertMouseEvent(this, e, parent);
                int id = e.getID();
                if(id == MouseEvent.MOUSE_PRESSED)
                    mls[0].mousePressed(e);
                else if(id == MouseEvent.MOUSE_RELEASED)
                    mls[0].mouseReleased(e);
                else
                    e.consume();
            }
        }
    }
 
    protected void processMouseMotionEvent(MouseEvent e) {
        if(isMouseOverChild(e)) {
            super.processMouseMotionEvent(e);
            return;
        }
        JComponent parent = (JComponent)getParent();
        MouseMotionListener[] mmls = parent.getMouseMotionListeners();
        if(mmls.length == 1 && mmls[0] instanceof LocalController) {
            LocalController controller = (LocalController)mmls[0];
            if(e.getID() == MouseEvent.MOUSE_DRAGGED && controller.dragging)
                controller.mouseDragged(
                    SwingUtilities.convertMouseEvent(this, e, parent));
            else
                e.consume();
        }
    }
 
    private boolean isMouseOverChild(MouseEvent e) {
        Point p = e.getPoint();
        Component[] c = getComponents();
        for(int j = 0; j < c.length; j++) {
            Rectangle r = c[j].getBounds();
            if(r.contains(p))
                return true;
        }
        return false;
    }
 
    protected void addChild(Component c, Rectangle bounds) {
        add(c);
        locateChild(c, bounds);
    }
 
    private void locateChild(Component c, Rectangle bounds) {
        Rectangle r = getBounds();
        Rectangle newBounds;
        // Set bounds for this component.
        if(getComponentCount() == 1) {    // First child.
            r = new Rectangle(bounds);
            r.grow(5, 5);
            newBounds = r;
            setBounds(r);
        } else {                          // Successive children.
            int x = Math.min(r.x, bounds.x-5);
            int y = Math.min(r.y, bounds.y-5);
            int w = Math.max(r.x+r.width, bounds.x+bounds.width+5) - x;
            int h = Math.max(r.y+r.height, bounds.y+bounds.height+5) - y;
            newBounds = new Rectangle(x, y, w, h);
            setBounds(newBounds);
        }
        // Set bounds for the new component c.
        // If this component has expanded toward its parents origin
        // as a result of the resizing necessary to accommodate the
        // component c collect the changes for use in resetting the
        // bounds of the previously-added children so that they may
        // maintain their current positions.
        int dx = 0;
        int dy = 0;
        if(r.x > newBounds.x) {
            bounds.x -= newBounds.x;
            dx = r.x - newBounds.x;
        } else {
            bounds.x -= r.x;
        }
        if(r.y > newBounds.y) {
            bounds.y -= newBounds.y;
            dy = r.y - newBounds.y;
        } else {
            bounds.y -= r.y;
        }
        c.setBounds(bounds);
        if(dx != 0 || dy != 0)
            resetOtherChildren(c, dx, dy);
        repaint();
    }
 
    private void resetOtherChildren(Component exclude, int dx, int dy) {
        Component[] c = getComponents();
        for(int j = 0; j < c.length; j++) {
            if(c[j] == exclude)
                continue;
            Rectangle r = c[j].getBounds();
            r.x += dx;
            r.y += dy;
            c[j].setLocation(r.x, r.y);
        }
    }
}

[Michelle Wang]

Thanks so much, it is wonderdful!