Java 如何根据JButton的大小更改其字体大小？

我有一个java应用程序——计算器。我想通过调整应用程序窗口的大小来动态调整按钮的字体大小。如何实施

我的想法是使用ComponentEvents。我有应用程序窗口的初始大小和初始字体的大小。我想根据按钮的大小改变字体大小，受窗口大小改变的影响。问题是如何在重写方法中使用比率[初始窗口大小]/[初始字体大小]？每种字体的比例不同

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

public class Main extends JFrame {
    public Main() {
        super("Test");

        JPanel cPane = (JPanel) getContentPane();
        cPane.setLayout(new BorderLayout());
        MyButton sampleButton = new MyButton("Sample text");
        sampleButton.setFont(new Font("Sans Serif", Font.PLAIN, 20));

        MyButton a, b, c, d;
        a = new MyButton("a");
        b = new MyButton("b");
        c = new MyButton("c");
        d = new MyButton("d");




        cPane.add(a, BorderLayout.PAGE_START);
        cPane.add(b, BorderLayout.PAGE_END);
        cPane.add(c, BorderLayout.LINE_START);
        cPane.add(d, BorderLayout.LINE_END);

        cPane.add(sampleButton, BorderLayout.CENTER);
        setSize(300, 200);
        setResizable(true);
        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        setVisible(true);
    }

    public static void main(String... args) {
        new Main();
    }

    class MyButton extends JButton implements ComponentListener {
        public MyButton(String title) {
            super(title);
        }

        @Override
        public void componentResized(ComponentEvent e) {
            //resizing font
        }

        @Override
        public void componentMoved(ComponentEvent e) {

        }

        @Override
        public void componentShown(ComponentEvent e) {

        }

        @Override
        public void componentHidden(ComponentEvent e) {

        }
    }
}

---

比较所示和所示的方法。前者使用一种可用的方法

后者引用了一个使用

FontMentrics

的例子

或

TextLayout

---

查看如何使用

GlyphVector

来确定适合的最大

字体


GUI有点不稳定，除非在设置框架可见和添加
ComponentListener
之间有延迟。我通过使用单发Swing
计时器延迟添加侦听器来解决这个问题

Is基于它是一个使用
ScriptEngine
的功能完整（如果简单）的计算器



import java.awt.*；
导入java.awt.event.*；
导入java.awt.font.*；
导入java.awt.geom.Rectangle2D；
导入java.awt.image.buffereImage；
导入javax.swing.*；
导入javax.swing.border.EmptyBorder；
导入java.util.ArrayList；
导入javax.script.*；
导入javax.swing.border.border；
类SwingCalculator实现ActionListener、KeyListener{
jTextIO；
脚本引擎；
ArrayList控件；
最终缓冲区图像文本图像=新缓冲区图像(
100, 100,
BuffereImage.TYPE_INT_ARGB）；
public int getMaxFontSizeForControl（）{
Graphics2D g=textImage.createGraphics（）；
FontRenderContext frc=g.getFontRenderContext（）；
int maxSize=500；
用于（JButton b:控件）{
//跳过=按钮。。
如果（！b.getText（）.equals（“=”）{
int max=getMaxFontSizeForControl（b，frc）；
如果（最大尺寸>最大值）{
最大尺寸=最大值；
}
}
}
g、 处置（）；
返回最大大小；
}
public int getMaxFontSizeForControl（JButton按钮，FontRenderContext frc）{
矩形r=button.getBounds（）；
Insets m=button.getMargin（）；
Insets i=button.getBorder（）.getBorderInsets（按钮）；
矩形可视区域=新矩形(
r、 宽度-
（m.右+m.左+i.左+i.右），
r、 高度-
（m.top+m.bottom+i.top+i.bottom）
);
Font=button.getFont（）；
int size=1；
布尔值tooBig=false；
而（！太大了）{
Font f=Font.deriveFont（（浮点）大小）；
GlyphVector gv=f.createGlyphVector（frc，button.getText（））；
矩形2D框=gv.getVisualBounds（）；
if（box.getHeight（）>viewableArea.getHeight（）
||box.getWidth（）>viewableArea.getWidth（））{
太大=正确；
大小--；
}
大小++；
}
返回大小；
}
SwingCalculator（）{
//获取对JS引擎的引用
engine=new ScriptEngineManager（）.getEngineByExtension（“js”）；
jpanelgui=newjpanel（newborderlayout（2,2））；
控件=新的ArrayList（）；
JPanel text=newjpanel（新的网格布局（0,1,3,3））；
添加（文本，BorderLayout.NORTH）；
io=新的JTextField（15）；
Font=io.getFont（）；
font=font.deriveFont（font.getSize（）*1.7f）；
io.setFont（字体）；
io.SET水平对齐（SwingConstants.Training）；
io.setFocusable（假）；
文本。添加（io）；
JPanel按钮=新的JPanel（新的网格布局（4,4,2,2））；
添加（按钮、边框布局、中心）；
添加按钮（按钮，“7”）；
添加按钮（按钮，“8”）；
添加按钮（按钮，“9”）；
添加按钮（按钮“/”；
添加按钮（按钮，“4”）；
添加按钮（按钮，“5”）；
添加按钮（按钮，“6”）；
添加按钮（按钮“*”）；
添加按钮（按钮，“1”）；
添加按钮（按钮，“2”）；
添加按钮（按钮，“3”）；
添加按钮（按钮“-”）；
添加按钮（按钮，“0”）；
添加按钮（按钮“.”）；
添加按钮（按钮，“C”）；
添加按钮（按钮“+”）；
JButton等于=新JButton（“”）；
equals.addKeyListener（this）；
控件。添加（等于）；
equals.addActionListener（this）；
添加（等于，BorderLayout.EAST）；
setboorder（新的EmptyBorder（5,5,5,5））；
最终JFrame f=新JFrame（“Calculet”）；
f、 setDefaultCloseOperation（JFrame.EXIT_ON_CLOSE）；
f、 setContentPane（gui）；
f、 包装（）；
f、 setMinimumSize（f.getSize（））；
f、 setLocationByPlatform（真）；
f、 setVisible（真）；
最终ComponentListener cl=新ComponentAdapter（）{
@凌驾
公共无效组件已恢复（组件事件e）{
int ii=getMaxFontSizeForControl（）；
用于（JButton b:控件）{
如果（！b.getText（）.equals（“=”）{
b、 setFont（b.getFont（）.deriveFont（（float）ii））；
}
}
}
};
ActionListener al=新的ActionListener（）{
@凌驾
已执行的公共无效操作（操作事件e）{
f、 addComponentListener（cl）；
}
};
定时器t=新定时器（500，al）；
t、 设置重复（假）；
t、 start（）；
}
公共void addButton（容器c，字符串文本）{
JButton b=新JButton（文本）；
b、 addActionListener（此）；
b、 addKeyListener（此）；
增加（b）；
c、 加（b）
import java.awt.*;
import java.awt.event.*;
import java.awt.font.*;
import java.awt.geom.Rectangle2D;
import java.awt.image.BufferedImage;
import javax.swing.*;
import javax.swing.border.EmptyBorder;
import java.util.ArrayList;
import javax.script.*;
import javax.swing.border.Border;

class SwingCalculator implements ActionListener, KeyListener {

    JTextField io;
    ScriptEngine engine;
    ArrayList<JButton> controls;
    final BufferedImage textImage = new BufferedImage(
            100, 100,
            BufferedImage.TYPE_INT_ARGB);

    public int getMaxFontSizeForControls() {
        Graphics2D g = textImage.createGraphics();
        FontRenderContext frc = g.getFontRenderContext();
        int maxSize = 500;
        for (JButton b : controls) {
            // skip the = button..
            if (!b.getText().equals("=")) {
                int max = getMaxFontSizeForControl(b, frc);
                if (maxSize > max) {
                    maxSize = max;
                }
            }
        }
        g.dispose();
        return maxSize;
    }

    public int getMaxFontSizeForControl(JButton button, FontRenderContext frc) {
        Rectangle r = button.getBounds();
        Insets m = button.getMargin();
        Insets i = button.getBorder().getBorderInsets(button);
        Rectangle viewableArea = new Rectangle(
                r.width - 
                (m.right + m.left + i.left + i.right),
                r.height - 
                (m.top + m.bottom + i.top + i.bottom)
                );
        Font font = button.getFont();
        int size = 1;
        boolean tooBig = false;
        while (!tooBig) {
            Font f = font.deriveFont((float) size);
            GlyphVector gv = f.createGlyphVector(frc, button.getText());
            Rectangle2D box = gv.getVisualBounds();
            if (box.getHeight() > viewableArea.getHeight()
                    || box.getWidth() > viewableArea.getWidth()) {
                tooBig = true;
                size--;
            }
            size++;
        }
        return size;
    }

    SwingCalculator() {
        // obtain a reference to the JS engine
        engine = new ScriptEngineManager().getEngineByExtension("js");

        JPanel gui = new JPanel(new BorderLayout(2, 2));
        controls = new ArrayList<JButton>();

        JPanel text = new JPanel(new GridLayout(0, 1, 3, 3));
        gui.add(text, BorderLayout.NORTH);
        io = new JTextField(15);
        Font font = io.getFont();
        font = font.deriveFont(font.getSize() * 1.7f);
        io.setFont(font);
        io.setHorizontalAlignment(SwingConstants.TRAILING);
        io.setFocusable(false);
        text.add(io);

        JPanel buttons = new JPanel(new GridLayout(4, 4, 2, 2));
        gui.add(buttons, BorderLayout.CENTER);
        addButton(buttons, "7");
        addButton(buttons, "8");
        addButton(buttons, "9");
        addButton(buttons, "/");

        addButton(buttons, "4");
        addButton(buttons, "5");
        addButton(buttons, "6");
        addButton(buttons, "*");

        addButton(buttons, "1");
        addButton(buttons, "2");
        addButton(buttons, "3");
        addButton(buttons, "-");

        addButton(buttons, "0");
        addButton(buttons, ".");
        addButton(buttons, "C");
        addButton(buttons, "+");

        JButton equals = new JButton("=");
        equals.addKeyListener(this);
        controls.add(equals);
        equals.addActionListener(this);
        gui.add(equals, BorderLayout.EAST);

        gui.setBorder(new EmptyBorder(5, 5, 5, 5));

        final JFrame f = new JFrame("Calculet");
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.setContentPane(gui);
        f.pack();
        f.setMinimumSize(f.getSize());
        f.setLocationByPlatform(true);
        f.setVisible(true);

        final ComponentListener cl = new ComponentAdapter() {

            @Override
            public void componentResized(ComponentEvent e) {
                int ii = getMaxFontSizeForControls();
                for (JButton b : controls) {
                    if (!b.getText().equals("=")) {
                        b.setFont(b.getFont().deriveFont((float) ii));
                    }
                }
            }
        };
        ActionListener al = new ActionListener() {

            @Override
            public void actionPerformed(ActionEvent e) {
                f.addComponentListener(cl);
            }
        };
        Timer t = new Timer(500, al);
        t.setRepeats(false);
        t.start();
    }

    public void addButton(Container c, String text) {
        JButton b = new JButton(text);
        b.addActionListener(this);
        b.addKeyListener(this);
        controls.add(b);
        c.add(b);
    }

    public void calculateResult() {
        try {
            Object result = engine.eval(io.getText());
            if (result == null) {
                io.setText("Output was 'null'");
            } else {
                io.setText(result.toString());
            }
        } catch (ScriptException se) {
            io.setText(se.getMessage());
        }
    }

    public void actionPerformed(ActionEvent ae) {
        String command = ae.getActionCommand();
        if (command.equals("C")) {
            io.setText("");
        } else if (command.equals("=")) {
            calculateResult();
        } else {
            io.setText(io.getText() + command);
        }
    }

    private JButton getButton(String text) {
        for (JButton button : controls) {
            String s = button.getText();
            if (text.endsWith(s)
                    || (s.equals("=")
                    && (text.equals("Equals") || text.equals("Enter")))) {

                return button;
            }
        }
        return null;
    }

    /*
     * START - Because I hate mice.
     */
    public void keyPressed(KeyEvent ke) {
    }

    public void keyReleased(KeyEvent ke) {
        String s = ke.getKeyText(ke.getKeyCode());
        JButton b = getButton(s);
        if (b != null) {
            b.requestFocusInWindow();
            b.doClick();
        }
    }

    public void keyTyped(KeyEvent ke) {
    }

    public static void main(String[] args) {
        Runnable r = new Runnable() {

            @Override
            public void run() {
                new SwingCalculator();
            }
        };
        // Swing GUIs should be created and updated on the EDT
        // http://docs.oracle.com/javase/tutorial/uiswing/concurrency
        SwingUtilities.invokeLater(r);
    }
}