Can anybody help??

[Michelle Wang]

Dear Friends:

I hope to draw the line between different components in a JPanel, but I hope the line should be a component, ie, it can be clicked, highlighted, selected and deleted instead of just painting a line in a panel,
But I search on web and google a while, I did not find this kind of "Line Component Example" to connect components in JPanel,
Can any guru throw some light or give some example??
Thanks in Advance

Michelle

[Campbell Ritchie]

Try a panel and set its width at 1 pixel??? There isn't a setWidth method but there are several methods allowing you to set sizes.

[Vijay Daniel]

Hi,

JSplitPane will be the right solution for your problem...
Get help from Java API...

With Regards
Vijay

[Gregg Bolinger]

Take a gander at the very last post in this thread.

[Michelle Wang]

Dear friends:
Thanks for reply.
see below Craig's famous and excellent code.
But What I need is that I need all these lines to connect theses components should be independent clickable or selectable components, these lines can be selected, clicked and remove at run time, not painted at design time and like this cannot be selected and deleted,
ie. independent clickable or selectable components are like JButton and JLabels etc, can any grur help??
Thanks.
Michelle.

  package com.aa;
 
import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;
import javax.swing.*;
import javax.swing.event.MouseInputAdapter;
public class ComponentLinks {  
private JTabbedPane getContent() {    
JTabbedPane tabbedPane = new JTabbedPane();       
// Component with draggable labels.    
tabbedPane.addTab("draggables", getDragComponent());
// Component with layout manager.      
tabbedPane.addTab("layout", getLayoutComponent());  
return tabbedPane;    
}    
private JPanel getDragComponent() {    
ComponentPanel cp = new ComponentPanel();    
cp.setLayout(null);   
int numComponents = 4;      
Rectangle r = new Rectangle(75, 75, 100, 35);     
for(int j = 0; j < numComponents; j++) {      
r.x = ((j+1)%2 == 0) ? 250 : 50;      
addLabel(cp, r, "Label " + (j+1));  
if(j%2 == 1)            
r.y += r.height + 75;
}      
LineManager manager = new LineManager(cp.getComponents());        
cp.setLineManager(manager);   
ComponentMover labelMover = new ComponentMover(cp, manager);
cp.addMouseListener(labelMover);     
cp.addMouseMotionListener(labelMover); 
return cp;   
}     
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 JPanel getLayoutComponent() {      
ComponentPanel cp = new ComponentPanel();  
cp.setLayout(new GridBagLayout());   
GridBagConstraints gbc = new GridBagConstraints();   
gbc.insets = new Insets(5,5,5,5);     
gbc.weightx = 1.0;    
gbc.weighty = 1.0;      
int numComponents = 8; 
for(int j = 0; j < numComponents; j++) {    
gbc.gridwidth = ((j+1)%2 == 0) ? GridBagConstraints.REMAINDER: GridBagConstraints.RELATIVE;   
JLabel label = new JLabel("Label " + (j+1), JLabel.CENTER);   
label.setPreferredSize(new Dimension(80, 25));           
label.setBorder(BorderFactory.createEtchedBorder());    
cp.add(label, gbc);      
}       
final LineManager manager = new LineManager(cp.getComponents());    
cp.setLineManager(manager);       
cp.addComponentListener(new ComponentAdapter()
{           
public void componentResized(ComponentEvent e) {         
Container src = (Container)e.getSource();          
Component[] c = src.getComponents();           
manager.resetLines(c);            
src.repaint();           
}       
});  
return cp;
}    
public static void main(String[] args) {  
JFrame f = new JFrame();    
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
f.getContentPane().add(new ComponentLinks().getContent());    
f.setSize(400,400);        f.setLocation(200,200);      
f.setVisible(true);    
}
} class ComponentPanel extends JPanel { 
  LineManager lineManager;    
  public void setLineManager(LineManager lm) {      
  lineManager = lm; 
  }    
  protected void paintComponent(Graphics g) {  
  super.paintComponent(g);     
  Graphics2D g2 = (Graphics2D)g; 
  g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,  RenderingHints.VALUE_ANTIALIAS_ON);     
  lineManager.drawLines(g2);   
  }
  } class LineManager {    
  Line2D.Double[] lines;  
  Rectangle[] rects;  
  public LineManager(Component[] c) {   
  int n = c.length;   
  // The number of lines is the combination of     
  // n components taken two at a time.     
  int numLines = factorial(n)/(factorial(2)*factorial(n-2)); 
  lines = new Line2D.Double[numLines];   
  rects = new Rectangle[c.length];     
  for(int j = 0, count = 0; j < c.length; j++) {   
  Rectangle r1 = c[j].getBounds();    
  rects[j] = r1;      
  for(int k = j+1; k < c.length; k++) {       
  Rectangle r2 = c[k].getBounds();       
  double theta = getAngle(r1, r2);       
  Point2D.Double p1 = getIntersectingPoint(theta, r1);  
  theta = getAngle(r2, r1);         
  Point2D.Double p2 = getIntersectingPoint(theta, r2);      
  lines[count++] = new Line2D.Double(p1, p2);     
  }       
  }   
  }   
  private double getAngle(Rectangle r1, Rectangle r2) {     
  double cy1 = r1.getCenterY();    
  double cx1 = r1.getCenterX();     
  double cy2 = r2.getCenterY();     
  double cx2 = r2.getCenterX();    
  double dy = cy2 - cy1;    
  double dx = cx2 - cx1;    
  return Math.atan2(dy, dx);   
  }    
  private Point2D.Double getIntersectingPoint(double theta, Rectangle r) {     
  double cx = r.getCenterX();     
  double cy = r.getCenterY();     
  double W = r.getWidth()/2;      
  double H = r.getHeight()/2;     
  double R = Point2D.distance(cx, cy, cx+W, cy+H);  
  double x = cx + R * Math.cos(theta);    
  double y = cy + R * Math.sin(theta);    
  Point2D.Double p = new Point2D.Double();
  int outcode = r.outcode(x, y);       
  switch(outcode) {       
  case Rectangle.OUT_TOP:  
  p.x = cx - H * ((x - cx)/(y - cy));           
  p.y = cy - H;                
  break;   
  case Rectangle.OUT_LEFT:  p.x = cx - W;   
  p.y = cy - W * ((y - cy)/(x - cx));       
  break;          
  case Rectangle.OUT_BOTTOM:  p.x = cx + H * ((x - cx)/(y - cy));    
  p.y = cy + H;              
  break;         
  case Rectangle.OUT_RIGHT: p.x = cx + W;    
  p.y = cy + W * ((y - cy)/(x - cx));      
  break;       
  }        
  return p;  
  }     
  private static int factorial(int n) {     
  return n == 0 ? 1 : n*factorial(n-1);  
  }  
  public void drawLines(Graphics2D g2) {      
  for(int j = 0; j < lines.length; j++) { 
  g2.draw(lines[j]);        
  // Label the lines with their index in the lines array.    
  //double x = lines[j].getX1() +         
  //          (lines[j].getX2() - lines[j].getX1())/3 + 5;    
  //double y = lines[j].getY1() +           
  //          (lines[j].getY2() - lines[j].getY1())/3 + 5;        
  //g2.drawString(String.valueOf(j), (float)x, (float)y);   
  }  
  }    
  public void setLinesFor(Rectangle r, int index) {     
  // Update the rect that is being dragged.        
  rects[index].setRect(r);        
  // Find the indices of the lines connected to     
  // the dragged rect - these need to be reset.   
  int[] indices = getLineIndices(index);      
  // Reset the indicated lines.    
  for(int j = 0, k = 0; j < rects.length; j++) {  
  if(j == index) continue;         
  Rectangle r2 = rects[j];         
  double theta = getAngle(r, r2); 
  Point2D.Double p1 = getIntersectingPoint(theta, r);    
  theta = getAngle(r2, r);        
  Point2D.Double p2 = getIntersectingPoint(theta, r2);         
  lines[indices[k++]].setLine(p1, p2);      
  }   
  }    
  /** Method called from dragComponent ComponentMover. */ 
  private int[] getLineIndices(int index) {   
  // Find indices of lines that need to be changed.    
  int[] indices = new int[rects.length-1];   
  int lineIndex = 0;     
  for(int j = 0, count = 0; j < index+1; j++) {   
  for(int k = 0; k < rects.length; k++) {    
  if((j < index & k == index) || (j == index && k > index))     
  indices[count++] = lineIndex;           
  if(k > j)     lineIndex++;       
  }     
  }     
  return indices; 
  }    
  /** Called from layoutComponent ComponentListener */  
  public void resetLines(Component[] c) {    
  for(int j = 0, count = 0; j < rects.length; j++) { 
  Rectangle r1 = c[j].getBounds();       
  rects[j] = r1;         
  for(int k = j+1; k < rects.length; k++) {    
  Rectangle r2 = c[k].getBounds();       
  double theta = getAngle(r1, r2);       
  Point2D.Double p1 = getIntersectingPoint(theta, r1);     
  theta = getAngle(r2, r1);           
  Point2D.Double p2 = getIntersectingPoint(theta, r2);      
  lines[count++].setLine(p1, p2);         
  }     
  }   
  }
  } 
  class ComponentMover extends MouseInputAdapter { 
  ComponentPanel panel;   
  LineManager lineManager;  
  Point offset = new Point();
  int selectedIndex;   
  boolean dragging = false;     
  public ComponentMover(ComponentPanel panel, LineManager lm) {     
  this.panel = panel;       
  lineManager = lm;   
  }    
  public void mousePressed(MouseEvent e) {  
  Point p = e.getPoint();     
  Component[] c = panel.getComponents(); 
  for(int j = 0; j < c.length; j++) {
  Rectangle r = c[j].getBounds();
  if(r.contains(p)) {            
  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 = panel.getComponent(selectedIndex);    
  c.setLocation(x, y);         
  // Update lines that terminate at component.    
  lineManager.setLinesFor(c.getBounds(), selectedIndex);   
  panel.repaint();    
  }   
  }
  }  

[Craig Wood]

import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;
import javax.swing.*;
import javax.swing.event.MouseInputAdapter;
 
public class SelectableLinks implements ActionListener {
    SelectableComponentPanel componentPanel;
 
    public void actionPerformed(ActionEvent e) {
        componentPanel.removeSelectedLink();
    }
 
    private JPanel getContent() {
        componentPanel = new SelectableComponentPanel();
        componentPanel.setLayout(null);
        int numComponents = 4;
        Rectangle r = new Rectangle(75, 75, 100, 35);
        for(int j = 0; j < numComponents; j++) {
            r.x = ((j+1)%2 == 0) ? 250 : 50;
            addLabel(componentPanel, r, "Label " + (j+1));
            if(j%2 == 1)
                r.y += r.height + 75;
        }
        componentPanel.initialize();
        SelectableComponentMover labelMover =
            new SelectableComponentMover(componentPanel);
        componentPanel.addMouseListener(labelMover);
        componentPanel.addMouseMotionListener(labelMover);
        return componentPanel;
    }
 
     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 JPanel getLast() {
        JButton button = new JButton("remove link");
        button.addActionListener(this);
        JPanel panel = new JPanel();
        panel.add(button);
        return panel;
    }
 
    public static void main(String[] args) {
        SelectableLinks test = new SelectableLinks();
        JFrame f = new JFrame();
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.getContentPane().add(test.getContent());
        f.getContentPane().add(test.getLast(), "Last");
        f.setSize(400,400);
        f.setLocation(200,200);
        f.setVisible(true);
    }
}
 
class SelectableComponentPanel extends JPanel {
    Line2D.Double[] lines;
    Rectangle[] rects;
    boolean[] visibility;
    final int SIDE = 4;
    Rectangle seeker = new Rectangle(SIDE, SIDE);
    int selectedIndex = -1;
 
    public SelectableComponentPanel() {
        addMouseListener(ml);
    }
 
    public void initialize() {
        initLines();
    }
 
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        Graphics2D g2 = (Graphics2D)g;
        g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                            RenderingHints.VALUE_ANTIALIAS_ON);
        for(int j = 0; j < lines.length; j++) {
            if(visibility[j]) {
                Color color = Color.black;
                if(j == selectedIndex)
                    color = Color.red;
                g2.setPaint(color);
                g2.draw(lines[j]);
                // Label the lines with their index in the lines array.
                //double x = lines[j].getX1() +
                //          (lines[j].getX2() - lines[j].getX1())/3 + 5;
                //double y = lines[j].getY1() +
                //          (lines[j].getY2() - lines[j].getY1())/3 + 5;
                //g2.drawString(String.valueOf(j), (float)x, (float)y);
            }
        }
    }
 
    private void initLines() {
        Component[] c = getComponents();
        int n = c.length;
        // The number of lines is the combination of
        // n components taken two at a time.
        int numLines = factorial(n)/(factorial(2)*factorial(n-2));
        lines = new Line2D.Double[numLines];
        rects = new Rectangle[c.length];
        for(int j = 0, count = 0; j < c.length; j++) {
            Rectangle r1 = c[j].getBounds();
            rects[j] = r1;
            for(int k = j+1; k < c.length; k++) {
                Rectangle r2 = c[k].getBounds();
                double theta = getAngle(r1, r2);
                Point2D.Double p1 = getIntersectingPoint(theta, r1);
                theta = getAngle(r2, r1);
                Point2D.Double p2 = getIntersectingPoint(theta, r2);
                lines[count++] = new Line2D.Double(p1, p2);
            }
        }
        visibility = new boolean[numLines];
        java.util.Arrays.fill(visibility, true);
    }
 
    private double getAngle(Rectangle r1, Rectangle r2) {
        double cy1 = r1.getCenterY();
        double cx1 = r1.getCenterX();
        double cy2 = r2.getCenterY();
        double cx2 = r2.getCenterX();
        double dy = cy2 - cy1;
        double dx = cx2 - cx1;
        return Math.atan2(dy, dx);
    }
 
    private Point2D.Double getIntersectingPoint(double theta, Rectangle r) {
        double cx = r.getCenterX();
        double cy = r.getCenterY();
        double W = r.getWidth()/2;
        double H = r.getHeight()/2;
        double R = Point2D.distance(cx, cy, cx+W, cy+H);
        double x = cx + R * Math.cos(theta);
        double y = cy + R * Math.sin(theta);
        Point2D.Double p = new Point2D.Double();
        int outcode = r.outcode(x, y);
        switch(outcode) {
            case Rectangle.OUT_TOP:
                p.x = cx - H * ((x - cx)/(y - cy));
                p.y = cy - H;
                break;
            case Rectangle.OUT_LEFT:
                p.x = cx - W;
                p.y = cy - W * ((y - cy)/(x - cx));
                break;
            case Rectangle.OUT_BOTTOM:
                p.x = cx + H * ((x - cx)/(y - cy));
                p.y = cy + H;
                break;
            case Rectangle.OUT_RIGHT:
                p.x = cx + W;
                p.y = cy + W * ((y - cy)/(x - cx));
                break;
        }
        return p;
    }
 
    private static int factorial(int n) {
        return n == 0 ? 1 : n*factorial(n-1);
    }
 
    public void setLinesFor(Rectangle r, int index) {
        // Update the rect that is being dragged.
        rects[index].setRect(r);
        // Find the indices of the lines connected to
        // the dragged rect - these need to be reset.
        int[] indices = getLineIndices(index);
        // Reset the indicated lines.
        for(int j = 0, k = 0; j < rects.length; j++) {
            if(j == index) continue;
            Rectangle r2 = rects[j];
            double theta = getAngle(r, r2);
            Point2D.Double p1 = getIntersectingPoint(theta, r);
            theta = getAngle(r2, r);
            Point2D.Double p2 = getIntersectingPoint(theta, r2);
            lines[indices[k++]].setLine(p1, p2);
        }
    }
 
    private int[] getLineIndices(int index) {
        // Find indices of lines that need to be changed.
        int[] indices = new int[rects.length-1];
        int lineIndex = 0;
        for(int j = 0, count = 0; j < index+1; j++) {
            for(int k = 0; k < rects.length; k++) {
                if((j < index & k == index) || (j == index && k > index))
                    indices[count++] = lineIndex;
                if(k > j)
                    lineIndex++;
            }
        }
        return indices;
    }
 
    public void removeSelectedLink() {
        if(selectedIndex != -1) {
            visibility[selectedIndex] = false;
            repaint();
        }
    }
 
    private MouseListener ml = new MouseAdapter() {
        public void mousePressed(MouseEvent e) {
            Point p = e.getPoint();
            // Position seeker over Point p.
            seeker.setFrameFromCenter(p.x, p.y, p.x+seeker.width/2,
                                                p.y+seeker.height/2);
            // Do any lines intersect seeker?
            for(int j = 0; j < lines.length; j++) {
                if(lines[j].intersects(seeker)) {
                    // Change the selection or toggle selection off.
                    if(selectedIndex == -1 || selectedIndex != j)
                        selectedIndex = j;
                    else
                        selectedIndex = -1;
                    repaint();
                    break;
                }
            }
        }
    };
}
 
class SelectableComponentMover extends MouseInputAdapter {
    SelectableComponentPanel componentPanel;
    Point offset = new Point();
    int selectedIndex;
    boolean dragging = false;
 
    public SelectableComponentMover(SelectableComponentPanel panel) {
        componentPanel = panel;
    }
 
    public void mousePressed(MouseEvent e) {
        Point p = e.getPoint();
        Component[] c = componentPanel.getComponents();
        for(int j = 0; j < c.length; j++) {
            Rectangle r = c[j].getBounds();
            if(r.contains(p)) {
                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 = componentPanel.getComponent(selectedIndex);
            c.setLocation(x, y);
            // Update lines that terminate at component.
            componentPanel.setLinesFor(c.getBounds(), selectedIndex);
            componentPanel.repaint();
        }
    }
}

[Michelle Wang]

Great!! Thanks so much Craig, How can your guru so smart and so genius?
Highly appreciated.

[Michelle Wang]

Dear Sir:
One more question,
[1].how can I adjust the width of the lines I draw in this example??
i.e, make them wider or narrower at my will;
[2]. How to draw arrow lines??
I tried to use Strokes, but fails.

Really sorry to bother.
Thanks
sunny
[ April 24, 2007: Message edited by: girl sunny ]

[Craig Wood]

class SelectableComponentPanel extends JPanel {
    ...
    protected void paintComponent(Graphics g) {
        ...
        g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                            RenderingHints.VALUE_ANTIALIAS_ON);
        g2.setStroke(new BasicStroke(3f));  // <---- line width
        for(int j = 0; j < lines.length; j++) {

[Michelle Wang]

Great!! Thanks so much guru, one more question, how to draw line with arrow in this sample??
[ April 24, 2007: Message edited by: girl sunny ]

[Craig Wood]

Changes to SelectableLinks for adding arrow heads to line:

class SelectableComponentPanel extends JPanel {
    ...
    GeneralPath[] arrowHeads;
    final int BARB = 12;
    final double BARB_ANGLE = 30.0;
    ...
    protected void paintComponent(Graphics g) {
        ...
                g2.draw(lines[j]);
                g2.draw(arrowHeads[j]);
    ...
    private void initLines() {
        ...
        arrowHeads = new GeneralPath[numLines];
        lines = new Line2D.Double[numLines];
        ...
                arrowHeads[count] = getArrowHead(theta, p1, p2);
                lines[count++] = new Line2D.Double(p1, p2);
    ...
 
    private GeneralPath getArrowHead(double theta, Point2D.Double p1,
                                                   Point2D.Double p2) {
        double phi = Math.toRadians(BARB_ANGLE);
        float x = (float)(p1.x - BARB*Math.cos(theta+phi));
        float y = (float)(p1.y - BARB*Math.sin(theta+phi));
        GeneralPath path = new GeneralPath();
        path.moveTo(x, y);
        path.lineTo((float)p1.x, (float)p1.y);
        x = (float)(p1.x - BARB*Math.cos(theta-phi));
        y = (float)(p1.y - BARB*Math.sin(theta-phi));
        path.lineTo(x, y);
        theta += Math.PI;
        x = (float)(p2.x - BARB*Math.cos(theta+phi));
        y = (float)(p2.y - BARB*Math.sin(theta+phi));
        path.moveTo(x, y);
        path.lineTo((float)p2.x, (float)p2.y);
        x = (float)(p2.x - BARB*Math.cos(theta-phi));
        y = (float)(p2.y - BARB*Math.sin(theta-phi));
        path.lineTo(x, y);
        return path;
    }
 
    public void setLinesFor(Rectangle r, int index) {
        ...
            arrowHeads[indices[k]] = getArrowHead(theta, p1, p2);
            lines[indices[k++]].setLine(p1, p2);
    ...

[Michelle Wang]

great jobs, great man!! thanks so much, highly appreciated. so wonderful!!

[Michelle Wang]

Hi, Craig,
Your sample code is excellent, My case is a little bit different from your one.
[1]. you use Rectangle as a basic component

   private JPanel getContent() {     
componentPanel = new SelectableComponentPanel();   
componentPanel.setLayout(null);     
int numComponents = 4;      
Rectangle r = new Rectangle(75, 75, 100, 35);     
for(int j = 0; j < numComponents; j++) {      
r.x = ((j+1)%2 == 0) ? 250 : 50;         
addLabel(componentPanel, r, "Label " + (j+1));    
if(j%2 == 1)    r.y += r.height + 75; 
}       
componentPanel.initialize();  
SelectableComponentMover labelMover =  new SelectableComponentMover(componentPanel);     
componentPanel.addMouseListener(labelMover);  
componentPanel.addMouseMotionListener(labelMover);  
return componentPanel;   
}      
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());   
}     

But my case use JLabel as basic components,

the difference is that in your code:

 private MouseListener ml = new MouseAdapter() {  
public void mousePressed(MouseEvent e) {    
Point p = e.getPoint();        
// Position seeker over Point p.   
seeker.setFrameFromCenter(p.x, p.y, p.x+seeker.width/2, p.y+seeker.height/2);  
// Do any lines intersect seeker?        
for(int j = 0; j < lines.length; j++) {   
if(lines[j].intersects(seeker)) {   
// Change the selection or toggle selection off. 
if(selectedIndex == -1 || selectedIndex != j)    
selectedIndex = j;             
else                      
selectedIndex = -1;    
repaint();               
break;             
}         
}        
}    
};
   

here only Rectanle has method to call lines[j].intersects(seeker);
but JLabel did not have this method, If I use JLabel, how Can I find a method something like intersects to make sure this line intersects with this JLabel instead of Rectangle?? I check the API already, so far not yet find this kind of method, can you help how to use it??

thanks

[Craig Wood]

you use Rectangle as a basic component
In the getContent method the Rectangle is used to store the [x, y, width, height]
information that is required for setting the location (x,y) and size (width,height) of
each JLabel added to the parent Container with null layout.
In the addLabel method

private void addLabel(Container c, Rectangle bounds, String id) {
    make a new JLabel
    add it to the parent Container
    set its bounds - without this it won't appear in the parent Container
    set a border - for visibility only

We are still adding JLabel (as the basic) components but using a null layout which
requires that we specify the location/size for each child component. setBounds is
one way to do this.

the difference is that in your code
...
here only Rectanle has method to call lines[j].intersects(seeker);
but JLabel did not have this method,
In the code block for mousePressed the Rectangle seeker is used as an easy
way to test if the mouse is on top of or close enough to any of the lines which connect
the components. By moving/centering the Rectangle seeker under the mousePressed
location we can test for Rectangle/Line intersection. This will allow the user to select
any of the visible lines that connect the basic components. We are testing for
intersection between the single/movable Rectangle instance seeker and each of the
visible connection lines.

If I use JLabel, how Can I find a method something like intersects to make sure this
line intersects with this JLabel instead of Rectangle??
This is a different question. To test if any line intersects a JLabel (or just about any
other Component) you can use the bounds of the JLabel for the test

Line2D.Double line ...
JLabel label ...
Rectangle r = label.getBounds();
boolean intersects = line.intersects(r);

Edit: Correct formatting.
[ April 30, 2007: Message edited by: Craig Wood ]

[Michelle Wang]

Dear Guru:
Thanks so much for your wonderful code and explanation
[ May 01, 2007: Message edited by: girl sunny ]

[Michelle Wang]

Dear Craig:
I tried to apply and integrate your idea and samples into my following code, but not success, can you help some more??
I was really stopped. In the following code, I can dynamically draw line between any components, But I cannot make these lines selectable and deletable. see code below. How to make these lines selectable and deletable by using your methods??

Thanks a lot!

    
 
import java.awt.*;
import java.awt.event.*; 
import java.awt.geom.*;
import java.util.Vector;
 
import javax.swing.*;
import javax.swing.event.*;
 
public class ConnectingLines extends JPanel
{
    protected JLabel label1, label2, label3, label4;
    protected JLabel[] labels;
    protected JLabel selectedLabel;
    protected JButton btn = new JButton("Draw Lines");
    protected JButton btn1 = new JButton("No Draw");
 
//    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 ConnectingLines());
        f.setSize(400,300);
        f.setLocation(200,200);
        f.setVisible(true);
    }
 
public ConnectingLines ()
{
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);
        //add(btn);
        btn.setBounds(10, 5, 125, 25);
        btn1.setBounds(125, 5, 125, 25);
        
        
       add(btn);
       add(btn1);
        
        //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) {
        }
      };     
 btn.addActionListener(lst);
btn1.addActionListener(lst1);
    }
 
    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]);
        }
    }
}
 
 

Regards.

Michelle.

[Craig Wood]

To be able to select lines with the mouse you will have to have references to the lines or
construct them for each mousePressed event. This will be difficult to do when you add labels
to the vector and draw connecting lines between components contained in the vector in
paintComponent (the way it is now.)
I would try to add lines to the vector instead of adding labels to the vector. This will
simplify the selection and removal of lines. Adding new lines becomes the problem with this
approach; you'll have to figure out a way to allow the user to add a line between any two
components. After that things should go much smoother.

[Michelle Wang]

Dear Craig,
You are right, last night, I tried to add Lines into Vector and hope to dynamically draw lines between JLabels and make these lines selectable, I can draw lines. but failed to select and remove lines, I am still trying and figure it out. your suggestion is very valuable.
Really thanks for your great help.
Regards
Michelle
[ May 02, 2007: Message edited by: girl sunny ]

[Craig Wood]

Once you get the lines in the vector the matter of selecting and removing them is pretty
much the same as used in SelectabeLinks. The only difference is that you are using a vector
instead of an array of lines.

[Michelle Wang]

so far not yet success, thanks for advice.
[ May 04, 2007: Message edited by: girl sunny ]

[Craig Wood]

This was more difficult than I had imagined. My last post missed the mark.
This app should allow adding, selecting and removing lines as you wish.
To add a line: press the addLine button and then click any two labels.
The removeLine button will work for selected (red) lines as before.
The app is set up for non-generics, j2se 1.4-
There are generic statements (for the two List/ArrayLists) which you can
uncomment (and comment–out the two non–generic statements right beneath them)
if using j2se 1.5+ and you want to avoid compiler warnings.

import java.awt.*;
import java.awt.event.*; 
import java.awt.geom.*;
import java.util.*;
import java.util.List;
import javax.swing.*;
import javax.swing.event.MouseInputAdapter;
 
public class LinkTest {
    LinkPanel linkPanel = new LinkPanel();
    LinkMover linkMover = new LinkMover(this, linkPanel);
    JButton addLine;
 
    public LinkTest() {
        linkPanel.setLayout(null);
        JLabel[] labels = addLabels();
        labels[0].setBounds( 25,  50, 125, 25);
        labels[1].setBounds(225,  50, 125, 25);
        labels[2].setBounds( 25, 175, 125, 25);
        labels[3].setBounds(225, 175, 125, 25);
    }
 
    public void enableAddLine(boolean enable) {
        addLine.setEnabled(enable);
    }
 
    private JLabel[] addLabels() {
        JLabel[] labels = new JLabel[4];
        for(int i = 0; i < labels.length; i++) {
            labels[i] = new JLabel("Label " + (i+1));
            labels[i].setHorizontalAlignment(SwingConstants.CENTER);
            labels[i].setBorder(BorderFactory.createEtchedBorder());
            linkPanel.add(labels[i]);
        }
        return labels;
    }
 
    private JPanel getLinkPanel() {
        linkPanel.addMouseListener(linkMover);
        linkPanel.addMouseMotionListener(linkMover);
        return linkPanel;
    }
 
    private JPanel getLastPanel() {
        addLine = new JButton("Add Line");
        final JButton removeLine = new JButton("Remove Line");
        final JCheckBox showLines = new JCheckBox("Show Lines", true);
        final JCheckBox showArrows = new JCheckBox("Arrows");
        ActionListener al = new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                AbstractButton button = (AbstractButton)e.getSource();
                if(button == addLine) {
                    linkMover.setAddingLine(true);
                    enableAddLine(false);
                } else if(button == removeLine) {
                    linkPanel.removeSelectedLink();
                } else if(button == showLines) {
                    linkPanel.setShowLines(showLines.isSelected());
                } else /* showArrows */ {
                    linkPanel.setShowArrows(showArrows.isSelected());
                }
            }
        };
        addLine.addActionListener(al);
        removeLine.addActionListener(al);
        showLines.addActionListener(al);
        showArrows.addActionListener(al);
        JPanel panel = new JPanel();
        panel.add(addLine);
        panel.add(removeLine);
        panel.add(showLines);
        panel.add(showArrows);
        return panel;
    }
    
    public static void main(String[] args) {
        LinkTest linkTest = new LinkTest();
        JFrame f = new JFrame();
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.getContentPane().add(linkTest.getLinkPanel());
        f.getContentPane().add(linkTest.getLastPanel(), "Last");
        f.setSize(400,300);
        f.setLocation(200,200);
        f.setVisible(true);
    }
}
 
class LinkPanel extends JPanel {
    // Generic statement for use in j2se 1.5+
    //List<LinkStore> links = new ArrayList<LinkStore>();
    // Non-generic statement for use in j2se 1.4-
    List links = new ArrayList();
    final int SIDE = 6;
    Rectangle seeker = new Rectangle(SIDE, SIDE);
    int selectedIndex = -1;
    boolean showLines = true;
    boolean showArrows = false;
 
    public LinkPanel() {
        addMouseListener(ml);
    }
 
    public void setShowLines(boolean show) {
        showLines = show;
        repaint();
    }
 
    public void setShowArrows(boolean show) {
        showArrows = show;
        repaint();
    }
 
    public void addLink(Component c1, Component c2) {
        links.add(new LinkStore(c1, c2, false, true));
        repaint();
    }
 
    public void setLinesFor(int index) {
        int[] linkIndices = getLinkIndices(index);
        // Reset the indicated lines.
        for(int j = 0; j < linkIndices.length; j++) {
            LinkStore link = (LinkStore)links.get(linkIndices[j]);
            link.resetLine();
        }
        repaint();
    }
 
    private int[] getLinkIndices(int index) {
        //List<Integer> list = new ArrayList<Integer>();  // generic
        List list = new ArrayList();                      // non-generic
        Component target = getComponent(index);
        for(int j = 0; j < links.size(); j++) {
            LinkStore link = (LinkStore)links.get(j);
            if(link.contains(target))
                list.add(Integer.valueOf(j));
        }
        int[] indices = new int[list.size()];
        for(int j = 0; j < list.size(); j++)
            indices[j] = ((Integer)list.get(j)).intValue();
        return indices;
    }
 
    public void removeSelectedLink() {
        if(selectedIndex != -1) {
            links.remove(selectedIndex);
            selectedIndex = -1;
            repaint();
        }
    }
 
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        Graphics2D g2 = (Graphics2D)g;
        g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                            RenderingHints.VALUE_ANTIALIAS_ON);
        if(showLines) {
            for(int j = 0; j < links.size(); j++) {
                LinkStore link = (LinkStore)links.get(j);
                link.draw(g2, showArrows);
            }
        }
    }
 
    private MouseListener ml = new MouseAdapter() {
        public void mousePressed(MouseEvent e) {
            Point p = e.getPoint();
            // Position seeker over Point p.
            seeker.setFrameFromCenter(p.x, p.y, p.x+seeker.width/2,
                                                p.y+seeker.height/2);
            // Do any link lines intersect seeker?
            for(int j = 0; j < links.size(); j++) {
                LinkStore link = (LinkStore)links.get(j);
                if(link.line.intersects(seeker)) {
                    // Change the selection or toggle selection off.
                    if(selectedIndex == -1 || selectedIndex != j) {
                        if(selectedIndex != -1)
                            ((LinkStore)links.get(selectedIndex)).isSelected = false;
                        selectedIndex = j;
                        link.isSelected = true;
                    } else {                        // toggle off/deselect
                        selectedIndex = -1;
                        link.isSelected = false;
                    }
                    repaint();
                    break;
                }
            }
        }
    };
}
 
class LinkMover extends MouseInputAdapter {
    LinkTest linkTest;
    LinkPanel linkPanel;
    Point offset = new Point();
    boolean dragging;
    int selectedIndex = -1;
    boolean addingLine = false;
 
    public LinkMover(LinkTest lt, LinkPanel lp) {
        linkTest = lt;
        linkPanel = lp;
    }
 
    public void setAddingLine(boolean adding) {
        addingLine = adding;
    }
 
    public void mousePressed(MouseEvent e) {
        Point p = e.getPoint();
        Component[] c = linkPanel.getComponents();
        if(addingLine) {        // Are we selecting a label for adding a line?
            for(int j = 0; j < c.length; j++) {
                Rectangle r = c[j].getBounds();
                if(r.contains(p)) {
                    if(selectedIndex != -1) {
                        linkPanel.addLink(c[selectedIndex], c[j]);
                        addingLine = false;
                        selectedIndex = -1;
                        linkTest.enableAddLine(true);
                    } else {
                        selectedIndex = j;
                    }
                    break;
                }
            }
        } else {                // Or selecting a label to drag?
            for(int j = 0; j < c.length; j++) {
                Rectangle r = c[j].getBounds();
                if(r.contains(p)) {
                    selectedIndex = j;
                    offset.x = p.x - r.x;
                    offset.y = p.y - r.y;
                    dragging = true;
                    break;
                }
            }
        }
    }
 
    public void mouseReleased(MouseEvent e) {
        dragging = false;
        if(!addingLine)
            selectedIndex = -1;
    }
 
    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 = linkPanel.getComponent(selectedIndex);
            c.setLocation(x, y);
            // Update link lines that terminate at component.
            linkPanel.setLinesFor(selectedIndex);
        }
    } 
}
 
class LinkStore {
    Component c1;
    Component c2;
    boolean isSelected;
    boolean isVisible;
    Line2D.Double line;
    GeneralPath arrows;
    final int BARB = 12;
    final double BARB_ANGLE = 20.0;
 
    public LinkStore(Component c1, Component c2,
                     boolean selected, boolean visible) {
        this.c1 = c1;
        this.c2 = c2;
        isSelected = selected;
        isVisible = visible;
        line = new Line2D.Double();
        arrows = new GeneralPath();
        resetLine();
    }
 
    public void draw(Graphics2D g2, boolean showArrows) {
        if(isVisible) {
            Color color = Color.black;
            if(isSelected)
                color = Color.red;
            g2.setPaint(color);
            g2.draw(line);
            if(showArrows)
                g2.draw(arrows);
        }
    }
 
    public void resetLine() {
        Rectangle r1 = c1.getBounds();
        Rectangle r2 = c2.getBounds();
        double theta = getAngle(r1, r2);
        Point2D.Double p1 = getIntersectingPoint(theta, r1);
        theta = getAngle(r2, r1);
        Point2D.Double p2 = getIntersectingPoint(theta, r2);
        line.setLine(p1, p2);
        setArrowHeads(theta, p1, p2);
    }
 
    public boolean contains(Component c) {
        return c.equals(c1) || c.equals(c2);
    }
 
    private double getAngle(Rectangle r1, Rectangle r2) {
        double cy1 = r1.getCenterY();
        double cx1 = r1.getCenterX();
        double cy2 = r2.getCenterY();
        double cx2 = r2.getCenterX();
        double dy = cy2 - cy1;
        double dx = cx2 - cx1;
        return Math.atan2(dy, dx);
    }
 
    private Point2D.Double getIntersectingPoint(double theta, Rectangle r) {
        double cx = r.getCenterX();
        double cy = r.getCenterY();
        double W = r.getWidth()/2;
        double H = r.getHeight()/2;
        double R = Point2D.distance(cx, cy, cx+W, cy+H);
        double x = cx + R * Math.cos(theta);
        double y = cy + R * Math.sin(theta);
        Point2D.Double p = new Point2D.Double();
        int outcode = r.outcode(x, y);
        switch(outcode) {
            case Rectangle.OUT_TOP:
                p.x = cx - H * ((x - cx)/(y - cy));
                p.y = cy - H;
                break;
            case Rectangle.OUT_LEFT:
                p.x = cx - W;
                p.y = cy - W * ((y - cy)/(x - cx));
                break;
            case Rectangle.OUT_BOTTOM:
                p.x = cx + H * ((x - cx)/(y - cy));
                p.y = cy + H;
                break;
            case Rectangle.OUT_RIGHT:
                p.x = cx + W;
                p.y = cy + W * ((y - cy)/(x - cx));
                break;
        }
        return p;
    }
 
    private void setArrowHeads(double theta, Point2D.Double p1,
                                             Point2D.Double p2) {
        double phi = Math.toRadians(BARB_ANGLE);
        float x = (float)(p2.x + BARB*Math.cos(theta+phi));
        float y = (float)(p2.y + BARB*Math.sin(theta+phi));
        arrows.reset(); 
        arrows.moveTo(x, y);
        arrows.lineTo((float)p2.x, (float)p2.y);
        x = (float)(p2.x + BARB*Math.cos(theta-phi));
        y = (float)(p2.y + BARB*Math.sin(theta-phi));
        arrows.lineTo(x, y);
        theta += Math.PI;
        x = (float)(p1.x + BARB*Math.cos(theta+phi));
        y = (float)(p1.y + BARB*Math.sin(theta+phi));
        arrows.moveTo(x, y);
        arrows.lineTo((float)p1.x, (float)p1.y);
        x = (float)(p1.x + BARB*Math.cos(theta-phi));
        y = (float)(p1.y + BARB*Math.sin(theta-phi));
        arrows.lineTo(x, y);
    }
}

[Michelle Wang]

Thanks so much for your great help. really appreciated, have a very good weekends. Test success. without you help, I cannot solve this problem.
Best Regards.
Michelle.