Question

我有一个程序在JFrame中绘制2个矩形。我希望当我拖动和移动（用于调整大小）时，其中一个矩形，第二个同时移动。因此，当您移动上方矩形的下边界时，下方矩形的上边框将朝同一方向移动。

编辑：我是Java编程的初学者，我根本看不到如何做到这一点。

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

class Resizing extends JPanel {
Rectangle rect = new Rectangle(100,100,150,150);
Rectangle rect2 = new Rectangle(100,250,150,100);

@Override
public void paintComponent(Graphics g) {
    super.paintComponent(g);
    Graphics2D g2 = (Graphics2D)g;
    g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,RenderingHints.VALUE_ANTIALIAS_ON);
    g2.setColor(new Color(0, 0, 200));
    g2.fill(rect);
    g2.setColor(new Color(0, 0, 100));
    g2.fill(rect2);

}

public static void main(String[] args) {
    JFrame f = new JFrame();
    f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    Resizing test = new Resizing();
    Resizing test2 = new Resizing();

    Resizer resizer = new Resizer(test);
    Resizer2 resizer2 = new Resizer2(test2);

    test.addMouseListener(resizer);
    test2.addMouseListener(resizer2);

    test.addMouseMotionListener(resizer);
    test2.addMouseMotionListener(resizer2);

    f.add(test);
    f.add(test2);

    f.setSize(400,400);
    f.setLocation(100,100);
    f.setVisible(true);
}
}
class Resizer extends MouseAdapter {
Resizing component;
boolean dragging = false;
// Give user some leeway for selections.
final int PROX_DIST = 3;

public Resizer(Resizing r) {
    component = r;
}

public void mousePressed(MouseEvent e) {
    if(component.getCursor() != Cursor.getDefaultCursor()) {
        // If cursor is set for resizing, allow dragging.
        dragging = true;
    }
}

public void mouseReleased(MouseEvent e) {
    dragging = false;
}

public void mouseDragged(MouseEvent e) {
    if(dragging){
        Point p = e.getPoint();
        Rectangle r = component.rect;
        int type = component.getCursor().getType();
        int dx = p.x - r.x;
        int dy = p.y - r.y;
        switch(type) {
            case Cursor.N_RESIZE_CURSOR:
                int height = r.height - dy;
                r.setRect(r.x, r.y+dy, r.width, height);
                break;
            case Cursor.S_RESIZE_CURSOR:
                height = dy;
                r.setRect(r.x, r.y, r.width, height);
                break;
            default:
                System.out.println("unexpected type: " + type);
        }
        component.repaint();
    }
}

public void mouseMoved(MouseEvent e) {
    Point p = e.getPoint();
    if(!isOverRect(p)) {
        if(component.getCursor() != Cursor.getDefaultCursor()) {
            // If cursor is not over rect reset it to the default.
            component.setCursor(Cursor.getDefaultCursor());
        }
        return;
    }
    // Locate cursor relative to center of rect.
    int outcode = getOutcode(p);
    Rectangle r = component.rect;
    switch(outcode) {
        case Rectangle.OUT_TOP:
            if(Math.abs(p.y - r.y) < PROX_DIST) {
                component.setCursor(Cursor.getPredefinedCursor(
                                    Cursor.N_RESIZE_CURSOR));
            }
            break;
        case Rectangle.OUT_BOTTOM:
            if(Math.abs(p.y - (r.y+r.height)) < PROX_DIST) {
                component.setCursor(Cursor.getPredefinedCursor(
                                    Cursor.S_RESIZE_CURSOR));
            }
            break;
        default:    // center
            component.setCursor(Cursor.getDefaultCursor());
    }
}

/**
 * Make a smaller Rectangle and use it to locate the
 * cursor relative to the Rectangle center.
 */
private int getOutcode(Point p) {
    Rectangle r = (Rectangle)component.rect.clone();
    r.grow(-PROX_DIST, -PROX_DIST);
    return r.outcode(p.x, p.y);
}

/**
 * Make a larger Rectangle and check to see if the
 * cursor is over it.
 */
private boolean isOverRect(Point p) {
    Rectangle r = (Rectangle)component.rect.clone();
    r.grow(PROX_DIST, PROX_DIST);
    return r.contains(p);
}
}

class Resizer2 extends MouseAdapter {
Resizing component2;
boolean dragging2 = false;
// Give user some leeway for selections.
final int PROX_DIST2 = 3;

public Resizer2(Resizing r2) {
    component2 = r2;
}

    @Override
public void mousePressed(MouseEvent e2) {
    if(component2.getCursor() != Cursor.getDefaultCursor()) {
        // If cursor is set for resizing, allow dragging.
        dragging2 = true;
    }
}

    @Override
public void mouseReleased(MouseEvent e2) {
    dragging2 = false;
}

    @Override
public void mouseDragged(MouseEvent e2) {
    if(dragging2) {
        Point p2 = e2.getPoint();
        Rectangle r2 = component2.rect2;
        int type = component2.getCursor().getType();
        int dx2 = p2.x - r2.x;
        int dy2 = p2.y - r2.y;
        switch(type) {
            case Cursor.N_RESIZE_CURSOR:
                int height = r2.height - dy2;
                r2.setRect(r2.x, r2.y+dy2, r2.width, height);
                break;
            case Cursor.S_RESIZE_CURSOR:
                height = dy2;
                r2.setRect(r2.x, r2.y, r2.width, height);
                break;
            default:
                System.out.println("unexpected type: " + type);
        }
        component2.repaint();
    }
}

public void mouseMoved(MouseEvent e2) {
    Point p2 = e2.getPoint();
    if(!isOverRect(p2)) {
        if(component2.getCursor() != Cursor.getDefaultCursor()) {
            // If cursor is not over rect reset it to the default.
            component2.setCursor(Cursor.getDefaultCursor());
        }
        return;
    }
    // Locate cursor relative to center of rect.
    int outcode = getOutcode(p2);
    Rectangle r2 = component2.rect2;
    switch(outcode) {
        case Rectangle.OUT_TOP:
            if(Math.abs(p2.y - r2.y) < PROX_DIST2) {
                component2.setCursor(Cursor.getPredefinedCursor(
                                    Cursor.N_RESIZE_CURSOR));
            }
            break;
        case Rectangle.OUT_BOTTOM:
            if(Math.abs(p2.y - (r2.y+r2.height)) < PROX_DIST2) {
                component2.setCursor(Cursor.getPredefinedCursor(
                                    Cursor.S_RESIZE_CURSOR));
            }
            break;
        default:    // center
            component2.setCursor(Cursor.getDefaultCursor());
    }
}

/**
 * Make a smaller Rectangle and use it to locate the
 * cursor relative to the Rectangle center.
 */
private int getOutcode(Point p2) {
    Rectangle r2 = (Rectangle)component2.rect2.clone();
    r2.grow(-PROX_DIST2, -PROX_DIST2);
    return r2.outcode(p2.x, p2.y);
}

/**
 * Make a larger Rectangle and check to see if the
 * cursor is over it.
 */
private boolean isOverRect(Point p2) {
    Rectangle r2 = (Rectangle)component2.rect2.clone();
    r2.grow(PROX_DIST2, PROX_DIST2);
    return r2.contains(p2);
}
}

Answer 1

在此基本example中，mouseDragged()处理程序计算dx和dy，即拖动鼠标时应用于对象的相对偏移量。在您的情况下，您将对两个矩形应用相同的偏移量。在引用here的更详细示例中，名为List<Node>的{{1}}包含当前选定的节点，selected更新所有选定节点的位置。

附录：我是Java编程的初学者，我根本看不到如何做到这一点。

使用新语言或不熟悉的图形库时，我发现从小例子开始是有帮助的。您可以查看一些引用here和here的替代方法。

Answer 2

您需要使用MouseMotionListener。 MouseListener无效。然后，您需要覆盖mouseDragged()

class Resizing extends JPanel impelemts MouseMotionListener {
    ...
    @Override
    public void mouseDragged(MouseEvent e){
        ...
    }
    public void mouseMoved(MouseEvent e){}
}

拖动鼠标时，会触发MouseEvent。使用该事件，您可以在拖动鼠标的任何给定时间获得该特定点

public void mouseDragged(MouseEvent e){
    Point p = e.getPoint();
}

关键是鼠标的位置。您可以使用其getX()和getY()方法在每个给定时刻获取该点的x和y位置

您希望声明为类成员的x和y变量保持该点，以便您可以在paint方法中使用它

int xLoc;
int yLoc;

在你mouseDragged中，您可以点MouseEvent点{x}和y点来设置xLoc和yLoc。然后重新粉刷

public void mouseDragged(MouseEvent e){
    Point p = e.getPoint();
    xLoc = p.getX();
    yLoc = p.getY();
    repaint();
}

在paintComponent()方法中，您将使用xLoc和yLoc绘制对象。因此，在每次拖动鼠标时，xLoc和yLoc都会不断更新并不断重新绘制。像

这样的东西

g2.fill(new Rectangle2D.Double(xLoc, yLoc, 50, 50));
g2.fill(new Rectangle2D.Double(xLoc + 100, yLoc + 100, 50, 50))

更新 - 示例程序。尝试并运行它

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


public class MoveRects extends JPanel {

    private static final int SCREEN_WIDTH = 600;
    private static final int SCREEN_HEIGHT = 600;
    int xLoc;
    int yLoc;

    public MoveRects(){
        addMouseMotionListener(new MouseMotionAdapter(){
            public void mouseDragged(MouseEvent e) {
                Point p = e.getPoint();
                xLoc = (int)p.getX();
                yLoc = (int)p.getY();
                repaint();
            }
        });
    }

    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        g.setColor(Color.GREEN);
        g.fillRect(xLoc, yLoc, 50, 50);
        g.setColor(Color.RED);
        g.fillRect(xLoc + 300, yLoc, 50, 50);
    }

    public Dimension getPreferredSize() {
        return new Dimension(SCREEN_WIDTH, SCREEN_HEIGHT);

    }

    public static void main(String[] args) {
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                JFrame frame = new JFrame();
                frame.add(new MoveRects());
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.pack();
                frame.setLocationRelativeTo(null);
                frame.setVisible(true);

            }
        });
    }
}

在一个JFrame中拖动和移动两个形状

2 个答案: