modello di componente java Swing personalizzato, UIDelegate, formato componente
Mi è stato dato il compito di creare un componente swing personalizzato. Ho il mio componente che funziona correttamente in un'applicazione di test che include JSlider che viene utilizzato per ingrandire e rimpicciolire un'immagine. Tuttavia mi viene richiesto di presentare il mio componente personalizzato in un formato di classe Model, UIDelegate e Component e sono totalmente perso su come convertire il mio codice in modo che segua questo formato. Ecco il codice per la mia applicazione di test.
package test;
import java.awt.*;
import java.awt.geom.AffineTransform;
import java.awt.image.BufferedImage;
import javax.swing.*;
import javax.swing.border.EmptyBorder;
import javax.swing.event.*;
import java.io.File;
import java.net.URL;
import javax.imageio.ImageIO;
public class ZoomDemo extends JComponent implements ChangeListener {
JPanel gui;
/**
* Displays the image.
*/
JLabel imageCanvas;
Dimension size;
double scale = 1.0;
private BufferedImage image;
public ZoomDemo() {
size = new Dimension(10, 10);
setBackground(Color.black);
try {
image = ImageIO.read(new File("car.jpg"));
} catch (Exception ex) {
ex.printStackTrace();
}
}
public void setImage(Image image) {
imageCanvas.setIcon(new ImageIcon(image));
}
public void initComponents() {
if (gui == null) {
gui = new JPanel(new BorderLayout());
gui.setBorder(new EmptyBorder(5, 5, 5, 5));
imageCanvas = new JLabel();
JPanel imageCenter = new JPanel(new GridBagLayout());
imageCenter.add(imageCanvas);
JScrollPane imageScroll = new JScrollPane(imageCenter);
imageScroll.setPreferredSize(new Dimension(300, 100));
gui.add(imageScroll, BorderLayout.CENTER);
}
}
public Container getGui() {
initComponents();
return gui;
}
public void stateChanged(ChangeEvent e) {
int value = ((JSlider) e.getSource()).getValue();
scale = value / 100.0;
paintImage();
}
protected void paintImage() {
int imageWidth = image.getWidth();
int imageHeight = image.getHeight();
BufferedImage bi = new BufferedImage(
(int)(imageWidth*scale),
(int)(imageHeight*scale),
image.getType());
Graphics2D g2 = bi.createGraphics();
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON);
AffineTransform at = AffineTransform.getTranslateInstance(0, 0);
at.scale(scale, scale);
g2.drawRenderedImage(image, at);
setImage(bi);
}
public Dimension getPreferredSize() {
int w = (int) (scale * size.width);
int h = (int) (scale * size.height);
return new Dimension(w, h);
}
private JSlider getControl() {
JSlider slider = new JSlider(JSlider.HORIZONTAL, 1, 500, 50);
slider.setMajorTickSpacing(50);
slider.setMinorTickSpacing(25);
slider.setPaintTicks(true);
slider.setPaintLabels(true);
slider.addChangeListener(this);
return slider;
}
public static void main(String[] args) {
ZoomDemo app = new ZoomDemo();
JFrame frame = new JFrame();
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setContentPane(app.getGui());
app.setImage(app.image);
// frame.getContentPane().add(new JScrollPane(app));
frame.getContentPane().add(app.getControl(), "Last");
frame.setSize(700, 500);
frame.setLocation(200, 200);
frame.setVisible(true);
}
}
Il seguente codice è il formato di classe di cui ho bisogno seguire
Classe di componenti
package component;
import javax.swing.JComponent;
import javax.swing.JSlider;
import javax.swing.plaf.ComponentUI;
public class ProgressBar extends JComponent {
public static ComponentUI createUI(JComponent c) {
return new ZoomUI();
}
public void installUI(JComponent c){
}
public void uninstallUI (JComponent c){
}
}
Classe modello
public class ZoomModel extends JSLider {
}
Classe UIDelegate
public class ZoomUI extends ComponentUI implements ChangeListener{
}
Qualsiasi aiuto su come implementare il mio componente personalizzato in questo formato sarebbe molto apprezzato. Sono molto nuovo a Swing e la documentazione che ho trovato su componenti personalizzati è stata molto confusa e di scarso aiuto.
Applicazione di prova
package test;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.geom.AffineTransform;
import java.awt.image.BufferedImage;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import javax.swing.*;
import javax.swing.border.EmptyBorder;
import javax.swing.border.LineBorder;
import javax.swing.event.*;
import java.io.File;
import java.net.URL;
import javax.imageio.ImageIO;
import component.ZoomComponent;
public class ZoomDemo extends JPanel implements PropertyChangeListener, ActionListener {
ZoomComponent zoomer;
JPanel board;
private BufferedImage image;
public ZoomDemo( ) {
super(true);
setLayout(new BorderLayout( ));
board = new JPanel(true);
board.setPreferredSize(new Dimension(300, 300));
board.setBorder(new LineBorder(Color.black, 5));
zoomer = new ZoomComponent();
add(board, BorderLayout.NORTH);
add(zoomer, BorderLayout.SOUTH);
}
@Override
public void actionPerformed(ActionEvent arg0) {
// TODO Auto-generated method stub
}
@Override
public void propertyChange(PropertyChangeEvent arg0) {
// TODO Auto-generated method stub
}
public static void main(String[] args) {
UIManager.getDefaults().put("ZoomComponentUI", "component.BasicZoomUI");
ZoomDemo s= new ZoomDemo();
JFrame frame = new JFrame("Sample Sketch Application");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setContentPane(s);
frame.pack( );
frame.setVisible(true);
}
}
1 answers
Va bene, quindi è stata una divertente avventura in parti dell'API che non uso :), inizia con una lettura Come scrivere un componente Swing personalizzato ed è collegato link, questo ti darà il lavoro di base per capire cosa sta per accadere...
Modello
L'interfaccia
Personalmente, comincio sempre con un'interfaccia, la vita è migliore con le interfacce e ti dà più flessibilità. Ora, da quale modello dovresti estendere (in base al tuo requisito)...?
Bene, la scelta migliore che ho trovato è stata la BoundedRangeModel, che viene utilizzata anche dalla JSlider...questo in realtà significa che non solo posso passare questo modello alla vista, ma a un JSlider e senza alcun lavoro aggiuntivo, il cursore cambia l'immagine!! Win-Win
import java.awt.Dimension;
import java.awt.Image;
import javax.swing.BoundedRangeModel;
public interface ZoomModel extends BoundedRangeModel {
public Image getImage();
public Dimension getScaledSize();
}
L'Abstract
Successivamente, mi piace creare una versione astratta, è qui che inserisco la funzionalità" comune", che probabilmente sarà la stessa per la maggior parte delle implementazioni, in questo caso potrebbe non esserlo richiesto, ma io sono finckle come questo...
import java.awt.Dimension;
import java.awt.Image;
import javax.swing.DefaultBoundedRangeModel;
public abstract class AbstractZoomModel extends DefaultBoundedRangeModel implements ZoomModel {
public AbstractZoomModel() {
super(100, 0, 0, 200);
}
@Override
public Dimension getScaledSize() {
Dimension size = new Dimension(0, 0);
Image image = getImage();
if (image != null) {
double scale = getValue() / 100d;
size.width = (int) Math.round(image.getWidth(null) * scale);
size.height = (int) Math.round(image.getHeight(null) * scale);
}
return size;
}
}
Quindi, puoi vedere qui, ho definito alcune proprietà di base, un livello di zoom iniziale di 100, un livello massimo di 200 e un livello minimo di 0, in più ho implementato getScaledSize, che viene usato un po ' e rende la vita più facile...
Il valore predefinito...
Ora, perché ci piace stato bello, forniamo un'implementazione "predefinita" del modello. Questo è piuttosto semplice in quanto tutto ciò che fa richiede un riferimento a un immagine...
import java.awt.Image;
public class DefaultZoomModel extends AbstractZoomModel {
Image image;
public DefaultZoomModel(Image image) {
this.image = image;
}
@Override
public Image getImage() {
return image;
}
}
È possibile creare implementazioni che scaricano immagini da un URL, ad esempio...
La vista
Ok, questo è il componente in realtà stesso, che viene aggiunto alla tua interfaccia utente. Contiene le funzionalità di base necessarie per costruire e preparare il delegato dell'interfaccia utente e gestire il modello. La cosa fondamentale di interesse qui è l'uso del supporto di modifica della proprietà per fornire la notifica della modifica al modello, questo è importante come lo farai vedere...
import java.awt.Color;
import java.awt.Dimension;
import javax.swing.JComponent;
import javax.swing.UIManager;
public class ZoomComponent extends JComponent {
private static final String uiClassID = "ZoomComponentUI";
private ZoomModel model;
public ZoomComponent() {
setBackground(Color.black);
setFocusable(true);
updateUI();
}
public void setModel(ZoomModel newModel) {
if (model != newModel) {
ZoomModel old = model;
this.model = newModel;
firePropertyChange("model", old, newModel);
}
}
public ZoomModel getModel() {
return model;
}
@Override
public Dimension getPreferredSize() {
ZoomModel model = getModel();
Dimension size = new Dimension(100, 100);
if (model != null) {
size = model.getScaledSize();
}
return size;
}
public void setUI(BasicZoomUI ui) {
super.setUI(ui);
}
@Override
public void updateUI() {
if (UIManager.get(getUIClassID()) != null) {
ZoomUI ui = (ZoomUI) UIManager.getUI(this);
setUI(ui);
} else {
setUI(new BasicZoomUI());
}
}
public BasicZoomUI getUI() {
return (BasicZoomUI) ui;
}
@Override
public String getUIClassID() {
return uiClassID;
}
}
Il Delegato dell'interfaccia utente
Ora le altre cose divertenti...Se seguiamo la convenzione standard, normalmente fornisci un concetto abstract del delegato dell'interfaccia utente, ad esempio...
import javax.swing.plaf.ComponentUI;
public abstract class ZoomUI extends ComponentUI {
}
Da questo, altri delegati cresceranno...
Delegato dell'interfaccia utente di base
La convenzione suggerirebbe normalmente di fornire un'implementazione "di base", facendo un sacco di lavori pesanti, ma consentendo ad altre implementazioni l'opportunità di saltare nel cambiare le cose lì probabile
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.event.ActionEvent;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.MouseWheelEvent;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import javax.swing.AbstractAction;
import javax.swing.Action;
import javax.swing.ActionMap;
import javax.swing.InputMap;
import javax.swing.JComponent;
import javax.swing.KeyStroke;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import javax.swing.plaf.ComponentUI;
public class BasicZoomUI extends ZoomUI {
private ZoomComponent zoomComponent;
private MouseAdapter mouseHandler;
private ChangeListener changeHandler;
private Action zoomIn;
private Action zoomOut;
private PropertyChangeListener propertyChangeHandler;
protected ChangeListener getChangeHandler() {
if (changeHandler == null) {
changeHandler = new ChangeHandler();
}
return changeHandler;
}
protected void installMouseListener() {
mouseHandler = new MouseAdapter() {
@Override
public void mouseClicked(MouseEvent e) {
zoomComponent.requestFocusInWindow();
}
@Override
public void mouseWheelMoved(MouseWheelEvent e) {
int amount = e.getWheelRotation();
ZoomModel model = zoomComponent.getModel();
if (model != null) {
int value = model.getValue();
model.setValue(value + amount);
}
}
};
zoomComponent.addMouseListener(mouseHandler);
zoomComponent.addMouseWheelListener(mouseHandler);
}
protected void installModelPropertyChangeListener() {
propertyChangeHandler = new PropertyChangeListener() {
@Override
public void propertyChange(PropertyChangeEvent evt) {
ZoomModel old = (ZoomModel) evt.getOldValue();
if (old != null) {
old.removeChangeListener(getChangeHandler());
}
ZoomModel newValue = (ZoomModel) evt.getNewValue();
if (newValue != null) {
newValue.addChangeListener(getChangeHandler());
}
}
};
zoomComponent.addPropertyChangeListener("model", propertyChangeHandler);
}
protected void installKeyBindings() {
zoomIn = new ZoomInAction();
zoomOut = new ZoomOutAction();
InputMap inputMap = zoomComponent.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW);
inputMap.put(KeyStroke.getKeyStroke(KeyEvent.VK_ADD, 0), "zoomIn");
inputMap.put(KeyStroke.getKeyStroke(KeyEvent.VK_SUBTRACT, 0), "zoomOut");
inputMap.put(KeyStroke.getKeyStroke(KeyEvent.VK_PLUS, 0), "zoomIn");
inputMap.put(KeyStroke.getKeyStroke(KeyEvent.VK_MINUS, 0), "zoomOut");
ActionMap actionMap = zoomComponent.getActionMap();
actionMap.put("zoomIn", zoomIn);
actionMap.put("zoomOut", zoomOut);
}
protected void installModelChangeListener() {
ZoomModel model = getModel();
if (model != null) {
model.addChangeListener(getChangeHandler());
}
}
@Override
public void installUI(JComponent c) {
zoomComponent = (ZoomComponent) c;
installMouseListener();
installModelPropertyChangeListener();
installKeyBindings();
installModelChangeListener();
}
protected void uninstallModelChangeListener() {
getModel().removeChangeListener(getChangeHandler());
}
protected void uninstallKeyBindings() {
InputMap inputMap = zoomComponent.getInputMap(JComponent.WHEN_FOCUSED);
inputMap.put(KeyStroke.getKeyStroke(KeyEvent.VK_ADD, 0), "donothing");
inputMap.put(KeyStroke.getKeyStroke(KeyEvent.VK_SUBTRACT, 0), "donothing");
inputMap.put(KeyStroke.getKeyStroke(KeyEvent.VK_PLUS, 0), "donothing");
inputMap.put(KeyStroke.getKeyStroke(KeyEvent.VK_MINUS, 0), "donothing");
AbstractAction blank = new AbstractAction() {
@Override
public void actionPerformed(ActionEvent e) {
}
};
ActionMap actionMap = zoomComponent.getActionMap();
actionMap.put("zoomIn", blank);
actionMap.put("zoomOut", blank);
}
protected void uninstallModelPropertyChangeListener() {
zoomComponent.removePropertyChangeListener(propertyChangeHandler);
propertyChangeHandler = null;
}
protected void uninstallMouseListener() {
zoomComponent.removeMouseWheelListener(mouseHandler);
mouseHandler = null;
}
@Override
public void uninstallUI(JComponent c) {
uninstallModelChangeListener();
uninstallModelPropertyChangeListener();
uninstallKeyBindings();
uninstallMouseListener();
mouseHandler = null;
zoomComponent = null;
}
@Override
public void paint(Graphics g, JComponent c) {
super.paint(g, c);
paintImage(g);
}
protected void paintImage(Graphics g) {
if (zoomComponent != null) {
ZoomModel model = zoomComponent.getModel();
Image image = model.getImage();
Dimension size = model.getScaledSize();
int x = (zoomComponent.getWidth() - size.width) / 2;
int y = (zoomComponent.getHeight() - size.height) / 2;
g.drawImage(image, x, y, size.width, size.height, zoomComponent);
}
}
public static ComponentUI createUI(JComponent c) {
return new BasicZoomUI();
}
protected ZoomModel getModel() {
return zoomComponent == null ? null : zoomComponent.getModel();
}
protected class ChangeHandler implements ChangeListener {
@Override
public void stateChanged(ChangeEvent e) {
zoomComponent.revalidate();
zoomComponent.repaint();
}
}
protected class ZoomAction extends AbstractAction {
private int delta;
public ZoomAction(int delta) {
this.delta = delta;
}
@Override
public void actionPerformed(ActionEvent e) {
ZoomModel model = getModel();
if (model != null) {
model.setValue(model.getValue() + delta);
}
}
}
protected class ZoomOutAction extends ZoomAction {
public ZoomOutAction() {
super(-5);
}
}
protected class ZoomInAction extends ZoomAction {
public ZoomInAction() {
super(5);
}
}
}
Da qui potresti andare a ideare implementazioni specifiche della piattaforma, ma ho deciso di attenermi al delegato di base...
Mettere tutto insieme
Se ciò non bastasse, prima di poterlo utilizzare, è necessario installare il delegato...
UIManager.getDefaults().put("ZoomComponentUI", "your.awesome.package.name.BasicZoomUI");
Nb: cambia your.awesome.package.name per riflettere il nome effettivo del pacchetto...
Esempio eseguibile
import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JSlider;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;
public class TestZoom100 {
public static void main(String[] args) {
new TestZoom100();
}
public TestZoom100() {
EventQueue.invokeLater(new Runnable() {
@Override
public void run() {
try {
UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
} catch (ClassNotFoundException | InstantiationException | IllegalAccessException | UnsupportedLookAndFeelException ex) {
ex.printStackTrace();
}
UIManager.getDefaults().put("ZoomComponentUI", "your.awesome.package.name.BasicZoomUI");
try {
DefaultZoomModel model = new DefaultZoomModel(ImageIO.read(new File("/your/awesome/image.jpg")));
model.setValue(50);
ZoomComponent zoomComp = new ZoomComponent();
zoomComp.setModel(model);
JSlider slider = new JSlider(model);
JFrame frame = new JFrame("Testing");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.add(new JScrollPane(zoomComp));
frame.add(slider, BorderLayout.SOUTH);
frame.pack();
frame.setLocationRelativeTo(null);
frame.setVisible(true);
} catch (IOException exp) {
exp.printStackTrace();
}
}
});
}
}
Non dimenticare di cambiare il nome del pacchetto per BasicZoomUI nel nome del pacchetto che hai memorizzato in e effettivamente specificare un file immagine;)