Problem!!! Moving point along the line

Question

hi,
I need to move the point along the line. I want move this point using mouse.
My program draws a line and a point that' s on this line.
Could someone help me.

Answer 1

import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;
import javax.swing.*;
import javax.swing.event.MouseInputAdapter;
public class TraverseAgain extends JPanel {
    Point2D.Double[] points;
    Point2D.Double p1;
    Point2D.Double p2;
    /** An endPoint of one of the lines is being moved. */
    public void setEndPoint(int index, double x, double y) {
        int start;
        double ratio;
        switch(index) {
            case 0:
                start = index == 0 ? 1 : 0;
                ratio = getRatio(p1, start, index);
                resetMidPoint(p1, points[start], x, y, ratio);
                break;
            case 1:
                start = index == 0 ? 1 : 0;
                ratio = getRatio(p1, start, index);
                resetMidPoint(p1, points[start], x, y, ratio);
                start = index == 1 ? 2 : 1;
                ratio = getRatio(p2, start, index);
                resetMidPoint(p2, points[start], x, y, ratio);
                break;
            case 2:
                start = index == 1 ? 2 : 1;
                ratio = getRatio(p2, start, index);
                resetMidPoint(p2, points[start], x, y, ratio);
                break;
            default:
                System.out.println("illegal index: " + index);
        points[index].setLocation(x, y);
        repaint();
     * Design assumption/decision:
     * Preserve this ratio when repositioning a midPoint between the
     * end points of its line when one of the end points is being moved.
    private double getRatio(Point2D.Double p, int start, int end) {
        double d1 = points[start].distance(p);
        double d2 = points[start].distance(points[end]);
        return d1 / d2;
    private void resetMidPoint(Point2D.Double p, Point2D.Double end,
                               double x, double y, double ratio) {
        double dy = y - end.y;
        double dx = x - end.x;
        double theta = Math.atan2(dy, dx);
        double length = end.distance(x, y);
        x = end.x + length*ratio*Math.cos(theta);
        y = end.y + length*ratio*Math.sin(theta);
        p.setLocation(x, y);
    /** A midPoint is being moved. */
    public void setMidPoint(int number, double x, double y) {
        switch(number) {
            case 1:
                double dx = points[1].x - points[0].x;
                double dy = points[1].y - points[0].y;
                if(points[0].x < x && x < points[1].x ||
                   points[1].x < x && x < points[0].x)
                    y = points[0].y + (x - points[0].x)*(dy / dx);
                else if(points[0].y < y && y < points[1].y ||
                        points[1].y < y && y < points[0].y)
                    x = points[0].x + (y - points[0].y)*(dx / dy);
                else
                    return;
                p1.setLocation(x, y);
                break;
            case 2:
                dx = points[2].x - points[1].x;
                dy = points[2].y - points[1].y;
                if(points[1].x < x && x < points[2].x ||
                   points[2].x < x && x < points[1].x)
                    y = points[1].y + (x - points[1].x)*(dy / dx);
                else if(points[1].y < y && y < points[2].y ||
                        points[2].y < y && y < points[1].y)
                    x = points[1].x + (y - points[1].y)*(dx / dy);
                else
                    return;
                p2.setLocation(x, y);
                break;
            default:
                System.out.println("illegal number " + number);
        repaint();
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        Graphics2D g2 = (Graphics2D)g;
        g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                            RenderingHints.VALUE_ANTIALIAS_ON);
        if(points == null)
            initGeoms();
        g2.setPaint(Color.blue);
        for(int j = 1; j < points.length; j++)
            g2.draw(new Line2D.Double(points[j-1].x, points[j-1].y,
                                      points[j].x,   points[j].y));
        g2.setPaint(Color.red);
        for(int j = 0; j < points.length; j++)
            mark(points[j], g2);
        g2.setPaint(Color.green.darker());
        mark(p1, g2);
        mark(p2, g2);
    private void mark(Point2D.Double p, Graphics2D g2) {
        g2.fill(new Ellipse2D.Double(p.x-2, p.y-2, 4, 4));
    private void initGeoms() {
        int w = getWidth();
        int h = getHeight();
        points = new Point2D.Double[3];
        points[0] = new Point2D.Double(w/4, h/3);
        points[1] = new Point2D.Double(w/16, h/2);
        points[2] = new Point2D.Double(w*13/15, h*3/4);
        double cx = points[0].x + (points[1].x - points[0].x)/2;
        double cy = points[0].y + (points[1].y - points[0].y)/2;
        p1 = new Point2D.Double(cx, cy);
        cx = points[1].x + (points[2].x - points[1].x)/2;
        cy = points[1].y + (points[2].y - points[1].y)/2;
        p2 = new Point2D.Double(cx, cy);
    public static void main(String[] args) {
        TraverseAgain test = new TraverseAgain();
        PointMover mover = new PointMover(test);
        test.addMouseListener(mover);
        test.addMouseMotionListener(mover);
        JFrame f = new JFrame();
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.getContentPane().add(test);
        f.setSize(400,400);
        f.setLocation(200,200);
        f.setVisible(true);
class PointMover extends MouseInputAdapter {
    TraverseAgain traverseAgain;
    int selectedEndIndex = -1;
    int selectedMidNumber = -1;
    Point2D.Double offset = new Point2D.Double();
    boolean dragging = false;
    final int MIN_DIST = 5;
    public PointMover(TraverseAgain ta) {
        traverseAgain = ta;
    public void mousePressed(MouseEvent e) {
        Point p = e.getPoint();
        Point2D.Double[] points = traverseAgain.points;
        for(int j = 0; j < points.length; j++) {
            if(points[j].distance(p) < MIN_DIST) {
                selectedEndIndex = j;
                rigForDrag(points[j], p);
                break;
        if(selectedEndIndex == -1) {
            if(traverseAgain.p1.distance(p) < MIN_DIST) {
                selectedMidNumber = 1;
                rigForDrag(traverseAgain.p1, p);
            } else if(traverseAgain.p2.distance(p) < MIN_DIST) {
                selectedMidNumber = 2;
                rigForDrag(traverseAgain.p2, p);
    private void rigForDrag(Point2D.Double p, Point loc) {
        offset.x = loc.x - p.x;
        offset.y = loc.y - p.y;
        dragging = true;
    public void mouseReleased(MouseEvent e) {
        dragging = false;
        selectedEndIndex = -1;
        selectedMidNumber = -1;
    public void mouseDragged(MouseEvent e) {
        if(dragging) {
            double x = e.getX() - offset.x;
            double y = e.getY() - offset.y;
            if(selectedEndIndex != -1)
                traverseAgain.setEndPoint(selectedEndIndex, x, y);
            else
                traverseAgain.setMidPoint(selectedMidNumber, x, y);
}