First Bean Compose SimpleBean Demo Simple Bean Discuss Manifest and Jar Add Properties to SimpleBean

import java.awt.*; import java.io.Serializable; public class SimpleBean extends Canvas implements Serializable{ //Constructor sets inherited properties public SimpleBean(){ setSize(60,40); setBackground(Color.red); }

All beans must implement Serializable Interface Sets background color and size Compile the Bean Create manifest file Create Jar file Load Jar in BeanBox Drop SimpleBean instance in BeanBox

Manifest File Describes entries in jar archive Made up of attribute/value pairs Format is “attribute: value” Name: SimpleBean.class Java-Bean: True

JAR Java archive file format Bundle any number of files ZIP compression Manifest describes content jar part of the jdk jar {ctx} [vfm0M] [jar-file] [manifest-file] files … jar cfm SimpleBean.jar manifest.tmp SimpleBean.class

Jar Command Options

Additional Jar Capabilities Security with Digital Signatures Decreased Applet Download Time Packaging of extensions Portability Package Sealing and Versioning Jar tutorial

Properties Properties are attributes of bean’s appearance and behavior that can be changed at design time. Private values accessed through getter and setter methods Encapsulation, Design Pattern Can be inherited (Canvas for SimpleBean)

Builder Tools and Properties Discover Bean’s Properties Determine properties’ read/write attributes Determine property types Locate property editors Display property sheet Alter properties

package sunw.demo.simple; import java.awt.*; import java.io.Serializable; public class SimpleBean extends Canvas implements Serializable{ private Color color = Color.green; //property getter method public Color getColor(){ return color; } //property setter method. Sets new SimpleBean //color and repaints. public void setColor(Color newColor){ color = newColor; repaint(); } public void paint(Graphics g) { g.setColor(color); g.fillRect(20, 5, 20, 30); } //Constructor sets inherited properties public SimpleBean(){ setSize(60,40); setBackground(Color.red); }

Events in the BeanBox Uses either design pattern introspection or BeanInfo class to discover events For a bean to be a source for an event, it must implement methods that add or remove listeners for that event For example, if a source Bean registers ActionListener objects, it will fire events at those objects by calling the actionPerformed method on those listeners. public void add ( a) public void remove ( a)

Bound Properties When property changes, other objects may need to be notified and react. When bound property changes, notification is sent to interested listeners. Bean with bound property must maintain list of property listeners and fire PropertyChangeEvent objects PropertyChangeSupport

A Bean with bound property maintains list of property change listeners Alerts those listeners when bound property changes. Convenience class PropertyChangeSupport implements methods that add and remove PropertyChangeListener objects, and fires PropertyChangeEvent objects at those listeners when the bound property changes. Beans can inherit from this class, or use it as an inner class. By implementing the PropertyChangeListener interface the listener can be added to the list maintained by the bound property Bean, and because it implements the PropertyChangeListener.propertyChange method, the listener can respond to property change notifications. The PropertyChangeEvent class encapsulates property change information, and is sent from the property change event source to each object in the property change listener list via the propertyChange method.

Inherit or use inner class Objects interested in event implement PropertyChangeListener interface Beanbox handles events with event hookup adapter Tutorial

Import java.beans package Instantiate a PropertyChangeSupport object Implement methods to maintain list of property change event listeners Modify a property's setter method to fire a property change event when the property is changed Listeners implement PropertyChangeListener interface with propertyChange (PropertyChangeEvent) method

1.Drop OurButton and ChangeReporter instances on the BeanBox. 2.Select the OurButton instance and choose the Edit|Events|propertyChange|propertyChange menu item. 3.Connect the rubber band line to the ChangeReporter instance. The EventTargetDialog will be displayed. 4.Choose reportChange from the EventTargetDialog. The event hookup adapter source will be generated and compiled 5.Select OurButton and change some of it's properties. You will see change reports in ChangeReporter.

package sunw.demo.misc; import java.awt.*; import java.beans.*; import java.io.Serializable; /** * A simple extension of TextField that handles PropertyChangeEvents. * This Bean handles PropertyChange events by displaying the name of * the property and the new property value. A Java Bean that displays * bound properties can be connected to a ChangeReporter with the * BeanBox. To do so programatically is straightforward: * * import sunw.demo.misc.OurButton; * import sunw.demo.misc.ChangeReporter; * import java.awt.*; * import java.beans.*; *

* public class DemoChangeReporter * { * OurButton button = new OurButton(); * ChangeReporter reporter = new ChangeReporter(); * PropertyChangeAdapter adapter = new PropertyChangeAdapter(); * * DemoChangeReporter() * { * button.addPropertyChangeListener(adapter); * button.setLabel("Report This"); * * Frame f = new Frame("Demo Change Reporter"); * f.setLayout(new FlowLayout()); * f.add(button); * f.add(reporter); * f.pack(); * f.show(); * } * * class PropertyChangeAdapter implements PropertyChangeListener * { * public void propertyChange(PropertyChangeEvent e) * { * reporter.reportChange(e); * } *

* public static void main(String[] argv) * { * new DemoChangeReporter(); * } * * In the example above, the button is connected to the ChangeReporter with * a (nested) adpater class. When the DemoChangeReporter object is constructed * the buttons label field is set, and the adapters propertyChange method * runs. * */ public class ChangeReporter extends TextField implements Serializable { public ChangeReporter() { super("", 35); setEditable(false); } public void reportChange(PropertyChangeEvent evt) { String text = evt.getPropertyName() + " := " + evt.getNewValue(); int width = getSize().width - 10; Font f = getFont(); if (f != null) { // Trim the text to fit. FontMetrics fm = getFontMetrics(f); while (fm.stringWidth(text) > width) { text = text.substring(0, text.length()-1); } setText(text); }}

package sunw.demo.buttons; import java.awt.*; import java.awt.event.*; import java.beans.*; import java.io.Serializable; import java.util.Vector; /** * A simple Java Beans button. OurButton is a "from-scratch" * lightweight AWT component. It's a good example of how to * implement bound properties and support for event listeners. * * Parts of the source are derived from sun.awt.tiny.TinyButtonPeer. */ public class OurButton extends Component implements Serializable, MouseListener, MouseMotionListener { /** * Constructs a Button with the a default label. */ public OurButton() { this("press"); }

// // Methods for registering/deregistering event listeners /** * The specified ActionListeners actionPerformed method will * be called each time the button is clicked. The ActionListener * object is added to a list of ActionListeners managed by * this button, it can be removed with removeActionListener. * Note: the JavaBeans specification does not require ActionListeners * to run in any particular order. * #removeActionListener l the ActionListener */ public synchronized void addActionListener(ActionListener l) { pushListeners.addElement(l); } /** * Remove this ActionListener from the buttons internal list. If the * ActionListener isn't on the list, silently do nothing. * #addActionListener l the ActionListener */ public synchronized void removeActionListener(ActionListener l) { pushListeners.removeElement(l); }

/** * The specified PropertyChangeListeners propertyChange method will * be called each time the value of any bound property is changed. * The PropertyListener object is addded to a list of PropertyChangeListeners * managed by this button, it can be removed with removePropertyChangeListener. * Note: the JavaBeans specification does not require PropertyChangeListeners * to run in any particular order. * #removePropertyChangeListener l the PropertyChangeListener */ public void addPropertyChangeListener(PropertyChangeListener l) { changes.addPropertyChangeListener(l); } /** * Remove this PropertyChangeListener from the buttons internal list. * If the PropertyChangeListener isn't on the list, silently do nothing. * #addPropertyChangeListener l the PropertyChangeListener */ public void removePropertyChangeListener(PropertyChangeListener l) { changes.removePropertyChangeListener(l); }

// /** * This method has the same effect as pressing the button. * #addActionListener */ public void fireAction() { if (debug) { System.err.println("Button " + getLabel() + " pressed."); } Vector targets; synchronized (this) { targets = (Vector) pushListeners.clone(); } ActionEvent actionEvt = new ActionEvent(this, 0, null); for (int i = 0; i < targets.size(); i++) { ActionListener target = (ActionListener)targets.elementAt(i); target.actionPerformed(actionEvt); } private PropertyChangeSupport changes = new PropertyChangeSupport(this); private Vector pushListeners = new Vector();

Other Properties Constrained Properties: Change to property can be vetoed by other objects. Indexed Properties: Properties with multiple values (e.g. like a list of choices) See Tutorial for additional informationTutorial