Heim > Java > javaLernprogramm > Wie kann ich mit Swing ein Raster mit Bildminiaturansichten in einem scrollbaren Bedienfeld anzeigen?

Wie kann ich mit Swing ein Raster mit Bildminiaturansichten in einem scrollbaren Bedienfeld anzeigen?

DDD
Freigeben: 2024-12-22 17:43:14
Original
1003 Leute haben es durchsucht

How can I display a grid of image thumbnails in a scrollable panel using Swing?

Bildminiaturansichten zu einem Layout in einem Raster hinzufügen

Problem:

Sie müssen Fügen Sie eine Sammlung von Bildern als kleine Miniaturansichten zu einem Rahmen in einem SpringLayout hinzu und zeigen Sie sie rasterförmig in einem Bildlaufbereich an. Die Liste der Fotos könnte umfangreich sein und ein Scroll-Fenster erfordern.

Lösung:

Um dies mit Swing zu erreichen, befolgen Sie diese Schritte:

  1. Erstellen Sie ein JPanel für die Fotos und ein JScrollPane für das JPanel.
  2. Verwenden Sie einen Layout-Manager wie FlowLayout, um die Miniaturansichten umlaufend anzuordnen, um das Anzeigen und Scrollen zu erleichtern.
  3. Fügen Sie jede Miniaturansicht als JPanel hinzu, wobei das Bild entsprechend skaliert ist.
  4. Fügen Sie das JScrollPane zum Rahmen hinzu und passen Sie es an Größe und Position mithilfe der SpringLayout-Einschränkungen.

Unten finden Sie ein Codebeispiel, das dies veranschaulicht Lösung:

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

import java.awt.BorderLayout;

import java.awt.Color;

import java.awt.Container;

import java.awt.Dimension;

import java.awt.EventQueue;

import java.awt.FlowLayout;

import java.awt.Graphics;

import java.awt.Graphics2D;

import java.awt.Image;

import java.awt.Insets;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.geom.AffineTransform;

import java.awt.image.BufferedImage;

import java.io.File;

import java.io.FileFilter;

import java.io.IOException;

import javax.imageio.ImageIO;

import javax.swing.JButton;

import javax.swing.JFrame;

import javax.swing.JPanel;

import javax.swing.JScrollPane;

import javax.swing.SwingUtilities;

import javax.swing.UIManager;

import javax.swing.UnsupportedLookAndFeelException;

 

public class ImageGrid {

 

    public static void main(String[] args) {

        new ImageGrid();

    }

 

    public ImageGrid() {

        EventQueue.invokeLater(new Runnable() {

            @Override

            public void run() {

                try {

                    UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());

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

                }

 

                JFrame frame = new JFrame("Image Grid");

                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

                frame.setLayout(new BorderLayout());

 

                // Create a JPanel for the photos and add it to a JScrollPane

                JPanel photoPanel = new JPanel(new WrapLayout());

                JScrollPane photoScroll = new JScrollPane(photoPanel);

 

                // Add the JScrollPane to the frame

                frame.add(photoScroll, BorderLayout.CENTER);

 

                // Create a button to scan and add the thumbnails

                JButton scanButton = new JButton("Scan");

                scanButton.addActionListener(new ActionListener() {

                    @Override

                    public void actionPerformed(ActionEvent e) {

                        // Scan for image files

                        String path = "Enter path to your image directory";

                        File[] files = new File(path).listFiles(new FileFilter() {

                            @Override

                            public boolean accept(File pathname) {

                                String name = pathname.getName().toLowerCase();

                                return pathname.isFile() && (name.endsWith(".png")

                                        || name.endsWith(".jpg")

                                        || name.endsWith(".gif"));

                            }

                        });

 

                        photoPanel.removeAll();

                        for (File file : files) {

                            try {

                                // Load and scale the image

                                ImagePane pane = new ImagePane(file);

                                photoPanel.add(pane);

                            } catch (Exception exp) {

                                exp.printStackTrace();

                            }

                        }

                        photoPanel.revalidate();

                        photoPanel.repaint();

                    }

                });

 

                // Add the scan button to the frame

                frame.add(scanButton, BorderLayout.SOUTH);

 

                frame.pack();

                frame.setLocationRelativeTo(null);

                frame.setResizable(true);

                frame.setVisible(true);

            }

        });

    }

 

    public class ImagePane extends JPanel {

 

        private Image img;

 

        public ImagePane(File source) throws IOException {

            img = ImageIO.read(source);

            if (img.getWidth(this) > 200 || img.getHeight(this) > 200) {

                int width = img.getWidth(this);

                int height = img.getWidth(this);

                float scaleWidth = 200f / width;

                float scaleHeight = 200f / height;

                if (scaleWidth > scaleHeight) {

                    width = -1;

                    height = (int)(height * scaleHeight);

                } else {

                    width = (int)(width * scaleWidth);

                    height = -1;

                }

                img = img.getScaledInstance(width, height, Image.SCALE_SMOOTH);

            }

        }

 

        @Override

        public Dimension getPreferredSize() {

            return new Dimension(200, 200);

        }

 

        @Override

        protected void paintComponent(Graphics g) {

            super.paintComponent(g);

            Graphics2D g2d = (Graphics2D) g.create();

            if (img != null) {

                // Draw the scaled image

                int x = (getWidth() - img.getWidth(this)) / 2;

                int y = (getHeight() - img.getHeight(this)) / 2;

                g2d.drawImage(img, x, y, this);

            }

            g2d.dispose();

        }

    }

 

    /**

     * FlowLayout subclass that fully supports wrapping of components.

     */

    public class WrapLayout extends FlowLayout {

 

        private Dimension preferredLayoutSize;

 

        /**

         * Constructs a new

         * <code>WrapLayout</code> with a left alignment and a default 5-unit

         * horizontal and vertical gap.

         */

        public WrapLayout() {

            super();

        }

 

        /**

         * Constructs a new

         * <code>FlowLayout</code> with the specified alignment and a default 5-unit

         * horizontal and vertical gap. The value of the alignment argument must be

         * one of

         * <code>WrapLayout</code>,

         * <code>WrapLayout</code>, or

         * <code>WrapLayout</code>.

         *

         * @param align the alignment value

         */

        public WrapLayout(int align) {

            super(align);

        }

 

        /**

         * Creates a new flow layout manager with the indicated alignment and the

         * indicated horizontal and vertical gaps.

         * <p>

         * The value of the alignment argument must be one of

         * <code>WrapLayout</code>,

         * <code>WrapLayout</code>, or

         * <code>WrapLayout</code>.

         *

         * @param align the alignment value

         * @param hgap the horizontal gap between components

         * @param vgap the vertical gap between components

         */

        public WrapLayout(int align, int hgap, int vgap) {

            super(align, hgap, vgap);

        }

 

        /**

         * Returns the preferred dimensions for this layout given the

         * <i>visible</i> components in the specified target container.

         *

         * @param target the component which needs to be laid out

         * @return the preferred dimensions to lay out the subcomponents of the

         * specified container

         */

        @Override

        public Dimension preferredLayoutSize(Container target) {

            return layoutSize(target, true);

        }

 

        /**

         * Returns the minimum dimensions needed to layout the <i>visible</i>

         * components contained in the specified target container.

         *

         * @param target the component which needs to be laid out

         * @return the minimum dimensions to lay out the subcomponents of the

         * specified container

         */

        @Override

        public Dimension minimumLayoutSize(Container target) {

            Dimension minimum = layoutSize(target, false);

            minimum.width -= (getHgap() + 1);

            return minimum;

        }

 

        /**

         * Returns the minimum or preferred dimension needed to layout the target

         * container.

         *

         * @param target target to get layout size for

         * @param preferred should preferred size be calculated

         * @return the dimension to layout the target container

         */

        private Dimension layoutSize(Container target, boolean preferred) {

            synchronized (target.getTreeLock()) {

                //  Each row must fit with the width allocated to the container.

                //  When the container width = 0, the preferred width of the container

Nach dem Login kopieren

Das obige ist der detaillierte Inhalt vonWie kann ich mit Swing ein Raster mit Bildminiaturansichten in einem scrollbaren Bedienfeld anzeigen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!

Erklärung dieser Website
Der Inhalt dieses Artikels wird freiwillig von Internetnutzern beigesteuert und das Urheberrecht liegt beim ursprünglichen Autor. Diese Website übernimmt keine entsprechende rechtliche Verantwortung. Wenn Sie Inhalte finden, bei denen der Verdacht eines Plagiats oder einer Rechtsverletzung besteht, wenden Sie sich bitte an admin@php.cn
Beliebte Tutorials
Mehr>
Neueste Downloads
Mehr>
Web-Effekte
Quellcode der Website
Website-Materialien
Frontend-Vorlage