Hi there!
This is my ULCSpinner component (the basic object is
JSpinner/SpinnerNumberModel). It seems to work but i have problems with
Enablers because it seems not to source enablers correctly.
I dont understand why the UISpinner.BasicSpinner.setEnabled method is
never called when, in the sample i posted you, i entered something on
the textfield. I set that textfield as enabler of the spinner and of the
button. The button is correctly enabled, but my the spinner not.
Why? :-o
Best regards,
Paolo Scaffardi
GFP Lab s.r.l.
http://www.gfplab.com
fax 178 2258454
import com.ulcjava.base.application.*;
import com.ulcjava.base.application.datatype.ULCNumberDataType;
import com.ulcjava.base.application.event.ActionEvent;
import com.ulcjava.base.application.event.IActionListener;
import com.ulcjava.base.application.event.IValueChangedListener;
import com.ulcjava.base.application.event.ValueChangedEvent;
import com.ulcjava.base.application.util.Color;
import com.ulcjava.base.application.util.Dimension;
import com.ulcjava.base.application.util.Font;
import com.ulcjava.base.application.util.ULCIcon;
import com.ulcjava.base.server.IDispatcher;
import java.awt.Image;
import java.util.Calendar;
import java.util.Date;
import javax.swing.ImageIcon;
import javax.swing.JDialog;
import javax.swing.JLabel;
public class ULCSpinnerSample extends AbstractApplication {
public void start() {
try {
ULCFrame frame = new ULCFrame("ULCSpinner Sample");
frame.setDefaultCloseOperation(ULCFrame.TERMINATE_ON_CLOSE);
ULCBoxPane boxPane = new ULCBoxPane();
ULCTextField textField = new ULCTextField(20) ;
ULCNumberDataType dataType = new ULCNumberDataType();
boxPane.add(textField);
ULCButton button1 = new ULCButton("Test");
button1.setEnabler(textField);
boxPane.add(button1);
final ULCSpinner spinner = new ULCSpinner(5,2,10,2);
spinner.addValueChangedListener(new IValueChangedListener() {
public void valueChanged(ValueChangedEvent arg0) {
System.out.println("Value changed: " +
((ULCSpinner) arg0.getSource()).getValue());
}
});
spinner.setEnabler(textField);
boxPane.add(spinner);
final ULCToggleButton button = new ULCToggleButton("Disable");
button.addActionListener(new IActionListener() {
public void actionPerformed(ActionEvent arg0) {
spinner.setEnabled(!button.isSelected());
}
});
boxPane.add(button);
button.setEnabler(spinner);
frame.add(boxPane);
frame.pack();
frame.setLocationRelativeTo(null);
frame.setVisible(true);
} catch (Exception e) {
e.printStackTrace() ;
}
}
}
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Vector;
import javax.swing.JSpinner;
import javax.swing.SpinnerModel;
import javax.swing.SpinnerNumberModel;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import com.ulcjava.base.client.UIComponent;
import com.ulcjava.base.client.util.IChangedListener;
import com.ulcjava.base.client.util.IEnablingSource;
import com.ulcjava.base.client.util.IEnablingTarget;
import com.ulcjava.base.client.util.IHasChangedSource;
public class UISpinner extends UIComponent
implements ChangeListener, IEnablingSource, IHasChangedSource,
IEnablingTarget {
private List<IEnablingTarget> enablingTargets = new
ArrayList<IEnablingTarget>();
private Vector<IChangedListener> changedListeners = new
Vector<IChangedListener>() ;
protected class BasicSpinner extends JSpinner {
public BasicSpinner() {
}
public BasicSpinner(SpinnerModel model) {
super(model);
}
}
@Override
protected Object createBasicObject(Object[] o) {
Number value = (Number) o[0];
Comparable min = (Comparable)o[1] ;
Comparable max = (Comparable)o[2] ;
Number stepSize = (Number)o[3] ;
SpinnerNumberModel model = new SpinnerNumberModel();
if (value != null)
model.setValue(value);
if (min != null)
model.setMinimum(min);
if (max != null)
model.setMaximum(max);
if (stepSize != null)
model.setStepSize(stepSize);
return new BasicSpinner(model);
}
public BasicSpinner getBasicSpinner() {
return (BasicSpinner) getBasicObject();
}
@Override
protected void postInitializeState() {
super.postInitializeState();
getModel().addChangeListener(this);
}
public SpinnerNumberModel getModel() {
return (SpinnerNumberModel) getBasicSpinner().getModel() ;
}
public void addTarget(IEnablingTarget ienablingtarget) {
enablingTargets.add(ienablingtarget);
ienablingtarget.setEnabled(isEnabling());
}
public boolean isEnabling() {
return getBasicSpinner().getValue() != null;
}
public void removeTarget(IEnablingTarget ienablingtarget) {
enablingTargets.remove(ienablingtarget);
}
private void updateEnablingTargets() {
Iterator<IEnablingTarget> iterator = enablingTargets.iterator();
while (iterator.hasNext()) {
IEnablingTarget ienablingtarget = iterator.next();
ienablingtarget.setEnabled(isEnabling());
}
}
public void addHasChangedListener(IChangedListener arg0) {
changedListeners.add(arg0);
}
public void removeHasChangedListener(IChangedListener arg0) {
changedListeners.remove(arg0);
}
public void stateChanged(ChangeEvent e) {
updateEnablingTargets();
updateStateULC("value", getValue());
fireValueChangedULC();
for(IChangedListener l : changedListeners)
l.changed() ;
}
protected void fireValueChangedULC() {
fireMandatoryEventULC("valueChanged", "valueChanged",
EMPTY_ARGUMENTS);
}
public Object getValue() {
return getBasicSpinner().getValue();
}
public void setMaximum(Comparable max) {
getModel().setMaximum(max);
}
public void setMinimum(Comparable min) {
getModel().setMinimum(min);
}
public void setStepSize(Number stepSize) {
getModel().setStepSize(stepSize);
}
public void setValue(Number n) {
getModel().setValue(n);
}
}
import com.ulcjava.base.application.ULCComponent;
import com.ulcjava.base.application.ULCProxy;
import com.ulcjava.base.application.enabler.IEnabler;
import com.ulcjava.base.application.enabler.IHasChangedSource;
import com.ulcjava.base.application.event.IValueChangedListener;
import com.ulcjava.base.application.event.ValueChangedEvent;
import com.ulcjava.base.server.IDispatcher;
public class ULCSpinner extends ULCComponent implements IEnabler,
IHasChangedSource {
public final static String VALUECHANGED_CATEGORY = "valueChanged" ;
private static final String VALUE_PROP = "value";
private static final String MINIMUM_PROP = "minimum";
private static final String MAXIMUM_PROP = "maximum";
private static final String STEPSIZE_PROP = "stepSize";
private Comparable minimum = null ;
private Comparable maximum = null ;
private Number stepSize = null ;
protected Number value = null ;
protected class ULCSpinnerDispatcher extends ULCComponentDispatcher {
public void updateValue(Number value) {
ULCSpinner.this.value = value ;
}
}
public ULCSpinner() {
this(null, null, null, null);
}
public ULCSpinner(Number value, Comparable min, Comparable max, Number
stepSize) {
this.value = value ;
this.minimum = min ;
this.maximum = max ;
this.stepSize = stepSize ;
}
@Override
protected IDispatcher createDispatcher() {
return new ULCSpinnerDispatcher();
}
@Override
protected String getPropertyPrefix() {
return "ULCSpinner";
}
@Override
protected String typeString() {
return "UISpinner";
}
public void addValueChangedListener(IValueChangedListener listener) {
addListener(VALUECHANGED_CATEGORY,listener);
}
public void removeValueChangedListener(IValueChangedListener listener) {
removeListener(VALUECHANGED_CATEGORY,listener);
}
@Override
protected void uploadStateUI() {
createStateUI(new Object[] {value, minimum, maximum, stepSize});
}
public Number getValue() {
return value;
}
public Comparable getMinimum() {
return minimum;
}
public Number getStepSize() {
return stepSize;
}
public Comparable getMaximum() {
return maximum;
}
public void setValue(Number value) {
this.value = (Number) setStateUI(VALUE_PROP, this.value, value);
}
public void setMaximum(Comparable maximum) {
this.maximum = (Comparable) setStateUI(MAXIMUM_PROP,
this.maximum, maximum);
}
public void setMinimum(Comparable minimum) {
this.minimum = (Comparable) setStateUI(MINIMUM_PROP,
this.minimum, minimum);
}
public void setStepSize(Number stepSize) {
this.stepSize = (Number) setStateUI(STEPSIZE_PROP,
this.stepSize, stepSize);
}
}
import com.ulcjava.base.development.DevelopmentRunner;
import com.ulcjava.base.shared.logging.Level;
public class ULCSpinnerLauncher {
public static void main(String[] args) {
DevelopmentRunner.setApplicationClass(ULCSpinnerSample.class);
DevelopmentRunner.setLogLevel(Level.ALL);
DevelopmentRunner.main(args);
}
}
