Repaint without painting every component again

Question

i have an application containing a jframe, this jframe then adds a jpanel which constains an image. the jpanel is displayed for a given time, then removed from the jframe and another jpanel is added.

I want to fade in and out between the images, and ive done this using a timer

private void fadeOut() {
    ActionListener fadeOutAc = new ActionListener() {
        @Override
        public void actionPerformed(ActionEvent e) {
            opacity += 10;
            if (opacity >= 255) {
                opacity = 255;
                fadeOutT.stop();

            }
            repaint();
        }
    };

    fadeOutT = new Timer(20, fadeOutAc);
    fadeOutT.start();
}

private void fadeIn() {
    ActionListener fadeInAc = new ActionListener() {
        @Override
        public void actionPerformed(ActionEvent e) {
            opacity -= 10;
            if (opacity <= 0) {
                opacity = 0;
                fadeInT.stop();
            }
            repaint();

        }
    };
    fadeInT = new Timer(10, fadeInAc);
    fadeInT.setInitialDelay(200);
    fadeInT.start();

}

public void paint(Graphics g) {
    super.paintComponent(g);
    g.setColor(new Color(picColor.getRed(), picColor.getGreen(), picColor.getBlue(), opacity));
    g.fillRect(0, 0, presWin.getWidth(), presWin.getHeight());
}

i recently moved the fading in/out from the jpanel to the jframe instead. The problem is, that in the jpanel, the repaint only had to draw an image, now it has to repaint the entire jpanel each time. Is there a way to call repaint without having the paint the components, only the rectangel?

MadProgrammer · Accepted Answer

To me, it seems a bit silly to put the functionality in the JFrame when what you seem to want is a container which can fade it's content in and out. This way you can isolate the responsibility to a single container/class which can be placed or used in what ever way you want in isolation to the rest of the UI.

Basically, this example uses a FadingPane (based on a JPanel) to control the fading process, but onto which I place JLabel which holds the actual images.

Fading is controlled through the use of a AlphaComposite, meaning that this panel will actually physically fade in and out, not just change fill color ;)

There is also a FadingListener which provides additional notifications about the fading process, really only interested in fadeOutDidComplete, so you can switch the images and fade the panel back in, but you never know...

Fading

import java.awt.AlphaComposite;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.EventQueue;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import javax.imageio.ImageIO;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.Timer;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;

public class Test {

    public static void main(String[] args) {
        new Test();
    }

    public Test() {
        EventQueue.invokeLater(new Runnable() {
            @Override
            public void run() {
                try {
                    UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
                } catch (ClassNotFoundException | InstantiationException | IllegalAccessException | UnsupportedLookAndFeelException ex) {
                    ex.printStackTrace();
                }

                JFrame frame = new JFrame("Testing");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.add(new TestPane());
                frame.pack();
                frame.setLocationRelativeTo(null);
                frame.setVisible(true);
            }
        });
    }

    public class TestPane extends JPanel {

        private JLabel label;
        private FadingPane fadingPane;

        private File[] pictures;
        private int index;

        public TestPane() {
            // Just for show 
            setBackground(Color.RED);
            fadingPane = new FadingPane(new FadeListener() {
                @Override
                public void fadeDidStart(FadingPane panel) {
                }

                @Override
                public void fadeDidStop(FadingPane panel) {
                }

                @Override
                public void fadeOutDidComplete(FadingPane panel) {
                    nextPicture();
                    fadingPane.fadeIn();
                }

                @Override
                public void fadeInDidComplete(FadingPane panel) {
                }
            });
            setLayout(new BorderLayout());
            fadingPane.setLayout(new BorderLayout());
            label = new JLabel();
            fadingPane.add(label);

            add(fadingPane);

            JButton next = new JButton("Next");
            add(next, BorderLayout.SOUTH);
            next.addActionListener(new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    fadingPane.fadeOut();
                }
            });

            pictures = new File("/Volumes/Disk02/Dropbox/MegaTokyo/thumnails").listFiles(new FileFilter() {
                @Override
                public boolean accept(File pathname) {
                    String name = pathname.getName().toLowerCase();
                    return name.endsWith(".jpg") || name.endsWith(".png");
                }
            });
            nextPicture();
        }

        protected void nextPicture() {
            index++;
            if (index >= pictures.length) {
                index = 0;
            }
            try {
                BufferedImage img = ImageIO.read(pictures[index]);
                label.setIcon(new ImageIcon(img));
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }

    }

    public interface FadeListener {
        public void fadeDidStart(FadingPane panel);
        public void fadeDidStop(FadingPane panel);
        public void fadeOutDidComplete(FadingPane panel);
        public void fadeInDidComplete(FadingPane panel);
    }

    public class FadingPane extends JPanel {

        private float delta;
        private float alpha = 1f;
        private Timer timer;

        private FadeListener fadeListener;

        public FadingPane(FadeListener fadeListener) {
            this.fadeListener = fadeListener;
            // This is important, as we may not always be opaque
            // and we don't want to stuff up the painting process
            setOpaque(false);

            timer = new Timer(40, new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    float alpha = getAlpha() + delta;
                    if (alpha < 0.001f) {
                        alpha = 0f;
                        timer.stop();
                        fadeListener.fadeOutDidComplete(FadingPane.this);
                    } else if (alpha >= 1.0f) {
                        alpha = 1.0f;
                        timer.stop();
                        fadeListener.fadeInDidComplete(FadingPane.this);
                    }
                    setAlpha(alpha);
                }
            });
        }

        public float getAlpha() {
            return alpha;
        }

        public void setAlpha(float value) {
            if (alpha != value) {
                this.alpha = Math.min(1.0f, Math.max(0.0f, value));
                repaint();
            }
        }

        @Override
        public void paint(Graphics g) {
            // I don't normally recomamned overriding paint, but in this case,
            // I want to affect EVERYTHING that might be added to this panel
            Graphics2D g2d = (Graphics2D) g.create();
            g2d.setComposite(AlphaComposite.SrcOver.derive(getAlpha()));
            super.paint(g2d);
            g2d.dispose();
        }

        public void fadeIn() {
            timer.stop();
            fadeListener.fadeDidStop(FadingPane.this);
            delta = 0.05f;
            timer.restart();
            fadeListener.fadeDidStart(FadingPane.this);
        }

        public void fadeOut() {
            timer.stop();
            fadeListener.fadeDidStop(FadingPane.this);
            delta = -0.05f;
            timer.restart();
            fadeListener.fadeDidStart(FadingPane.this);
        }

    }

}

Repaint without painting every component again

Answers (2)

Related Questions