이미지 투명도 및 JPanel 이미지 배경

Question

안녕하세요 저는 이미지를 투명하게 만들고 새 이미지를 얻고 jpanel 배경으로 설정하려고합니다. 나도 알아, 이미 거기에 답변이 있다고 말할지도 모르지만 아무 것도 작동하지 않고 왜 그런지 모르겠다. 나는 정말로 도움이된다. 여기

코드입니다 :

import java.awt.AlphaComposite; 
import java.awt.Color; 
import java.awt.Font; 
import java.awt.Graphics; 
import java.awt.Graphics2D; 
import java.awt.Image; 
import java.awt.Toolkit; 
import java.awt.event.ActionEvent; 
import java.awt.event.ActionListener; 
import java.sql.Time; 

import javax.swing.Timer; 

import javax.swing.ImageIcon; 
import javax.swing.JLabel; 
import javax.swing.JPanel; 

public class DvdInterface extends JPanel { 

    private String cathegory; 
    private JPanel hiddenPnl = new JPanel(); 
    private JPanel imagePnl; 
    private ImageIcon imageLoading; 
    private TextAnimation textMoving = new TextAnimation(); 
    private ImageIcon bgImg; 
    private Timer tm; 
    private int x = 0; 
    private int y = 240; 
    private DvdInterface dvd; 



    public DvdInterface(){ 

     components(); 

     setVisible(true); 


    } 



    private void components(){ 


     this.setLayout(null); 
     JLabel text = new JLabel("Movie selector"); 
     JLabel select = new JLabel("Please select a movie"); 

     JLabel empty2 = new JLabel(""); 
     JLabel empty3 = new JLabel(""); 
     JLabel empty4 = new JLabel(""); 

     imageLoading = new ImageIcon("D:/Java Eclipe Workspace/Dvd sorter/Loading.jpg"); 
     Image img = imageLoading.getImage(); 
     Image tempImg = img.getScaledInstance(200, 250, Image.SCALE_SMOOTH); 

     imageLoading = new ImageIcon(tempImg); 

     JLabel labelImg = new JLabel(imageLoading, JLabel.CENTER); 


     labelImg.setBounds(198, 202, 200, 250); 
     text.setBounds(235, 150, 183, 57); 

     paintSelect(select); 
     paintSelect(text); 

     add(select); 
     add(labelImg); 
     add(text); 



     tm = new Timer(100, new ActionListener() { 

      @Override 
      public void actionPerformed(ActionEvent arg0) { 

       select.setBounds(205, 200, 250, 270); 

       if(x >= 0){ 

        x = x + 10; 

       } 

       if(x == 250){ 

        x = x - 150; 


       } 

       select.setForeground(new Color(0, 255, 100, x)); 

      } 
     }); 

     tm.start(); 

    } 




    public void setCathegory(String cathegory) { 
     this.cathegory = cathegory; 
    } 

    public void paintSelect(JLabel select){ 


     select.setFont(new Font("Engravers MT", Font.BOLD, 10)); 


    } 

} 

Answer 1

의 사용을 만들기 배경

import java.awt.Dimension; 
import java.awt.Graphics; 
import java.awt.Graphics2D; 
import java.awt.RenderingHints; 
import java.awt.Transparency; 
import java.awt.image.BufferedImage; 
import javax.swing.JPanel; 

public class BackgroundPane extends JPanel { 

    private BufferedImage img; 
    private BufferedImage scaled; 

    public BackgroundPane() { 
    } 

    @Override 
    public Dimension getPreferredSize() { 
     return img == null ? super.getPreferredSize() : new Dimension(img.getWidth(), img.getHeight()); 
    } 

    public void setBackground(BufferedImage value) { 
     if (value != img) { 
      this.img = value; 
      repaint(); 
     } 
    } 

    @Override 
    public void invalidate() { 
     super.invalidate(); 
     if (getWidth() > img.getWidth() || getHeight() > img.getHeight()) { 
      scaled = getScaledInstanceToFill(img, getSize()); 
     } else { 
      scaled = img; 
     } 
    } 

    @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 static BufferedImage getScaledInstanceToFill(BufferedImage img, Dimension size) { 

     double scaleFactor = getScaleFactorToFill(img, size); 

     return getScaledInstance(img, scaleFactor); 

    } 

    public static double getScaleFactorToFill(BufferedImage img, Dimension size) { 

     double dScale = 1; 

     if (img != null) { 

      int imageWidth = img.getWidth(); 
      int imageHeight = img.getHeight(); 

      double dScaleWidth = getScaleFactor(imageWidth, size.width); 
      double dScaleHeight = getScaleFactor(imageHeight, size.height); 

      dScale = Math.max(dScaleHeight, dScaleWidth); 

     } 

     return dScale; 

    } 

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

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

     return dScale; 

    } 

    public static BufferedImage getScaledInstance(BufferedImage img, double dScaleFactor) { 

     return getScaledInstance(img, dScaleFactor, RenderingHints.VALUE_INTERPOLATION_BILINEAR, true); 

    } 

    protected static BufferedImage getScaledInstance(BufferedImage img, double dScaleFactor, Object hint, boolean bHighQuality) { 

     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, hint, bHighQuality); 

     } else { 

      imgScale = getScaledUpInstance(img, iImageWidth, iImageHeight, hint, bHighQuality); 

     } 

     return imgScale; 

    } 

    protected static BufferedImage getScaledDownInstance(BufferedImage img, 
                              int targetWidth, 
                              int targetHeight, 
                              Object hint, 
                              boolean higherQuality) { 

     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; 
      if (higherQuality) { 
       // Use multi-step technique: start with original size, then 
       // scale down in multiple passes with drawImage() 
       // until the target size is reached 
       w = img.getWidth(); 
       h = img.getHeight(); 
      } else { 
       // Use one-step technique: scale directly from original 
       // size to target size with a single drawImage() call 
       w = targetWidth; 
       h = targetHeight; 
      } 

      do { 
       if (higherQuality && w > targetWidth) { 
        w /= 2; 
        if (w < targetWidth) { 
         w = targetWidth; 
        } 
       } 

       if (higherQuality && 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, 
                             boolean higherQuality) { 

     int type = BufferedImage.TYPE_INT_ARGB; 

     BufferedImage ret = (BufferedImage) img; 
     int w, h; 
     if (higherQuality) { 
      // Use multi-step technique: start with original size, then 
      // scale down in multiple passes with drawImage() 
      // until the target size is reached 
      w = img.getWidth(); 
      h = img.getHeight(); 
     } else { 
      // Use one-step technique: scale directly from original 
      // size to target size with a single drawImage() call 
      w = targetWidth; 
      h = targetHeight; 
     } 

     do { 
      if (higherQuality && w < targetWidth) { 
       w *= 2; 
       if (w > targetWidth) { 
        w = targetWidth; 
       } 
      } 

      if (higherQuality && 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; 
    } 

} 

로 Image 그림의 JPanel 할 수는 말했다와 패널

BufferedImage backgroundImage = ImageIO.read(...); 
BackgroundPane backgroundPane = new BackgroundPane(); 
backgroundPane.setBackground(backgroundImage); 

패널, 배경 이미지, 레이블 및 버튼

,

backgroundPane.setLayout(new GridBagLayout()); 
GridBagConstraints gbc = new GridBagConstraints(); 
gbc.gridwidth = GridBagConstraints.REMAINDER; 
backgroundPane.add(new JLabel("This is a label"), gbc); 
backgroundPane.add(new JButton("This is a button"), gbc); 

는 대부분의 구성 요소는 기본적으로 불투명 기억, 그래서 당신은 할 setOpaque(false)을 사용해야 할 수도 있습니다 그들 당신에 패널을 추가해야합니다, 어떤 점에서

(JLabel는 예외 중 하나입니다) 투명 이것은 (JFrame과 같은) 창 기반 클래스입니다. 왜냐하면이 클래스가 표시 할 수있는 유일한 방법이기 때문입니다.