java 图像在屏幕_java – 在任何屏幕分辨率中定位图像

以你之姓@ 2022-11-03 04:28 259阅读 0赞

我宁愿一直尝试在框架的边界内工作,从长远来看,它使生活变得更加容易.

Swing已经开始设计用于LayoutManagers,这意味着Swing更新它的组件并传达这些更改的方式是基于LayoutManagers的使用(或多或少).

下面的示例使用Java: maintaining aspect ratio of JPanel background image中的片段来缩放图像,以及一个PropertionalLayoutManager,它不仅可以根据父容器的大小尝试缩放组件的大小,还可以缩放组件的位置.

这里演示的PropertionalLayoutManager将尝试围绕父容器的中心布局组件.你可以改变它,但它看起来很奇怪 – 恕我直言

import java.awt.BorderLayout;

import java.awt.Component;

import java.awt.Container;

import java.awt.Dimension;

import java.awt.EventQueue;

import java.awt.Graphics;

import java.awt.Graphics2D;

import java.awt.LayoutManager2;

import java.awt.RenderingHints;

import java.awt.Transparency;

import java.awt.image.BufferedImage;

import java.io.File;

import java.io.IOException;

import java.util.Map;

import java.util.WeakHashMap;

import javax.imageio.ImageIO;

import javax.swing.JFrame;

import javax.swing.JPanel;

import javax.swing.UIManager;

import javax.swing.UnsupportedLookAndFeelException;

public class Drums \{

protected static BufferedImage SYMBOL;

protected static BufferedImage DRUM;

public static void main(String\[\] args) \{

new Drums();

public Drums() \{

EventQueue.invokeLater(new Runnable() \{

@Override

public void run() \{

try \{

UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());

\} catch (ClassNotFoundException | InstantiationException | IllegalAccessException | UnsupportedLookAndFeelException ex) \{

JFrame frame = new JFrame("Testing");

frame.setDefaultCloseOperation(JFrame.EXIT\_ON\_CLOSE);

frame.setLayout(new BorderLayout());

frame.add(new TestPane());

frame.pack();

frame.setLocationRelativeTo(null);

frame.setVisible(true);

\});

public class TestPane extends JPanel \{

public TestPane() \{

setLayout(new PropertionalLayoutManager(400, 400));

add(new Symbol(), new PropertionalConstraint(0f, 0));

add(new Symbol(), new PropertionalConstraint(0.67f, 0));

add(new Symbol(), new PropertionalConstraint(0f, 0.4675f));

add(new Symbol(), new PropertionalConstraint(0.67f, 0.4675f));

add(new Drum(), new PropertionalConstraint(0.205f, 0.1f));

add(new Drum(), new PropertionalConstraint(0.5f, 0.1f));

add(new Drum(), new PropertionalConstraint(0f, 0.33f));

add(new Drum(), new PropertionalConstraint(0.705f, 0.33f));

public class PropertionalConstraint \{

private float x;

private float y;

public PropertionalConstraint(float x, float y) \{

this.x = x;

this.y = y;

public float getX() \{

return x;

public float getY() \{

return y;

public class PropertionalLayoutManager implements LayoutManager2 \{

private Map constraints;

private Dimension defaultSize;

public PropertionalLayoutManager(int defaultWidth, int defaultHeight) \{

constraints = new WeakHashMap<>(25);

defaultSize = new Dimension(defaultWidth, defaultHeight);

@Override

public void addLayoutComponent(Component comp, Object constraint) \{

if (constraint instanceof PropertionalConstraint) \{

constraints.put(comp, ((PropertionalConstraint) constraint));

@Override

public Dimension maximumLayoutSize(Container target) \{

return preferredLayoutSize(target);

@Override

public float getLayoutAlignmentX(Container target) \{

return 0.5f;

@Override

public float getLayoutAlignmentY(Container target) \{

return 0.5f;

@Override

public void invalidateLayout(Container target) \{

@Override

public void addLayoutComponent(String name, Component comp) \{

@Override

public void removeLayoutComponent(Component comp) \{

constraints.remove(comp);

@Override

public Dimension preferredLayoutSize(Container parent) \{

return defaultSize;

@Override

public Dimension minimumLayoutSize(Container parent) \{

return preferredLayoutSize(parent);

@Override

public void layoutContainer(Container parent) \{

int width = parent.getWidth();

int height = parent.getHeight();

double dScaleWidth = getScaleFactor(defaultSize.width, width);

double dScaleHeight = getScaleFactor(defaultSize.height, height);

double scaleSize = Math.min(dScaleHeight, dScaleWidth);

int minRange = Math.min(width, height);

if (width > 0 && height > 0) \{

int maxY = 0;

int maxX = 0;

for (Component comp : parent.getComponents()) \{

PropertionalConstraint p = constraints.get(comp);

if (p != null) \{

Dimension prefSize = comp.getPreferredSize();

prefSize.width \*= scaleSize;

prefSize.height \*= scaleSize;

int x = Math.round(minRange \* p.getX());

int y = Math.round(minRange \* p.getY());

comp.setBounds(x, y, prefSize.width, prefSize.height);

maxX = Math.max(maxX, x + prefSize.width);

maxY = Math.max(maxY, y + prefSize.height);

\} else \{

comp.setBounds(0, 0, 0, 0);

for (Component comp : parent.getComponents()) \{

System.out.println("maxX = " + maxX);

System.out.println("maxY = " + maxY);

if (comp.getWidth() > 0 && comp.getHeight() > 0) \{

int x = ((width - maxX) / 2) + comp.getX();

int y = ((height - maxY) / 2) + comp.getY();

comp.setLocation(x, y);

\} else \{

for (Component comp : parent.getComponents()) \{

comp.setBounds(0, 0, 0, 0);

public abstract class AbstractKitPiecePane extends JPanel \{

private BufferedImage scaled;

public AbstractKitPiecePane() \{

setOpaque(false);

public abstract BufferedImage getKitImage();

@Override

public Dimension getPreferredSize() \{

return new Dimension(getKitImage().getWidth(), getKitImage().getHeight());

@Override

public void invalidate() \{

super.invalidate();

if (getWidth() > 0 && getHeight() > 0) \{

scaled = getScaledInstanceToFit(getKitImage(), getSize());

\} else \{

scaled = null;

@Override

protected void paintComponent(Graphics g) \{

super.paintComponent(g);

if (scaled != null) \{

int x = (getWidth() - scaled.getWidth()) / 2;

int y = (getHeight() - scaled.getHeight()) / 2;

g.drawImage(scaled, x, y, this);

public class Drum extends AbstractKitPiecePane \{

@Override

public BufferedImage getKitImage() \{

return DRUM;

public class Symbol extends AbstractKitPiecePane \{

@Override

public BufferedImage getKitImage() \{

return SYMBOL;

protected static BufferedImage getScaledInstance(BufferedImage img, double dScaleFactor) \{

BufferedImage imgScale = img;

int iImageWidth = (int) Math.round(img.getWidth() \* dScaleFactor);

int iImageHeight = (int) Math.round(img.getHeight() \* dScaleFactor);

if (dScaleFactor <= 1.0d) \{

imgScale = getScaledDownInstance(img, iImageWidth, iImageHeight, RenderingHints.VALUE\_INTERPOLATION\_BILINEAR);

\} else \{

imgScale = getScaledUpInstance(img, iImageWidth, iImageHeight, RenderingHints.VALUE\_INTERPOLATION\_BILINEAR);

return imgScale;

protected static BufferedImage getScaledDownInstance(BufferedImage img,

int targetWidth,

int targetHeight,

Object hint) \{

// System.out.println("Scale down...");

int type = (img.getTransparency() == Transparency.OPAQUE)

? BufferedImage.TYPE\_INT\_RGB : BufferedImage.TYPE\_INT\_ARGB;

BufferedImage ret = (BufferedImage) img;

if (targetHeight > 0 || targetWidth > 0) \{

int w, h;

w = img.getWidth();

h = img.getHeight();

do \{

if (w > targetWidth) \{

w /= 2;

if (w < targetWidth) \{

w = targetWidth;

if (h > targetHeight) \{

h /= 2;

if (h < targetHeight) \{

h = targetHeight;

BufferedImage tmp = new BufferedImage(Math.max(w, 1), Math.max(h, 1), type);

Graphics2D g2 = tmp.createGraphics();

g2.setRenderingHint(RenderingHints.KEY\_INTERPOLATION, hint);

g2.drawImage(ret, 0, 0, w, h, null);

g2.dispose();

ret = tmp;

\} while (w != targetWidth || h != targetHeight);

\} else \{

ret = new BufferedImage(1, 1, type);

return ret;

protected static BufferedImage getScaledUpInstance(BufferedImage img,

int targetWidth,

int targetHeight,

Object hint) \{

int type = BufferedImage.TYPE\_INT\_ARGB;

BufferedImage ret = (BufferedImage) img;

int w, h;

w = img.getWidth();

h = img.getHeight();

do \{

if (w < targetWidth) \{

w \*= 2;

if (w > targetWidth) \{

w = targetWidth;

if (h < targetHeight) \{

h \*= 2;

if (h > targetHeight) \{

h = targetHeight;

BufferedImage tmp = new BufferedImage(w, h, type);

Graphics2D g2 = tmp.createGraphics();

g2.setRenderingHint(RenderingHints.KEY\_INTERPOLATION, hint);

g2.drawImage(ret, 0, 0, w, h, null);

g2.dispose();

ret = tmp;

tmp = null;

\} while (w != targetWidth || h != targetHeight);

return ret;

public static BufferedImage getScaledInstanceToFit(BufferedImage img, Dimension size) \{

double scaleFactor = getScaleFactorToFit(img, size);

return getScaledInstance(img, scaleFactor);

public static double getScaleFactorToFit(BufferedImage img, Dimension size) \{

double dScale = 1;

if (img != null) \{

int imageWidth = img.getWidth();

int imageHeight = img.getHeight();

dScale = getScaleFactorToFit(new Dimension(imageWidth, imageHeight), size);

return dScale;

public static double getScaleFactorToFit(Dimension original, Dimension toFit) \{

double dScale = 1d;

if (original != null && toFit != null) \{

double dScaleWidth = getScaleFactor(original.width, toFit.width);

double dScaleHeight = getScaleFactor(original.height, toFit.height);

dScale = Math.min(dScaleHeight, dScaleWidth);

return dScale;

public static double getScaleFactor(int iMasterSize, int iTargetSize) \{

double dScale = 1;

if (iMasterSize > iTargetSize) \{

dScale = (double) iTargetSize / (double) iMasterSize;

\} else \{

dScale = (double) iTargetSize / (double) iMasterSize;

return dScale;

static \{

try \{

SYMBOL = ImageIO.read(new File("Symbol.png"));

\} catch (IOException ex) \{

ex.printStackTrace();

try \{

DRUM = ImageIO.read(new File("Drum.png"));

\} catch (IOException ex) \{

ex.printStackTrace();

以及程序中使用的图像,供您享受.它们位于运行程序的同一目录中

java 图像在屏幕_java – 在任何屏幕分辨率中定位图像

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关屏幕分辨率：PC / 手机屏幕常见分辨率，前端如何适配分辨率

相关修改屏幕分辨率

相关 css获取屏幕分辨率

相关 SDL编程入门（2）在屏幕上显示图像

相关 java 图像在屏幕_java – 在任何屏幕分辨率中定位图像

相关 iPhone屏幕分辨率

相关根据屏幕分辨率操作

相关 Unity中快速给Object在屏幕上定位

相关如何得到屏幕分辨率？

相关屏幕分辨率