Java 如何制作曲线形状的JSlider？

我想为我父母的房地产代理度假租赁在线预订服务创建一个Java应用程序

不幸的是，我还不能发布图片，但他们想要一种滑块式的预订服务，用户可以滑动吧台选择价格、卧室等。他们给我的设计使用了弧形滑块，但我似乎无法在网上找到任何帮助。他们希望在一个圆圈内有5个滑块，显示选定的图形，并有一个按钮进行确认

有人有什么想法吗？它会画一条圆曲线或类似的东西吗？此外，这将是更多的麻烦比它的价值-毕竟有在线替代预订系统，但最好有一个定制的一个创建

---

感谢您的帮助。

当涉及GUI组件及其外观、样式、行为和预期用途的细节时，通常有无限多的自由度

这应该通过专门的外观和感觉来解决吗？是否有可能影响颜色？“旋钮”的宽度是多少？曲线的开始角和结束角？您想在后台使用

BoundedRangeModel

，将其作为

JSlider

的替代品吗

然而，我写了一个非常简单的草图，完全基于自己的绘画和鼠标侦听器：可以修改最小和最大角度和值，并用鼠标拖动旋钮

由于缺乏细节，不清楚这是否适合您。它没有“BoundedRangeModel”。它不支持侦听器（尽管这是最容易添加的）。边界案例的行为可能存在一些小问题，解决这些问题的方法将取决于您根本没有指定的细节

这就是它看起来的样子：

该守则的内容如下：

import java.awt.BasicStroke；
导入java.awt.BorderLayout；
导入java.awt.Color；
导入java.awt.Graphics；
导入java.awt.Graphics2D；
导入java.awt.GridLayout；
导入java.awt.Point；
导入java.awt.RenderingHints；
导入java.awt.Shape；
导入java.awt.event.MouseEvent；
导入java.awt.event.MouseListener；
导入java.awt.event.MouseMotionListener；
导入java.awt.geom.Arc2D；
导入java.awt.geom.Area；
导入java.awt.geom.Ellipse2D；
导入java.awt.geom.Line2D；
导入java.io.IOException；
导入javax.swing.JFrame；
导入javax.swing.JLabel；
导入javax.swing.JPanel；
导入javax.swing.JSlider；
导入javax.swing.SwingUtilities；
导入javax.swing.event.ChangeEvent；
导入javax.swing.event.ChangeListener；
公共类曲线滑块测试
{
公共静态void main（字符串[]args）引发IOException
{
SwingUtilities.invokeLater（新的Runnable（）
{
@凌驾
公开募捐
{
createAndShowGUI（）；
}
});
}
私有静态void createAndShowGUI（）
{
JFrame f=新的JFrame（）；
f、 setDefaultCloseOperation（JFrame.EXIT_ON_CLOSE）；
f、 getContentPane（）.setLayout（新的BorderLayout（））；
CurvedSlider仪表面板=新的CurvedSlider（）；
f、 getContentPane（）.add（gaugePanel，BorderLayout.CENTER）；
JPanel控制面板=createControlPanel（仪表面板）；
f、 getContentPane（）.add（控制面板，BorderLayout.NORTH）；
f、 设置大小（600800）；
f、 setLocationRelativeTo（空）；
f、 setVisible（真）；
}
静态JPanel createControlPanel（最终曲线滑块仪表面板）
{
最终JSlider minAngleSlider=新JSlider（0,100,0）；
最终JSlider maxAngleSlider=新JSlider（0,100,0）；
最终JSlider minValueSlider=新JSlider（0,100,0）；
最终JSlider maxValueSlider=新JSlider（0,100,0）；
最终JSlider valueSlider=新JSlider（0,100,0）；
JPanel控制面板=新JPanel（新网格布局（0,2））；
添加（新的JLabel（“minAngle”）；
controlPanel.add（minAngleSlider）；
添加（新JLabel（“maxangel”）；
控制面板。添加（maxAngleSlider）；
添加（新JLabel（“minValue”））；
添加（minValueSlider）；
添加（新JLabel（“maxValue”）；
添加（maxValueSlider）；
添加（新JLabel（“值”））；
添加（值滑块）；
ChangeListener ChangeListener=新的ChangeListener（）
{
@凌驾
公共无效状态已更改（更改事件e）
{
double minAngle=minAngleSlider.getValue（）/100.0*Math.PI*2；
double maxAngle=maxAngleSlider.getValue（）/100.0*Math.PI*2；
double minValue=minValueSlider.getValue（）/100.0；
double maxValue=maxValueSlider.getValue（）/100.0；
double value=valueSlider.getValue（）/100.0；
仪表面板设置角度（米南格尔、maxAngle）；
gaugePanel.setRange（最小值、最大值）；
仪表面板设置值（值）；
}
};
minAngleSlider.addChangeListener（changeListener）；
maxAngleSlider.addChangeListener（changeListener）；
minValueSlider.addChangeListener（changeListener）；
maxValueSlider.addChangeListener（changeListener）；
valueSlider.addChangeListener（changeListener）；
设置值（50）；
maxAngleSlider.setValue（0）；
minValueSlider.setValue（10）；
maxValueSlider.setValue（90）；
valueSlider.setValue（50）；
返回控制面板；
}
}
类CurvedSlider扩展JPanel实现MouseListener、MouseMotionListener
{
私人双米南格勒=0.0；
专用双maxAngleRad=0.0；
私有双最小值=0.0；
专用双maxValue=0.0；
私有双值=0.0；
曲线滑块（）
{
addMouseListener（这个）；
addMouseMotionListener（此）；
}
空隙设置角（双米纳角）
import java.awt.BasicStroke;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.GridLayout;
import java.awt.Point;
import java.awt.RenderingHints;
import java.awt.Shape;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.awt.geom.Arc2D;
import java.awt.geom.Area;
import java.awt.geom.Ellipse2D;
import java.awt.geom.Line2D;
import java.io.IOException;

import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JSlider;
import javax.swing.SwingUtilities;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;


public class CurvedSliderTest
{
    public static void main(String[] args) throws IOException
    {
        SwingUtilities.invokeLater(new Runnable()
        {
            @Override
            public void run()
            {
                createAndShowGUI();
            }
        });
    }

    private static void createAndShowGUI()
    {
        JFrame f = new JFrame();
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        f.getContentPane().setLayout(new BorderLayout());

        CurvedSlider gaugePanel = new CurvedSlider();
        f.getContentPane().add(gaugePanel, BorderLayout.CENTER);

        JPanel controlPanel = createControlPanel(gaugePanel);
        f.getContentPane().add(controlPanel, BorderLayout.NORTH);

        f.setSize(600,800);
        f.setLocationRelativeTo(null);
        f.setVisible(true);
    }

    static JPanel createControlPanel(final CurvedSlider gaugePanel)
    {
        final JSlider minAngleSlider = new JSlider(0, 100, 0);
        final JSlider maxAngleSlider = new JSlider(0, 100, 0);
        final JSlider minValueSlider = new JSlider(0, 100, 0);
        final JSlider maxValueSlider = new JSlider(0, 100, 0);
        final JSlider valueSlider = new JSlider(0, 100, 0);

        JPanel controlPanel = new JPanel(new GridLayout(0,2));
        controlPanel.add(new JLabel("minAngle"));
        controlPanel.add(minAngleSlider);
        controlPanel.add(new JLabel("maxAngle"));
        controlPanel.add(maxAngleSlider);
        controlPanel.add(new JLabel("minValue"));
        controlPanel.add(minValueSlider);
        controlPanel.add(new JLabel("maxValue"));
        controlPanel.add(maxValueSlider);
        controlPanel.add(new JLabel("value"));
        controlPanel.add(valueSlider);

        ChangeListener changeListener = new ChangeListener()
        {
            @Override
            public void stateChanged(ChangeEvent e)
            {
                double minAngle = minAngleSlider.getValue() / 100.0 * Math.PI * 2;
                double maxAngle = maxAngleSlider.getValue() / 100.0 * Math.PI * 2;
                double minValue = minValueSlider.getValue() / 100.0;
                double maxValue = maxValueSlider.getValue() / 100.0;
                double value = valueSlider.getValue() / 100.0;

                gaugePanel.setAngles(minAngle, maxAngle);
                gaugePanel.setRange(minValue, maxValue);
                gaugePanel.setValue(value);
            }
        };
        minAngleSlider.addChangeListener(changeListener);
        maxAngleSlider.addChangeListener(changeListener);
        minValueSlider.addChangeListener(changeListener);
        maxValueSlider.addChangeListener(changeListener);
        valueSlider.addChangeListener(changeListener);

        minAngleSlider.setValue(50);
        maxAngleSlider.setValue(0);
        minValueSlider.setValue(10);
        maxValueSlider.setValue(90);
        valueSlider.setValue(50);

        return controlPanel;
    }


}



class CurvedSlider extends JPanel implements MouseListener, MouseMotionListener
{
    private double minAngleRad = 0.0;
    private double maxAngleRad = 0.0;
    private double minValue = 0.0;
    private double maxValue = 0.0;
    private double value = 0.0;

    CurvedSlider()
    {
        addMouseListener(this);
        addMouseMotionListener(this);
    }

    void setAngles(double minAngleRad, double maxAngleRad)
    {
        this.minAngleRad = minAngleRad;
        this.maxAngleRad = maxAngleRad;
        repaint();
    }

    void setRange(double minValue, double maxValue)
    {
        this.minValue = minValue;
        this.maxValue = maxValue;
        repaint();
    }

    void setValue(double value)
    {
        this.value = value;
        repaint();
    }

    @Override
    protected void paintComponent(Graphics gr)
    {
        super.paintComponent(gr);
        Graphics2D g = (Graphics2D)gr;
        g.setRenderingHint(
            RenderingHints.KEY_ANTIALIASING, 
            RenderingHints.VALUE_ANTIALIAS_ON);
        g.setColor(Color.WHITE);
        g.fillRect(0,0,getWidth(),getHeight());

        boolean printValues = false;
        printValues = true;
        if (printValues)
        {
            int ty = 20;
            g.setColor(Color.BLACK);
            g.drawString("minAngle "+Math.toDegrees(minAngleRad), 20, ty+=20);
            g.drawString("maxAngle "+Math.toDegrees(maxAngleRad), 20, ty+=20);
            g.drawString("minValue "+minValue, 20, ty+=20);
            g.drawString("maxValue "+maxValue, 20, ty+=20);
            g.drawString("value "+value, 20, ty+=20);
        }

        double alpha = (value - minValue) / (maxValue - minValue);
        double angleRad = minAngleRad + alpha * (maxAngleRad - minAngleRad);

        double radius = Math.min(getWidth(), getHeight()) / 3.0;

        final double thickness = 15;
        double xC = getWidth() / 2.0;
        double yC = getHeight() / 2.0;
        double x0 = xC + Math.cos(angleRad) * (radius - thickness);
        double y0 = yC - Math.sin(angleRad) * (radius - thickness);
        double x1 = xC + Math.cos(angleRad) * radius;
        double y1 = yC - Math.sin(angleRad) * radius;

        Shape background0 = new Arc2D.Double(
            xC-radius, yC-radius, 
            radius+radius, radius+radius, 
            Math.toDegrees(minAngleRad), 
            Math.toDegrees(maxAngleRad-minAngleRad), 
            Arc2D.PIE);

        Shape background1 = new Ellipse2D.Double(
            xC-radius+thickness, yC-radius+thickness, 
            radius+radius-thickness-thickness, 
            radius+radius-thickness-thickness);

        Area a = new Area(background0);
        a.subtract(new Area(background1));

        g.setColor(Color.GRAY);
        g.fill(a);
        g.setStroke(new BasicStroke(3.0f, 
            BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
        g.setColor(Color.LIGHT_GRAY);
        g.draw(a);

        g.setStroke(new BasicStroke(8.0f, 
            BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
        g.setColor(Color.BLACK);
        g.draw(new Line2D.Double(x0, y0, x1, y1));
    }

    private void updateAngle(Point p)
    {
        double xC = getWidth() / 2.0;
        double yC = getHeight() / 2.0;
        double dx = p.getX() - xC;
        double dy = p.getY() - yC;
        double angleRad = Math.atan2(-dy, dx);
        if (angleRad < -Math.PI / 2)
        {
            angleRad = 2 * Math.PI + angleRad;
        }
        angleRad = Math.max(maxAngleRad, Math.min(minAngleRad, angleRad));
        double alpha = (angleRad - minAngleRad) / (maxAngleRad - minAngleRad);
        double value = minValue + alpha * (maxValue - minValue);
        setValue(value);
    }

    @Override
    public void mouseDragged(MouseEvent e)
    {
        updateAngle(e.getPoint());
    }

    @Override
    public void mouseMoved(MouseEvent e)
    {
    }

    @Override
    public void mousePressed(MouseEvent e)
    {
        updateAngle(e.getPoint());
    }

    @Override
    public void mouseClicked(MouseEvent e)
    {
    }

    @Override
    public void mouseReleased(MouseEvent e)
    {
    }

    @Override
    public void mouseEntered(MouseEvent e)
    {
    }

    @Override
    public void mouseExited(MouseEvent e)
    {
    }
}