Using JLayer in Swing Applications in NetBeans 7

Create a New Project. Select File > New Project.

Select Java from the Categories column and Java Application from the Projects column and then click Next.

Perform the following steps.

a. Name the project JLayerDemo.

b. Uncheck the Create Main Class check box.

c. Click Finish.

Right-click JLayerDemo Project and select New > Java Class .

Name the class WallPaperDemo, package name demo, and then click Finish.

Add the following import statements to the java class, WallPaperDemo.java

import java.awt.*;
import javax.swing.*;
import javax.swing.plaf.LayerUI;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

To create the UI, add the method createUI()to the class.

private static JPanel createUI()
{
JPanel panel1 = new JPanel ();
JLabel lblName = new JLabel ("Name:");
panel1.add (lblName);
final JTextField txtName = new JTextField (20);
panel1.add (txtName);
JButton btnReverse = new JButton ("Reverse");
panel1.add (btnReverse);
return panel1;
}

This method creates a UI with the follwing components -Jlabel, JTextField, and a JButton.

These components are added to a JPanel and the panel is returned.

Next add the method createLayer() to the class.

public static void createLayer()
{
JFrame f = new JFrame("Wallpaper");
JPanel panel = createUI();
f.add(createUI());
f.pack ();
f.setSize(300, 200);
f.setDefaultCloseOperation (JFrame.EXIT_ON_CLOSE);
f.setLocationRelativeTo (null);
f.setVisible (true);

}

This method adds the panel returned by the createUI() method to a JFrame. The method also sets the various properties of JFrame.

In the createUI() method, add event handling code to the Reverse button.

ActionListener al;
al = new ActionListener ()
{
public void actionPerformed (ActionEvent ae)
{
String txt = txtName.getText ();
txt = new StringBuffer (txt).reverse().toString();
txtName.setText (txt);
}
};
btnReverse.addActionListener (al);

The Reverse button responds to the click event and retrieves the text entered in the JTextField, txtName, reverses the String, and then displays it in the textfield.

Next add the main() method to the class. In the main method, createLayer()is invoked.

public static void main(String[] args)
{
javax.swing.SwingUtilities.invokeLater(new Runnable()
{ public void run() {
createLayer();
} });
}

In the Projects pane, right-click WallPaperDemo.java and choose Run File.

You can test the application by entering a String in the Name field and then clicking Reverse.

Output with the reversed String will be as in the below screenshot. 

To create a WallPaper using JLayer, add the following class to WallPaperDemo.java. Be sure to add the class after the last closing brace.

class WallpaperLayerUI extends LayerUI<JComponent>
{
@Override
public void paint(Graphics g, JComponent c)
{ super.paint(g, c);
Graphics2D g2 = (Graphics2D) g.create();
int w = c.getWidth();
int h = c.getHeight();
g2.setComposite(AlphaComposite.getInstance( AlphaComposite.SRC_OVER, .5f));
g2.setPaint(new GradientPaint(0, 0, Color.yellow, 0, h, Color.red));
g2.fillRect(0, 0, w, h);
g2.dispose();

}

}

JLayer delegates the handling of painting and input events to a LayerUI object, which performs the decoration.
Extend LayerUI and you can override various methods to enable custom painting and event handling.
In this case, you are overriding the paint() method and passing an instance of this class,
along with the component to be decorated, to the JLayer constructor: public JLayer(V view, LayerUI<V> ui)

To add the Wallpaper to the UI using JLayer, modify the createLayer() method as below.

a. Add the following lines of code to the method as indicated in the screenshot below.

LayerUI layerUI = new WallpaperLayerUI();
JLayer jlayer = new JLayer(panel, layerUI);
f.add(jlayer);

The first argument to the Layer constructor can be any class extending the java.awt.Component and is the Swing component you want to decorate.
This component can be a JPanel or another container.
The container and all contained components will be decorated. The second argument identifies the decorator.

b. Delete the line of code shown below:

f.add(createUI());

In the Projects pane, right-click WallPaperDemo.java and choose Run File.

You can test the application by entering a String in the Name field and then clicking Reverse.

Output with the reversed String and WallPaper applied to the UI will be as in the below screenshot. 

Right-click JLayerDemo Project and select New > Java Class .

Name the class FieldValidatorDemo, package name demo and then click Finish.

Add the following import statements to the java class, FieldValidator.java .

import java.awt.*;
import java.text.*;
import javax.swing.*;
import javax.swing.plaf.LayerUI;

To create the UI, add the createContent()method to the class.

This method performs the following operations.

• Creates a JLayer UI.
• Creates a JLabel, Number and a JFormattedTextField with a initial value of 25.
• Creates a JPanel. The Layout manager for the panel is set to be GridLayoutManager with 2 rows and 1 column. JLabel and the JFormattedTextField are added to the JPanel.
• Creates a JLabel and a JFormattedTextField. The initial value of the date field is set for the current date.
• Adds the JLabel and JFormattedTextField to the JPanel.

Next add the method createUI() to the class.

public static void createUI() {

JFrame f = new JFrame ("FieldValidator");
JComponent content = createContent();
f.add (content); f.pack();
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.setLocationRelativeTo (null);
f.setVisible (true);
}

The createUI() method performs the following:

• Creates a JFrame instance and sets the title to "FieldValidator".
• The JPanel instance created in method createContent() is added to the JFrame.
• Other properties of the JFrame are set in this method.

Next add the main() method to the class. In the main() method, createUI()is invoked.

public static void main(String[] args)
{
javax.swing.SwingUtilities.invokeLater(new Runnable()
{ public void run() {
createUI();
} });
}

To implement FieldValidation using JLayer, add the ValidationLayerUI class to FieldValidator.java.

class ValidationLayerUI extends LayerUI<JFormattedTextField> {
@Override
public void paint (Graphics g, JComponent c) {
super.paint (g, c);

JLayer jlayer = (JLayer)c;
JFormattedTextField ftf = (JFormattedTextField)jlayer.getView();
if (!ftf.isEditValid()) {
Graphics2D g2 = (Graphics2D)g.create();

// Paint the red X.
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON);
int w = c.getWidth();
int h = c.getHeight();
int s = 8;
int pad = 4;
int x = w - pad - s;
int y = (h - s) / 2;
g2.setPaint(Color.red);
g2.fillRect(x, y, s + 1, s + 1);
g2.setPaint(Color.white);
g2.drawLine(x, y, x + s, y + s);
g2.drawLine(x, y + s, x + s, y);
g2.dispose();
}
}
}

The class ValidationLayerUI is a LayerUI subclass and the paint() method is overridden to implement the FieldValidation.

In the Projects pane, right-click FieldValidator.java and choose Run File.

The output will be as below

You can test the application for the following input conditions.

a. Delete the initial value displayed in the Number Field. Output after FieldValidation will be as below.

b. Delete the initial date value displayed in the Date field. Output after FieldValidation will be as below.