Develop Reference

Can I join several action events of the same type into one in a Java JFrame?

I have a java project in which I am trying to make an effect similar to the hover in CSS, changing the color(icon) every time the mouse passes over a jlabel, but I realized that I am using several methods that do the same thing.
My question is if there is a possibility to unify all of them in a single method or if there is a simpler way to do this kind of animations with a library or something like that.
private void lblPersonalizarMouseExited(java.awt.event.MouseEvent evt) {
lblPersonalizar.setIcon(icono_personalizari);
}
private void lblPersonalizarMouseEntered(java.awt.event.MouseEvent evt) {
lblPersonalizar.setIcon(icono_personalizara);
}
private void lblNuevaCompraMouseExited(java.awt.event.MouseEvent evt) {
lblNuevaCompra.setIcon(icono_comprai);
}
private void lblNuevaCompraMouseEntered(java.awt.event.MouseEvent evt) {
lblNuevaCompra.setIcon(icono_compraa);
}
private void lblUsuarioMouseEntered(java.awt.event.MouseEvent evt) {
lblUsuario.setIcon(icono_usuarioa);
}
private void lblUsuarioMouseExited(java.awt.event.MouseEvent evt) {
lblUsuario.setIcon(icono_usuarioi);
}
private void lblFacturasMouseEntered(java.awt.event.MouseEvent evt) {
lblFacturas.setIcon(icono_facturasa);
}
private void lblFacturasMouseExited(java.awt.event.MouseEvent evt) {
lblFacturas.setIcon(icono_facturasi);
}
private void lblMaterialesMouseEntered(java.awt.event.MouseEvent evt) {
lblMateriales.setIcon(icono_materialesa);
}
private void lblMaterialesMouseExited(java.awt.event.MouseEvent evt) {
lblMateriales.setIcon(icono_materialesi);
}
private void lblAyudaMouseEntered(java.awt.event.MouseEvent evt) {
lblAyuda.setIcon(icono_ayudaa);
}
private void lblAyudaMouseExited(java.awt.event.MouseEvent evt) {
lblAyuda.setIcon(icono_ayudai);
}

JButton supports image rollover, which would be a much simper solution
import java.awt.Color;
import java.awt.EventQueue;
import java.awt.GridBagLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.IOException;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.imageio.ImageIO;
import javax.swing.Icon;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
public class Main {
public static void main(String[] args) {
new Main();
}
public Main() {
EventQueue.invokeLater(new Runnable() {
#Override
public void run() {
try {
JFrame frame = new JFrame();
frame.add(new TestPane());
frame.pack();
frame.setLocationRelativeTo(null);
frame.setVisible(true);
} catch (IOException ex) {
Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
}
}
});
}
public class TestPane extends JPanel {
public TestPane() throws IOException {
setLayout(new GridBagLayout());
setBackground(Color.BLACK);
JButton bagButton = makeButton(new ImageIcon(ImageIO.read(getClass().getResource("/images/Bag.png"))), new ImageIcon(ImageIO.read(getClass().getResource("/images/Bag-Selected.png"))));
JButton editButton = makeButton(new ImageIcon(ImageIO.read(getClass().getResource("/images/Edit.png"))), new ImageIcon(ImageIO.read(getClass().getResource("/images/Edit-Selected.png"))));
JButton settingsButton = makeButton(new ImageIcon(ImageIO.read(getClass().getResource("/images/Settings.png"))), new ImageIcon(ImageIO.read(getClass().getResource("/images/Settings-Selected.png"))));
add(bagButton);
add(editButton);
add(settingsButton);
bagButton.addActionListener(new ActionListener() {
#Override
public void actionPerformed(ActionEvent e) {
System.out.println("Bag was selected");
}
});
editButton.addActionListener(new ActionListener() {
#Override
public void actionPerformed(ActionEvent e) {
System.out.println("Edit was selected");
}
});
settingsButton.addActionListener(new ActionListener() {
#Override
public void actionPerformed(ActionEvent e) {
System.out.println("Settings was selected");
}
});
}
protected JButton makeButton(Icon icon, Icon rollOverIcon) {
JButton button = new JButton();
button.setIcon(icon);
button.setRolloverIcon(rollOverIcon);
button.setRolloverEnabled(true);
button.setBorderPainted(false);
button.setFocusPainted(false);
return button;
}
}
}
Make sure you take a look at How to Use Buttons, Check Boxes, and Radio Buttons

Prevent JButton repaint() after click

I have a button. I want to change the background after I click on it. My problem here is the button auto call paintComponent(). How can prevent this? I expect after clicking the button the button will be blue, but it will still be red.
package test;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
public class ButtonDemo extends JButton implements ActionListener{
public ButtonDemo() {
this.setText("BUTTON TEXT");
this.addActionListener(this);
}
#Override
protected void paintComponent(Graphics g) {
super.paintComponent(g);
setBackground(Color.RED);
}
public static void main(String[] args){
JFrame frame = new JFrame();
JPanel contentPane = new JPanel();
frame.setContentPane(contentPane);
contentPane.add(new ButtonDemo());
frame.setSize(500, 500);
frame.setVisible(true);
}
#Override
public void actionPerformed(ActionEvent e) {
this.setBackground(Color.BLUE);
}
}

My personal gut feeling is that JButton is probably not suited to your desired goal.
Essentially, you want to control when and how the "selected" state of the piece is changed.
Personally, I would have some kind of controller which monitored the mouse events in some way (probably having the piece component delegate the event back to the controller) and some kind of model which control when pieces become selected, this would then notify the controller of the state change and it would make appropriate updates to the UI.
But that's a long process to setup. Instead, I'm demonstrating a simple concept where a component can be selected with the mouse, but only the controller can de-select. In this example, this will allow only a single piece to be selected
import java.awt.Color;
import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.GridLayout;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.border.LineBorder;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
public class Main {
public static void main(String[] args) {
new Main();
}
public Main() {
EventQueue.invokeLater(new Runnable() {
#Override
public void run() {
JFrame frame = new JFrame();
frame.add(new TestPane());
frame.pack();
frame.setLocationRelativeTo(null);
frame.setVisible(true);
}
});
}
public class TestPane extends JPanel {
public TestPane() {
setLayout(new GridLayout(5, 5));
ChangeListener listener = new ChangeListener() {
private PiecePane selectedPiece;
#Override
public void stateChanged(ChangeEvent e) {
if (!(e.getSource() instanceof PiecePane)) { return; }
PiecePane piece = (PiecePane) e.getSource();
// Want to ignore events from the selected piece, as this
// might interfer with the changing of the pieces
if (selectedPiece == piece) { return; }
if (selectedPiece != null) {
selectedPiece.setSelecetd(false);
selectedPiece = null;
}
selectedPiece = piece;
}
};
for (int index = 0; index < 5 * 5; index++) {
PiecePane pane = new PiecePane();
pane.addChangeListener(listener);
add(pane);
}
}
}
public class PiecePane extends JPanel {
private boolean selecetd;
private Color selectedBackground;
private Color normalBackground;
private MouseListener mouseListener;
public PiecePane() {
setBorder(new LineBorder(Color.DARK_GRAY));
mouseListener = new MouseAdapter() {
#Override
public void mouseClicked(MouseEvent e) {
setSelecetd(true);
}
};
setNormalBackground(Color.BLUE);
setSelectedBackground(Color.RED);
}
#Override
public Dimension getPreferredSize() {
return new Dimension(50, 50);
}
#Override
public void addNotify() {
super.addNotify();
addMouseListener(mouseListener);
}
#Override
public void removeNotify() {
super.removeNotify();
removeMouseListener(mouseListener);
}
public void addChangeListener(ChangeListener listener) {
listenerList.add(ChangeListener.class, listener);
}
public void removeChangeListener(ChangeListener listener) {
listenerList.remove(ChangeListener.class, listener);
}
protected void fireSelectionChanged() {
ChangeListener[] listeners = listenerList.getListeners(ChangeListener.class);
if (listeners.length == 0) {
return;
}
ChangeEvent evt = new ChangeEvent(this);
for (int index = listeners.length - 1; index >= 0; index--) {
listeners[index].stateChanged(evt);
}
}
public boolean isSelected() {
return selecetd;
}
public void setSelecetd(boolean selecetd) {
if (selecetd == this.selecetd) { return; }
this.selecetd = selecetd;
updateSelectedState();
fireSelectionChanged();
}
public Color getSelectedBackground() {
return selectedBackground;
}
public void setSelectedBackground(Color selectedBackground) {
this.selectedBackground = selectedBackground;
updateSelectedState();
}
public Color getNormalBackground() {
return normalBackground;
}
public void setNormalBackground(Color normalBackground) {
this.normalBackground = normalBackground;
updateSelectedState();
}
protected void updateSelectedState() {
if (isSelected()) {
setBackground(getSelectedBackground());
} else {
setBackground(getNormalBackground());
}
}
}
}

I created a toggle button.
You set the primary color and the alternate color in the class constructor.
When you call the switchColors method, the JButton background changes from the primary color to the alternate color. When you call the switchColors method again, the JButton background changes from the alternate color to the primary color.
In the following example, I put the switchColors method in the actionListener so you can see the color change. Each time you left-click on the JButton, the background color changes.
You would call the switchColors method when you want the JButton background to change from blue to red, and again when you want the JButton background to change from red to blue. It's under your control.
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;
public class ButtonDemo extends JButton
implements ActionListener {
private static final long serialVersionUID = 1L;
public static void main(String[] args) {
SwingUtilities.invokeLater(new Runnable() {
#Override
public void run() {
JFrame frame = new JFrame("Button Demo");
frame.setDefaultCloseOperation(
JFrame.EXIT_ON_CLOSE);
JPanel contentPane = new JPanel();
contentPane.setLayout(new BorderLayout());
frame.setContentPane(contentPane);
contentPane.add(new ButtonDemo(Color.BLUE,
Color.RED));
frame.setSize(300, 300);
frame.setLocationByPlatform(true);
frame.setVisible(true);
}
});
}
private boolean primaryBackground;
private Color primaryColor;
private Color alternateColor;
public ButtonDemo(Color primaryColor,
Color alternateColor) {
this.primaryColor = primaryColor;
this.alternateColor = alternateColor;
this.primaryBackground = true;
this.setText("BUTTON TEXT");
this.setBackground(primaryColor);
this.addActionListener(this);
}
public void switchColors() {
primaryBackground = !primaryBackground;
Color color = primaryBackground ? primaryColor :
alternateColor;
this.setBackground(color);
}
#Override
public void actionPerformed(ActionEvent e) {
switchColors();
}
}

If you want to change the background for a short while you can do it with swing Timer:
import java.awt.Color;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.Timer;
public class ButtonDemo extends JButton implements ActionListener{
private static final int DELAY = 600; //milliseconds
private final Timer timer;
public ButtonDemo() {
this.setText("BUTTON TEXT");
this.addActionListener(this);
Color defaultCloor = getBackground();
timer = new Timer(DELAY, e-> setBackground(defaultCloor));
timer.setRepeats(false);
}
public static void main(String[] args){
JFrame frame = new JFrame();
JPanel contentPane = new JPanel();
frame.setContentPane(contentPane);
contentPane.add(new ButtonDemo());
frame.setSize(300, 200);
frame.setVisible(true);
}
#Override
public void actionPerformed(ActionEvent e) {
timer.stop();
this.setBackground(Color.RED);
timer.start();
}
}

Editable JComboBox KeyPressed not working

I have this code where I designed an editable JComboBox to listen to my keyPressed event and show a message that the key is pressed. But I have no idea why this not working. As a beginner I might have gone wrong logically/conceptually.
So, I would request for suggestions about how to construct the code, so that it works.
Code
import javax.swing.*;
import java.awt.*;
public class testEJCBX extends JFrame {
JComboBox jcbx = new JComboBox();
public testEJCBX() {
super("Editable JComboBox");
jcbx.setEditable(true);
getContentPane().setLayout(new FlowLayout());
getContentPane().add(jcbx);
jcbx.addKeyListener(new java.awt.event.KeyAdapter() {
public void keyPressed(java.awt.event.KeyEvent evt)
{
jcbxKeyPressed(evt);
}
});
setSize(300, 170);
setVisible(true);
}
private void jcbxKeyPressed(java.awt.event.KeyEvent evt) {
JOptionPane.showMessageDialog(null, "Key Pressed");
}
public static void main(String argv[]) {
new testEJCBX();
}
}

You shouldn't be using a KeyListener for this sort of thing. Rather if you want to detect changes to the combo box's editor component, extract it and add a DocumentListener to it:
import javax.swing.*;
import javax.swing.event.DocumentEvent;
import javax.swing.event.DocumentListener;
import javax.swing.text.Document;
import java.awt.*;
public class TestEJCBX extends JFrame {
JComboBox<String> jcbx = new JComboBox<>();
public TestEJCBX() {
super("Editable JComboBox");
setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
jcbx.setEditable(true);
getContentPane().setLayout(new FlowLayout());
getContentPane().add(jcbx);
JTextField editorComponent = (JTextField) jcbx.getEditor()
.getEditorComponent();
Document doc = editorComponent.getDocument();
doc.addDocumentListener(new DocumentListener() {
#Override
public void removeUpdate(DocumentEvent e) {
System.out.println("text changed");
}
#Override
public void insertUpdate(DocumentEvent e) {
System.out.println("text changed");
}
#Override
public void changedUpdate(DocumentEvent e) {
System.out.println("text changed");
}
});
pack();
setLocationRelativeTo(null);
setVisible(true);
}
public static void main(String argv[]) {
new TestEJCBX();
}
}

How to make an Auto Clicker with Java?

So I wanted to make a program that holds down the mouse button for me.
So far I've got this: http://pastebin.com/UTJwdHY7
What I'm wondering is how I can stop it. Also, what I realise is that stopping the button makes no sense as I wouldn't be able to click it anyway. Also some tips on how I've done so far would be nice.
Edit (Adding code):
package main;
import javax.swing.*;
import javax.swing.border.LineBorder;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.InputEvent;
import java.beans.PropertyChangeListener;
public class clickForever extends JFrame implements ActionListener {
public static boolean isClicking = false;
public void actionPerformed(ActionEvent e) {}
public void createFrame() { initComponents(); }
public void initComponents() {
JFrame frame = new JFrame("AutoClicker");
JPanel panel = new JPanel(true);
JButton button = new JButton("OKAY");
JLabel label = new JLabel();
frame.setVisible(true);
frame.setSize(350, 67);
frame.setResizable(false);
frame.setDefaultCloseOperation(EXIT_ON_CLOSE);
frame.setLocationRelativeTo(null);
frame.getContentPane().add(panel, BorderLayout.CENTER);
frame.add(panel);
button.addActionListener(new Action() {
#Override
public Object getValue(String s) {
return null;
}
#Override
public void putValue(String s, Object o) {}
#Override
public void setEnabled(boolean b) {}
#Override
public boolean isEnabled() {
return false;
}
#Override
public void addPropertyChangeListener(PropertyChangeListener propertyChangeListener) {}
#Override
public void removePropertyChangeListener(PropertyChangeListener propertyChangeListener) {}
#Override
public void actionPerformed(ActionEvent actionEvent) {
if(isClicking){isClicking = false; return;}
if(!isClicking){isClicking = true; return;}
}
});
label.setFont(new Font("Times New Roman", 1, 16));
label.setText("Click 'OKAY' to start.");
label.setBorder(BorderFactory.createLineBorder(Color.black));
panel.add(label);
panel.setBorder(new LineBorder(Color.BLACK));
panel.add(button);
}
public static void main(String[] args) throws java.awt.AWTException, java.lang.InterruptedException {
clickForever clickForever = new clickForever();
Robot rbt = new Robot();
clickForever.createFrame();
while(true){
if(isClicking) rbt.mousePress(InputEvent.BUTTON1_MASK);
if(!isClicking) ;
}
}
}

Add a key listener to the frame, and when the key is pressed, stop the pressing. Note that this will not work if the frame goes out of focus, in which case you would have to listen for a global key press, which I believe would be much more difficult.

You Can Use This To End Your Program And Try Link It To The Press Of A button
Code:
public class Main {
public static void main(String[] args) {
System.out.println("Statement 1");
System.exit(0);
System.out.println("Statement 2");
}
}

Convert Java program with TextField to swing JTextField

This piece of code is a simplified version of a program I would convert to swing (using JTextField and DocumentListener). I have read some tutorials but I can't do it...
I shouldn't use global variables and I have to use some like getSource() (getDocument() in this case?), because in the original program the number of JTextField is variable (they are generated inside a for, so they haven't a "name"). This number depends on a value written in a text file.
import java.awt.*;
import java.awt.event.*;
class TestWindow extends Frame {
public TestWindow() {
Panel p = new Panel(new FlowLayout());
Label l = new Label("Temp");
TextField tf1 = new TextField();
TextField tf2 = new TextField();
tf1.addTextListener(new myTextListener(l));
tf2.addTextListener(new myTextListener(l));
p.add(tf1);
p.add(tf2);
tf1.setColumns(10);
tf2.setColumns(10);
p.add(l);
add(p);
pack();
setVisible(true);
}
class myTextListener implements TextListener {
Label input;
myTextListener(Label input) {
this.input = input;
}
public void textValueChanged(TextEvent e) {
input.setText(((TextField)(e.getSource())).getText());
}
}
}
public class Test {
public static void main(String[] args) {
new TestWindow();
}
}

This is a direct conversion of the code you posted to Swing that performs exactly the same task:
import javax.swing.*;
import javax.swing.event.DocumentEvent;
import javax.swing.event.DocumentListener;
import javax.swing.text.BadLocationException;
import java.awt.FlowLayout;
public class TestWindow extends JFrame {
public TestWindow() {
JPanel p = new JPanel(new FlowLayout());
JLabel l = new JLabel("Temp");
JTextField tf1 = new JTextField(10);
JTextField tf2 = new JTextField(10);
tf1.getDocument().addDocumentListener(new MyDocumentListener(l));
tf2.getDocument().addDocumentListener(new MyDocumentListener(l));
p.add(tf1);
p.add(tf2);
p.add(l);
add(p);
pack();
setVisible(true);
}
class MyDocumentListener implements DocumentListener{
private JLabel label;
MyDocumentListener(JLabel label) {
this.label = label;
}
#Override
public void insertUpdate(DocumentEvent e) {
handleTextChange(e);
}
#Override
public void removeUpdate(DocumentEvent e) {
handleTextChange(e);
}
#Override
public void changedUpdate(DocumentEvent e) {
handleTextChange(e);
}
private void handleTextChange(DocumentEvent e) {
try {
label.setText(e.getDocument().getText(0,e.getDocument().getLength()));
} catch (BadLocationException ignored) {
//todo: handle exception properly although this should never happen
}
}
}
public static void main(String[] args) {
new TestWindow();
}
}
Please note that DocumentListener provides more control for handling text change events than the TextListener, but I chose to handle them with one single method in order to exactly match your example's functionality