private void init() {
setDefaultCloseOperation(DISPOSE_ON_CLOSE);
setTitle("Strategy Information - " + strategy.getName());
this.addWindowListener(
new WindowAdapter() {
@Override
public void windowClosing(WindowEvent e) {
Dispatcher dispatcher = Dispatcher.getInstance();
dispatcher.removeListener(StrategyInformationDialog.this);
}
});
JPanel contentPanel = new JPanel(new BorderLayout());
getContentPane().add(contentPanel, BorderLayout.CENTER);
JTabbedPane tabbedPane = new JTabbedPane();
contentPanel.add(tabbedPane, BorderLayout.CENTER);
JPanel performancePanel = new JPanel(new SpringLayout());
tabbedPane.addTab("Performance", performancePanel);
NumberFormat nf2 = NumberFormatterFactory.getNumberFormatter(2);
PerformanceManager pm = strategy.getPerformanceManager();
add(performancePanel, "Position", strategy.getPositionManager().getCurrentPosition());
add(performancePanel, "Trades", pm.getTrades());
add(performancePanel, "% Profitable", nf2.format(pm.getPercentProfitableTrades()));
add(performancePanel, "Average trade", nf2.format(pm.getAverageProfitPerTrade()));
add(performancePanel, "Net Profit", nf2.format(pm.getNetProfit()));
add(performancePanel, "Max Drawdown", nf2.format(pm.getMaxDrawdown()));
add(performancePanel, "Profit Factor", nf2.format(pm.getProfitFactor()));
add(performancePanel, "Kelly", nf2.format(pm.getKellyCriterion()));
add(performancePanel, "PI", nf2.format(pm.getPerformanceIndex()));
add(performancePanel, "CPI", nf2.format(pm.getCPI()));
makeCompactGrid(performancePanel);
JPanel securityPanel = new JPanel(new SpringLayout());
tabbedPane.addTab("Instrument", securityPanel);
add(securityPanel, "Symbol", strategy.getContract().m_symbol);
add(securityPanel, "Security Type", strategy.getContract().m_secType);
add(securityPanel, "Exchange", strategy.getContract().m_exchange);
add(securityPanel, "Multiplier", strategy.getContract().m_multiplier);
add(securityPanel, "Commission", strategy.getPerformanceManager().getCommission().toString());
bidAskLabel = new JLabel();
securityPanel.add(new JLabel("Best bid-ask" + ":"));
securityPanel.add(bidAskLabel);
cumBidAskSizesLabel = new JLabel();
securityPanel.add(new JLabel("Book bid-ask size" + ":"));
securityPanel.add(cumBidAskSizesLabel);
makeCompactGrid(securityPanel);
JPanel parametersPanel = new JPanel(new SpringLayout());
tabbedPane.addTab("Parameters", parametersPanel);
StrategyParams params = strategy.getParams();
add(parametersPanel, "Schedule", strategy.getTradingSchedule().toString());
for (StrategyParam param : params.getAll()) {
add(parametersPanel, param.getName(), param.getValue());
}
makeCompactGrid(parametersPanel);
IndicatorManager indicatorManager = strategy.getIndicatorManager();
if (indicatorManager != null) {
JPanel indicatorsPanel = new JPanel(new SpringLayout());
tabbedPane.addTab("Indicators", indicatorsPanel);
for (Indicator indicator : strategy.getIndicatorManager().getIndicators()) {
add(indicatorsPanel, indicator.getKey(), indicator.getValue());
}
makeCompactGrid(indicatorsPanel);
}
getContentPane().setPreferredSize(new Dimension(450, 400));
}
/** The main loop for the background thread. It is here that most of the work os orchestrated. */
public void run() {
double thisCost = 500.0;
double oldCost = 0.0;
double dcost = 500.0;
int countSame = 0;
map.update(map.getGraphics());
while (countSame < 100) {
generation++;
int ioffset = matingPopulationSize;
int mutated = 0;
// Mate the chromosomes in the favoured population
// with all in the mating population
for (int i = 0; i < favoredPopulationSize; i++) {
Chromosome cmother = chromosomes[i];
// Select partner from the mating population
int father = (int) (0.999999 * Math.random() * (double) matingPopulationSize);
Chromosome cfather = chromosomes[father];
mutated += cmother.mate(cfather, chromosomes[ioffset], chromosomes[ioffset + 1]);
ioffset += 2;
}
// The new generation is in the matingPopulation area
// move them to the correct area for sort.
for (int i = 0; i < matingPopulationSize; i++) {
chromosomes[i] = chromosomes[i + matingPopulationSize];
chromosomes[i].calculateCost(cities);
}
// Now sort the new mating population
Chromosome.sortChromosomes(chromosomes, matingPopulationSize);
double cost = chromosomes[0].getCost();
dcost = Math.abs(cost - thisCost);
thisCost = cost;
double mutationRate = 100.0 * (double) mutated / (double) matingPopulationSize;
NumberFormat nf = NumberFormat.getInstance();
nf.setMinimumFractionDigits(2);
nf.setMinimumFractionDigits(2);
status.setText(
"Generation "
+ generation
+ " Cost "
+ (int) thisCost
+ " Mutated "
+ nf.format(mutationRate)
+ "%");
if ((int) thisCost == (int) oldCost) {
countSame++;
} else {
countSame = 0;
oldCost = thisCost;
}
map.update(map.getGraphics());
}
status.setText("Solution found after " + generation + " generations.");
}
static {
Stroke stroke = new BasicStroke(2);
selectionShape = stroke.createStrokedShape(hitRect);
format.setMinimumIntegerDigits(1);
format.setMinimumFractionDigits(1);
format.setMaximumFractionDigits(2);
}
/** Return a double parsed from the given string, possibly formatted with a "%" sign */
public static double parseDouble(String val) throws NumberFormatException, ParseException {
NumberFormat formatPercent = NumberFormat.getPercentInstance(Locale.US); // for zoom factor
if (val.indexOf("%") == -1) { // not in percent format !
return Double.parseDouble(val);
}
// else it's a percent format -> parse it
Number n = formatPercent.parse(val);
return n.doubleValue();
}
//
// Sets the frame rate text displayed in the lower left corner.
//
void setFrameRateText() {
NumberFormat nf = NumberFormat.getInstance();
nf.setMinimumFractionDigits(2);
nf.setMaximumFractionDigits(2);
frameRateText.text(
"frames/sec = " + nf.format((double) frameCount / ((double) (time - lastTime) / 1000.0)));
}
/** A class to render numbers in scientific format. */
class ScientificRenderer extends JLabel implements TableCellRenderer {
NumberFormat format = NumberFormat.getInstance();
public ScientificRenderer(int sigfigs) {
sigfigs = Math.min(sigfigs, 6);
if (format instanceof DecimalFormat) {
String pattern = "0.0"; // $NON-NLS-1$
for (int i = 0; i < sigfigs - 1; i++) {
pattern += "0"; // $NON-NLS-1$
}
pattern += "E0"; // $NON-NLS-1$
((DecimalFormat) format).applyPattern(pattern);
}
}
public Component getTableCellRendererComponent(
JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
setFont(
getDefaultRenderer(String.class)
.getTableCellRendererComponent(DatasetStatisticsTable.this, "a", false, false, 0, 0)
.getFont()); //$NON-NLS-1$
setText(format.format(value));
setHorizontalAlignment(SwingConstants.TRAILING);
return this;
}
}
public void label(Graphics g, String var, double m, String units, int adj) {
g.setColor(Color.black);
g.setFont(font);
String s = format.format(m);
g.drawString(var + ": " + s, x + 5, y + h / 2 - 5);
g.drawString(units, x + w - adj, y + h / 2 - 5);
}
/**
* Formats the specified value and enters it in the text field.
*
* @param value the value to be entered
*/
public void setValue(double value) {
if (!isVisible()) return;
if (minValue != null) value = Math.max(value, minValue.doubleValue());
if (maxValue != null) value = Math.min(value, maxValue.doubleValue());
setFormatFor(value);
setText(format.format(value));
prevValue = value;
}
public void updateStates() {
NumberFormat nf = NumberFormat.getInstance();
nf.setMaximumFractionDigits(2);
nf.setMinimumFractionDigits(2);
try {
// System.out.println("getting variables.");
status = cryo.cryoGetStatusCORBA();
frame.lblStatus.setText(statusString[status] + " ");
heater = cryo.cryoGetHeaterCORBA();
frame.lblHeater.setText(nf.format(heater) + " watts");
temp = cryo.cryoGetTempCORBA();
frame.lblTemp.setText(nf.format(temp) + " deg");
cli = cryo.cryoGetCliCORBA();
if (Double.isNaN(cli)) {
frame.lblCli.setText(cli + " ");
} else frame.lblCli.setText(nf.format(cli) + " ");
} catch (org.omg.CORBA.COMM_FAILURE cf) {
// stop thread and try to reconnect to the server
frame.lblStatus.setText("FAILURE!! Server connected?");
stop = true;
return;
}
}
public Component getTableCellRendererComponent(
JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
setFont(
getDefaultRenderer(String.class)
.getTableCellRendererComponent(DatasetStatisticsTable.this, "a", false, false, 0, 0)
.getFont()); //$NON-NLS-1$
setText(format.format(value));
setHorizontalAlignment(SwingConstants.TRAILING);
return this;
}
/**
* Gets the value from the text field.
*
* @return the value
*/
public double getValue() {
if (getText().equals(format.format(prevValue))) return prevValue;
double retValue;
try {
retValue = format.parse(getText()).doubleValue();
if (minValue != null && retValue < minValue.doubleValue()) {
setValue(minValue.doubleValue());
return minValue.doubleValue();
}
if (maxValue != null && retValue > maxValue.doubleValue()) {
setValue(maxValue.doubleValue());
return maxValue.doubleValue();
}
} catch (ParseException e) {
Toolkit.getDefaultToolkit().beep();
setValue(prevValue);
return prevValue;
}
return retValue;
}
/**
* @return a double parsed from the value associated with the given key in the given Properties.
* returns "def" in key wasn't found, or if a parsing error occured. If "value" contains a "%"
* sign, we use a <code>NumberFormat.getPercentInstance</code> to convert it to a double.
*/
public static double parseProperty(Properties preferences, String key, double def) {
NumberFormat formatPercent = NumberFormat.getPercentInstance(Locale.US); // for zoom factor
String val = preferences.getProperty(key);
if (val == null) return def;
if (val.indexOf("%") == -1) { // not in percent format !
try {
return Double.parseDouble(val);
} catch (NumberFormatException nfe) {
nfe.printStackTrace();
return def;
}
}
// else it's a percent format -> parse it
try {
Number n = formatPercent.parse(val);
return n.doubleValue();
} catch (ParseException ex) {
ex.printStackTrace();
return def;
}
}
public void init() {
// 添加按钮
JPanel buttonPanel = new JPanel();
buttonPanel.add(okButton);
mainPanel.setLayout(new GridLayout(0, 3));
mainWin.add(mainPanel, BorderLayout.CENTER);
JFormattedTextField intField0 =
new JFormattedTextField(
new InternationalFormatter(NumberFormat.getIntegerInstance()) {
protected DocumentFilter getDocumentFilter() {
return new NumberFilter();
}
});
intField0.setValue(100);
addRow("只接受数字的文本框", intField0);
JFormattedTextField intField1 = new JFormattedTextField(NumberFormat.getIntegerInstance());
intField1.setValue(new Integer(100));
// 添加输入校验器
intField1.setInputVerifier(new FormattedTextFieldVerifier());
addRow("带输入校验器的文本框", intField1);
// 创建自定义格式器对象
IPAddressFormatter ipFormatter = new IPAddressFormatter();
ipFormatter.setOverwriteMode(false);
// 以自定义格式器对象创建格式化文本框
JFormattedTextField ipField = new JFormattedTextField(ipFormatter);
ipField.setValue(new byte[] {(byte) 192, (byte) 168, 4, 1});
addRow("IP地址格式", ipField);
mainWin.add(buttonPanel, BorderLayout.SOUTH);
mainWin.pack();
mainWin.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
mainWin.setVisible(true);
}
/** Update the statistic */
public void setStats(int mi, double me, int ma, double sd) {
NumberFormat nf = NumberFormat.getInstance();
nf.setMaximumFractionDigits(2);
nf.setMinimumFractionDigits(2);
nf.setGroupingUsed(false);
min.setText(Integer.toString(mi));
max.setText(Integer.toString(ma));
String s = nf.format(me);
mean.setText(s);
s = nf.format(sd);
stdDev.setText(s);
}
/**
* A Step is associated with a single frame of a TTrack. It contains an array of TPoints that define
* its image data and a Footprint that determines its screen appearance. This is an abstract class
* and cannot be instantiated directly.
*
* @author Douglas Brown
*/
public abstract class Step implements Cloneable {
// static fields
protected static Rectangle hitRect = new Rectangle(-4, -4, 8, 8);
protected static Shape selectionShape;
protected static AffineTransform transform = new AffineTransform();
protected static NumberFormat format = NumberFormat.getNumberInstance(Locale.US);
protected static Font textLayoutFont = new JTextField().getFont();
protected static FontRenderContext frc =
new FontRenderContext(
null, // no AffineTransform
false, // no antialiasing
false); // no fractional metrics
static {
Stroke stroke = new BasicStroke(2);
selectionShape = stroke.createStrokedShape(hitRect);
format.setMinimumIntegerDigits(1);
format.setMinimumFractionDigits(1);
format.setMaximumFractionDigits(2);
}
// instance fields
protected TTrack track; // track this belongs to
protected int n; // frame number
protected Footprint footprint; // determines appearance
protected TPoint[] points; // defines image data
protected Point[] screenPoints; // for transform conversions
protected boolean valid; // invalid steps not drawn
protected Map<TrackerPanel, Mark> marks // tracker panel to Mark
= new HashMap<TrackerPanel, Mark>();
protected int defaultIndex = 0; // array index of default TPoint
protected boolean dataVisible = true; // true if visible in plots, tables
/**
* Constructs a Step with the specified frame number.
*
* @param track the track
* @param n the frame number
*/
protected Step(TTrack track, int n) {
this.track = track;
this.n = n;
}
/**
* Gets the frame number.
*
* @return the frame number
*/
public int getFrameNumber() {
return n;
}
/**
* Sets the footprint.
*
* @param footprint the footprint
*/
public void setFootprint(Footprint footprint) {
this.footprint = footprint;
}
/**
* Gets the track.
*
* @return the track
*/
public TTrack getTrack() {
return track;
}
/**
* Gets the array of TPoints contained in this step.
*
* @return the TPoints array
*/
public TPoint[] getPoints() {
return points;
}
/**
* Gets the index of a point in the points[] array.
*
* @param p the point
* @return the index, or -1 if not found
*/
public int getPointIndex(TPoint p) {
for (int i = 0; i < points.length; i++) {
if (points[i] == p) return i;
}
return -1;
}
/**
* Gets the default point. The default point is the point initially selected when the step is
* created.
*
* @return the default TPoint
*/
public TPoint getDefaultPoint() {
return points[defaultIndex];
}
/**
* Sets the default point index. This defines the index of the points array used to get the point
* initially selected when the step is created.
*
* @param index the index
*/
public void setDefaultPointIndex(int index) {
index = Math.min(index, points.length - 1);
defaultIndex = Math.max(0, index);
}
/**
* Erases this on the specified tracker panel. Erasing adds the current bounds to the dirty region
* and nulls the step's mark to trigger creation of a new one.
*
* @param trackerPanel the tracker panel
*/
public void erase(TrackerPanel trackerPanel) {
if (marks.get(trackerPanel) == null) return; // already dirty
trackerPanel.addDirtyRegion(getBounds(trackerPanel)); // old bounds
marks.put(trackerPanel, null); // triggers new mark
}
/**
* Erases and remarks this on the specified tracker panel. Remarking creates a new mark for the
* step and adds both the old and new bounds to the tracker panel's dirty region.
*
* @param trackerPanel the tracker panel
*/
public void remark(TrackerPanel trackerPanel) {
erase(trackerPanel);
trackerPanel.addDirtyRegion(getBounds(trackerPanel)); // new bounds
}
/**
* Repaints this on the specified tracker panel. Repainting a step first remarks it and then
* requests a repaint of the panel's dirty region.
*
* @param trackerPanel the tracker panel
*/
public void repaint(TrackerPanel trackerPanel) {
remark(trackerPanel);
trackerPanel.repaintDirtyRegion();
}
/** Erases this on all tracker panels. */
public void erase() {
Iterator<TrackerPanel> it = marks.keySet().iterator();
while (it.hasNext()) erase(it.next());
}
/** Remarks this on all tracker panels. */
public void remark() {
Iterator<TrackerPanel> it = marks.keySet().iterator();
while (it.hasNext()) remark(it.next());
}
/** Repaints this on all tracker panels. */
public void repaint() {
Iterator<TrackerPanel> it = marks.keySet().iterator();
while (it.hasNext()) repaint(it.next());
}
/**
* Draws this step.
*
* @param panel the drawing panel requesting the drawing
* @param g the graphics context on which to draw
*/
public void draw(DrawingPanel panel, Graphics g) {
if (track.trackerPanel == panel) {
AutoTracker autoTracker = track.trackerPanel.getAutoTracker();
if (autoTracker.isInteracting(track)) return;
}
TrackerPanel trackerPanel = (TrackerPanel) panel;
boolean highlighted = (trackerPanel.getFrameNumber() == n);
if (trackerPanel.autoTracker != null
&& trackerPanel.autoTracker.getWizard().isVisible()
&& trackerPanel.autoTracker.getTrack() == track) {
highlighted = false;
}
getMark(trackerPanel).draw((Graphics2D) g, highlighted);
}
/**
* Finds the Interactive located at the specified pixel position.
*
* @param panel the drawing panel
* @param xpix the x pixel position
* @param ypix the y pixel position
* @return the TPoint that is hit, or null
*/
public Interactive findInteractive(DrawingPanel panel, int xpix, int ypix) {
boolean highlighted = (track.trackerPanel.getFrameNumber() == getFrameNumber());
AutoTracker autoTracker = track.trackerPanel.getAutoTracker();
TrackerPanel trackerPanel = (TrackerPanel) panel;
setHitRectCenter(xpix, ypix);
for (int i = 0; i < points.length; i++) {
if (points[i] == null || Double.isNaN(points[i].getX())) continue;
if (hitRect.contains(points[i].getScreenPosition(trackerPanel))) {
if (highlighted && autoTracker.isDrawingKeyFrameFor(track, i)) return null;
return points[i];
}
}
return null;
}
/**
* Gets the screen bounds of this step on the specified tracker panel.
*
* @param trackerPanel the tracker panel drawing the step
* @return the bounding rectangle
*/
public Rectangle getBounds(TrackerPanel trackerPanel) {
boolean highlighted = (trackerPanel.getFrameNumber() == n);
return getMark(trackerPanel).getBounds(highlighted);
}
/**
* Gets the mark for the specified panel.
*
* @param trackerPanel the tracker panel
* @return the mark
*/
protected Mark getMark(TrackerPanel trackerPanel) {
Mark mark = marks.get(trackerPanel);
TPoint selection = null;
if (mark == null) {
selection = trackerPanel.getSelectedPoint();
Point p = null;
valid = true; // assume true
for (int n = 0; n < points.length; n++) {
if (!valid) continue;
// determine if point is valid (ie not NaN)
valid = valid && !Double.isNaN(points[n].getX()) && !Double.isNaN(points[n].getY());
screenPoints[n] = points[n].getScreenPosition(trackerPanel);
if (valid && selection == points[n]) p = screenPoints[n];
}
mark = footprint.getMark(screenPoints);
if (p != null) { // point is selected, so draw selection shape
transform.setToTranslation(p.x, p.y);
int scale = FontSizer.getIntegerFactor();
if (scale > 1) {
transform.scale(scale, scale);
}
final Color color = footprint.getColor();
final Mark stepMark = mark;
final Shape selectedShape = transform.createTransformedShape(selectionShape);
mark =
new Mark() {
public void draw(Graphics2D g, boolean highlighted) {
stepMark.draw(g, false);
Paint gpaint = g.getPaint();
g.setPaint(color);
g.fill(selectedShape);
g.setPaint(gpaint);
}
public Rectangle getBounds(boolean highlighted) {
Rectangle bounds = selectedShape.getBounds();
bounds.add(stepMark.getBounds(false));
return bounds;
}
};
}
final Mark theMark = mark;
mark =
new Mark() {
public void draw(Graphics2D g, boolean highlighted) {
if (!valid) return;
theMark.draw(g, false);
}
public Rectangle getBounds(boolean highlighted) {
return theMark.getBounds(highlighted);
}
};
marks.put(trackerPanel, mark);
}
return mark;
}
/**
* Returns a String describing this step.
*
* @return a descriptive string
*/
public String toString() {
return "Step " + n; // $NON-NLS-1$
}
/**
* Clones this Step.
*
* @return a clone of this step
*/
public Object clone() {
try {
Step step = (Step) super.clone();
step.points = new TPoint[points.length];
step.screenPoints = new Point[points.length];
step.marks = new HashMap<TrackerPanel, Mark>();
return step;
} catch (CloneNotSupportedException ex) {
ex.printStackTrace();
}
return null;
}
/**
* Centers the hit testing rectangle on the specified screen point.
*
* @param xpix the x pixel position
* @param ypix the y pixel position
*/
protected void setHitRectCenter(int xpix, int ypix) {
hitRect.setLocation(xpix - hitRect.width / 2, ypix - hitRect.height / 2);
}
/**
* Gets the step length. Default length is 1.
*
* @return the length of the points array
*/
public static int getLength() {
return 1;
}
/** An inner superclass of all handles. */
class Handle extends TPoint {
/**
* Constructs a Handle with specified image coordinates.
*
* @param x the x coordinate
* @param y the y coordinate
*/
public Handle(double x, double y) {
super(x, y);
}
/**
* Sets the position of this handle on the line nearest the specified screen position.
* Subclasses must override.
*
* @param xScreen the x screen position
* @param yScreen the y screen position
* @param trackerPanel the trackerPanel drawing this step
*/
public void setPositionOnLine(int xScreen, int yScreen, TrackerPanel trackerPanel) {}
}
}
/**
* This is a JTextField that accepts only numbers.
*
* @author Douglas Brown
* @version 1.0
*/
public class NumberField extends JTextField {
// instance fields
protected NumberFormat format = NumberFormat.getInstance();
protected double prevValue;
protected Double maxValue;
protected Double minValue;
/**
* Constructs a NumberField.
*
* @param columns the number of character columns
*/
public NumberField(int columns) {
super(columns);
}
/**
* Gets the value from the text field.
*
* @return the value
*/
public double getValue() {
if (getText().equals(format.format(prevValue))) return prevValue;
double retValue;
try {
retValue = format.parse(getText()).doubleValue();
if (minValue != null && retValue < minValue.doubleValue()) {
setValue(minValue.doubleValue());
return minValue.doubleValue();
}
if (maxValue != null && retValue > maxValue.doubleValue()) {
setValue(maxValue.doubleValue());
return maxValue.doubleValue();
}
} catch (ParseException e) {
Toolkit.getDefaultToolkit().beep();
setValue(prevValue);
return prevValue;
}
return retValue;
}
/**
* Formats the specified value and enters it in the text field.
*
* @param value the value to be entered
*/
public void setValue(double value) {
if (!isVisible()) return;
if (minValue != null) value = Math.max(value, minValue.doubleValue());
if (maxValue != null) value = Math.min(value, maxValue.doubleValue());
setFormatFor(value);
setText(format.format(value));
prevValue = value;
}
/**
* Sets the resolution for this number field.
*
* @param delta the change in value that must be resolvable
*/
public void setResolution(double delta) {
/** implemented in subclasses */
}
/**
* Sets a minimum value for this field.
*
* @param min the minimum allowed value
*/
public void setMinValue(double min) {
minValue = new Double(min);
}
/**
* Sets a maximum value for this field.
*
* @param max the maximum allowed value
*/
public void setMaxValue(double max) {
maxValue = new Double(max);
}
/**
* Gets the format for this field.
*
* @return the format
*/
public NumberFormat getFormat() {
return format;
}
/**
* Sets the format for a specified value. Subclasses may override this to modify the format before
* displaying the value.
*
* @param value the value to be displayed
*/
public void setFormatFor(double value) {
/** implemented in subclasses */
}
}
public FormatTestFrame() {
JPanel buttonPanel = new JPanel();
okButton = new JButton("Ok");
buttonPanel.add(okButton);
add(buttonPanel, BorderLayout.SOUTH);
mainPanel = new JPanel();
mainPanel.setLayout(new GridLayout(0, 3));
add(mainPanel, BorderLayout.CENTER);
JFormattedTextField intField = new JFormattedTextField(NumberFormat.getIntegerInstance());
intField.setValue(new Integer(100));
addRow("Number:", intField);
JFormattedTextField intField2 = new JFormattedTextField(NumberFormat.getIntegerInstance());
intField2.setValue(new Integer(100));
intField2.setFocusLostBehavior(JFormattedTextField.COMMIT);
addRow("Number (Commit behavior):", intField2);
JFormattedTextField intField3 =
new JFormattedTextField(
new InternationalFormatter(NumberFormat.getIntegerInstance()) {
protected DocumentFilter getDocumentFilter() {
return filter;
}
});
intField3.setValue(new Integer(100));
addRow("Filtered Number", intField3);
JFormattedTextField intField4 = new JFormattedTextField(NumberFormat.getIntegerInstance());
intField4.setValue(new Integer(100));
intField4.setInputVerifier(
new InputVerifier() {
public boolean verify(JComponent component) {
JFormattedTextField field = (JFormattedTextField) component;
return field.isEditValid();
}
});
addRow("Verified Number:", intField4);
JFormattedTextField currencyField = new JFormattedTextField(NumberFormat.getCurrencyInstance());
currencyField.setValue(new Double(10));
addRow("Currency:", currencyField);
JFormattedTextField dateField = new JFormattedTextField(DateFormat.getDateInstance());
dateField.setValue(new Date());
addRow("Date (default):", dateField);
DateFormat format = DateFormat.getDateInstance(DateFormat.SHORT);
format.setLenient(false);
JFormattedTextField dateField2 = new JFormattedTextField(format);
dateField2.setValue(new Date());
addRow("Date (short, not lenient):", dateField2);
try {
DefaultFormatter formatter = new DefaultFormatter();
formatter.setOverwriteMode(false);
JFormattedTextField urlField = new JFormattedTextField(formatter);
urlField.setValue(new URL("http://java.sun.com"));
addRow("URL:", urlField);
} catch (MalformedURLException ex) {
ex.printStackTrace();
}
try {
MaskFormatter formatter = new MaskFormatter("###-##-####");
formatter.setPlaceholderCharacter('0');
JFormattedTextField ssnField = new JFormattedTextField(formatter);
ssnField.setValue("078-05-1120");
addRow("SSN Mask:", ssnField);
} catch (ParseException ex) {
ex.printStackTrace();
}
JFormattedTextField ipField = new JFormattedTextField(new IPAddressFormatter());
ipField.setValue(new byte[] {(byte) 130, 65, 86, 66});
addRow("IP Address:", ipField);
pack();
}
public MainCitiesCriteriaPanel() {
super(new BorderLayout());
CountryController countryc = Application.getCountryController();
CitiesController citiesc = Application.getCitiesController();
countryName = Application.getCountryName();
label = new JLabel();
labelPanel = new JPanel();
labelPanel.add(label);
label.setText("Criteria to select main cities for " + countryName.replaceAll("_", " "));
listModel = new DefaultListModel();
Iterator<HashMap<String, String>> iter = citiesc.getToponymTypesIterator();
while (iter.hasNext()) {
String topTypeName = iter.next().get("code");
listModel.addElement(topTypeName);
}
list = new JList(listModel);
list.addListSelectionListener(this);
listPanel = new JScrollPane(list);
NumberFormat nCitiesFormat = NumberFormat.getInstance();
nCitiesFormat.setMaximumFractionDigits(0);
nCitiesFormat.setMaximumIntegerDigits(4);
NumberFormat distFormat = NumberFormat.getInstance();
distFormat.setMaximumFractionDigits(0);
distFormat.setMaximumIntegerDigits(3);
nCitiesField = new JFormattedTextField(nCitiesFormat);
distField = new JFormattedTextField(distFormat);
nCitiesField.setMaximumSize(new Dimension(50, 1));
distField.setMaximumSize(new Dimension(50, 1));
rb1 = new JRadioButton("Filter by type", true);
rb2 = new JRadioButton("Filter by number", false);
rb3 = new JRadioButton("Filter by distance to the borders (km)", false);
ButtonGroup bgroup = new ButtonGroup();
bgroup.add(rb1);
bgroup.add(rb2);
bgroup.add(rb3);
JPanel radioPanel = new JPanel();
radioPanel.setLayout(new BoxLayout(radioPanel, BoxLayout.Y_AXIS));
radioPanel.add(rb1);
radioPanel.add(listPanel);
radioPanel.add(rb2);
radioPanel.add(nCitiesField);
radioPanel.add(rb3);
radioPanel.add(distField);
submit = new JButton();
back = new JButton();
submit.setText("OK");
back.setText("GO BACK");
submit.addActionListener(this);
back.addActionListener(this);
buttonPanel = new JPanel();
buttonPanel.add(back);
buttonPanel.add(submit);
add(labelPanel, BorderLayout.NORTH);
add(radioPanel, BorderLayout.CENTER);
add(buttonPanel, BorderLayout.SOUTH);
}