null to set the background to be transparent
* @see #setDataAreaColor(Color)
* @see #setForegroundColor(Color)
*/
public void setBackground(Color c)
{
contentPane.setBackground(c);
setChanged();
}
/**
* Get the background color.
*/
public Color getBackground()
{
if (contentPane.isPaintingBackground()) return contentPane.getBackground();
else return super.getBackground();
}
/**
* Sets the current foreground color, used by default as the color
* for the axis, labels, title, legend etc. By default the foreground
* color of the plots container is used
* @param c The new foreground color
*/
public void setForegroundColor(Color c)
{
super.setForeground(c);
setChanged();
}
/**
* Return the current data area background color
* @return The current data area background color
* @see #setDataAreaColor(Color)
*/
public Color getDataAreaColor()
{
return dataArea.getBackground();
}
/**
* Set the color used to paint the background of the data area
* @param c The new color to be used to paint the data area background, or null`to set the bacground back to the default value
* @see #setBackground(Color)
* @see #setForeground(Color)
*/
public void setDataAreaColor(Color c)
{
dataArea.setBackground(c);
setChanged();
}
public final static int NONE = PlotComponent.NONE;
public final static int BEVEL_IN = PlotComponent.BEVEL_IN;
public final static int BEVEL_OUT = PlotComponent.BEVEL_OUT;
public final static int ETCHED = PlotComponent.ETCHED;
public final static int LINE = PlotComponent.LINE;
public final static int SHADOW = PlotComponent.SHADOW;
/**
* Set the border to place around the data area
* @param type One of NONE,BEVEL_IN,BEVEL_OUT,ETCHED,LINE,SHADOW
*/
public void setDataAreaBorderType(int type)
{
dataArea.setBorderType(type);
dataArea.revalidate();
setChanged();
}
/**
* Get the current data area border type
* @return One of NONE,BEVEL_IN,BEVEL_OUT,ETCHED,LINE,SHADOW,OTHER
*/
public int getDataAreaBorderType()
{
return dataArea.getBorderType();
}
public void setDataAreaBorder(Border b)
{
dataArea.setBorder(b);
}
public Border getDataAreaBorder()
{
return dataArea.getBorder();
}
/**
* Gets the X axis
* @return The current X axis
*/
public JASHistAxis getXAxis()
{
return dataManager.getXAxis();
}
/**
* Gets the default Y Axis
* @return The current default Y Axis
* @see #getYAxis(int)
*/
public JASHistAxis getYAxis()
{
return dataManager.getYAxis(0);
}
/**
* Gets either Y Axis.
* @param index The axis to get, 0 = left (default), 1 = right
* @return The requested Axis
*/
public JASHistAxis getYAxis(int index)
{
return dataManager.getYAxis(index);
}
/**
* Get an array containing all of the Y Axes
*/
public JASHistAxis[] getYAxes()
{
return dataManager.getYAxes();
}
final public static int LEGEND_NEVER = 0;
final public static int LEGEND_AUTOMATIC = 1;
final public static int LEGEND_ALWAYS = 2;
/**
* Set when the legend will be shown. By default the option is
* set to LEGEND_AUTOMATIC, which means that the legend will be shown
* whenever there is more than one DataSource attached to the plot.
* @param legend One of LEGEND_NEVER,LEGEND_AUTOMATIC,LEGEND_ALWAYS
*/
public void setShowLegend(int legend)
{
showLegend = legend;
dataManager.showLegend();
}
/**
* Get the current setting of the showLegend property
* @return The current settign of showLegend
* @see #setShowLegend(int)
*/
public int getShowLegend()
{
return showLegend;
}
/**
* Add a DataSource to the plot.
* @param ds The DataSource to add
* @throws DataManagerException If the subclass of DataSource is unrecognized or if the new DataSource is incompatible with previously added DataSources.
*/
public JASHistData addData(DataSource ds) throws DataManagerException
{
if (ds instanceof Rebinnable1DHistogramData) return add1DData((Rebinnable1DHistogramData) ds);
if (ds instanceof XYDataSource ) return addXYData((XYDataSource) ds);
if (ds instanceof Rebinnable2DHistogramData) return add2DData((Rebinnable2DHistogramData) ds);
if (ds instanceof ScatterPlotSource ) return addScatterData((ScatterPlotSource) ds);
if (ds instanceof FunctionData ) return addFunctionData((FunctionData) ds);
throw new DataManagerException("Unknown DataSource subclass: "+ds);
}
/**
* Add a Rebinnable1DHistogramData source to the plot
* @param ds The data source to be added
*/
private JASHistData add1DData(Rebinnable1DHistogramData ds) throws DataManagerException
{
if (dataManager instanceof DefaultDataManager)
{
int type = ds.getAxisType();
if (type == ds.DOUBLE ) dataManager = new DoubleDataManager(this,dataArea,legend,stats,50);
else if (type == ds.INTEGER) dataManager = new IntegerDataManager(this,dataArea,legend,stats,50);
else if (type == ds.STRING ) dataManager = new StringDataManager(this,dataArea,legend,stats);
else if (type == ds.DATE ) dataManager = new DateDataManager(this,dataArea,legend,stats,50);
else throw new DataManagerException("Unsupported axis type");
if (isInit) dataManager.init(); // Only necessary if addNotify already called
}
JASHistData data = dataManager.add(ds);
setChanged();
return data;
}
/**
* Add a Rebinnable1DHistogramData source to the plot
* @param ds The data source to be added
*/
private JASHistData addXYData(XYDataSource ds) throws DataManagerException
{
if (dataManager instanceof DefaultDataManager)
{
int type = ds.getAxisType();
if (type == ds.DOUBLE ) dataManager = new DoubleDataManager(this,dataArea,legend,stats,50);
else if (type == ds.INTEGER) dataManager = new IntegerDataManager(this,dataArea,legend,stats,50);
else if (type == ds.DATE ) dataManager = new DateDataManager(this,dataArea,legend,stats,50);
else throw new DataManagerException("Unsupported axis type");
if (isInit) dataManager.init(); // Only necessary if addNotify already called
}
JASHistData data = dataManager.add(ds);
setChanged();
return data;
}
/**
* Add a ScatterPlotSource to the plot
* @param ds The data source to be added
*/
private JASHistData addScatterData(ScatterPlotSource ds) throws DataManagerException
{
if (dataManager instanceof DefaultDataManager)
{
int typeX = ds.getXAxisType();
int typeY = ds.getYAxisType();
if (typeY != ds.DOUBLE) throw new DataManagerException("Scatterplot Y Axis must be of type DOUBLE");
if (typeX == ds.DOUBLE) dataManager = new DoubleScatterDataManager(this, dataArea, legend, stats);
else if (typeX == ds.DATE ) dataManager = new DateScatterDataManager(this,dataArea, legend, stats);
if (isInit) dataManager.init(); // Only necessary if addNotify already called
}
final JASHistData data = dataManager.add(ds);
setChanged();
return data;
}
/**
* Add a 2D Histogram data source to the histogram
* @param ds The data source to be added
*/
private JASHistData add2DData(Rebinnable2DHistogramData ds) throws DataManagerException
{
if (dataManager instanceof DefaultDataManager)
{
int typeX = ds.getXAxisType();
int typeY = ds.getYAxisType();
if (typeX == ds.DOUBLE) dataManager = new DoubleScatterDataManager(this, dataArea, legend, stats);
else if (typeX == ds.DATE ) dataManager = new DateScatterDataManager(this,dataArea, legend, stats);
else throw new DataManagerException("Unsupported X Axis type for ScatterPlot");
if (isInit) dataManager.init(); // Only necessary if addNotify already called
}
final JASHistData data = dataManager.add(ds);
setChanged();
return data;
}
/**
* Add a function to be overlayed on a 1D histogram
* @param ds The function to be added
*/
private JASHistData addFunctionData(FunctionData ds) throws DataManagerException
{
if ( dataManager instanceof SupportsFunctions )
{
JASHistData data = ((SupportsFunctions) dataManager).addFunction((Basic1DFunction) ds);
setChanged();
return data;
}
else throw new UnsupportedOperationException("Cannot add function.");
}
int numberOfDataSets() // used by property dialog
{
return dataManager.numberOfDataSources();
}
int numberOfFunctions()
{
if (dataManager instanceof SupportsFunctions)
return ((SupportsFunctions) dataManager).numberOfFunctions();
return 0;
}
/**
* Get the set of data sources currently attached to the plot.
* Note that despite the name of this routine it does not return
* an Enumeration of DataSources, but rather an Enumeration of
* JASHistData objects, from which the DataSource can be obtained,
* for example:
*
* Enumeration e = hPlot.getDataSources();
* while (e.hasMoreElements())
* {
* JASHistData data = (JASHistData) e.nextElement();
* DataSource source = data.getDataSource();
* }
*
* @return An Enumeration of the JASHistData objects
* @see JASHistData
* @see JASHistData#getDataSource()
*/
public Enumeration getDataSources()
{
return dataManager.getDataSources();
}
/**
* Get the number of data sources attached to the plot
*/
public int getNumberOfDataSources()
{
return dataManager.numberOfDataSources();
}
/**
* Get the set of Functions currently attached to the plot
* @return An Enumeration of the Functions, or null if the current DataSources do not support functions
*/
public Enumeration get1DFunctions()
{
if (dataManager instanceof SupportsFunctions)
return ((SupportsFunctions) dataManager).getFunctions();
return null;
}
/**
* Removes and detaches all data from the plot, but doesn't set up
* the plot for further use. Call this method if you aren't going to
* be using the plot object any more. Call removeAllData()
* to remove all data and set up the plot for further use.
*/
public void destroy()
{
dataManager.destroy();
contentPane.removeAll(); // should detach itself as a listener to all of its children
}
/**
* Removes and detaches all data and sets up the plot for further use.
* The method destroy() is less expensive and
* should be used if the plot will not be used any more.
*/
public void removeAllData()
{
dataManager.destroy(); // this call detached data, now we set up the plot for further use
dataManager = new DefaultDataManager(this,dataArea);
setChanged();
}
private void resetAxis(JASHistAxis a)
{
a.setRangeAutomatic(true);
a.setAllowSuppressedZero(true);
a.setLogarithmic(false);
setChanged();
}
/**
* Fills the appropriate Function menu items into a user
* provided menu. This routine can be used to make a function
* fitting menu available to an external application without having
* to rewrite a bunch of code already contained in JASHist
*
* @param menu The menu to which the items will be added
*/
public void fillFunctionMenu(JMenu menu)
{
if (dataManager instanceof SupportsFunctions)
{
((SupportsFunctions) dataManager).fillFunctionMenu(menu);
menu.setEnabled(true);
}
else menu.setEnabled(false);
}
/**
* Fills the appriate Slice/Projection menu items into a user
* provided menu. This routine can be used to make a function
* fitting menu available to an external application without having
* to rewrite a bunch of code already contained in JASHist
*
* @param menu The menu to which the items will be added
*/
public void fillSliceMenu(JMenu menu)
{
if (dataManager instanceof TwoDDataManager)
{
((TwoDDataManager) dataManager).fillSliceMenu(menu);
menu.setEnabled(true);
}
else menu.setEnabled(false);
}
/**
* Get the text of the title.
* @return A String containing the text of the title, or null if there is no title at present
* @see #getTitleObject()
*/
public String getTitle()
{
if (title == null) return null;
return title.getText();
}
/**
* Actually get the Title object.
* @return The current title, or null if there is no title
*/
public Title getTitleObject()
{
return title;
}
/**
* Actually set the Title object.
* @param newTitle The new title object
*/
public void setTitleObject(Title newTitle)
{
if (title != null)
{
contentPane.remove(title);
}
title = newTitle;
contentPane.add(title);
contentPane.invalidate();
setChanged();
}
/**
* Set the text of the title
* @param newValue pass null to remove the title
*/
public void setTitle(String newValue)
{
if (newValue != null && newValue.length() != 0)
{
if (title == null)
{
title = new Title(newValue);
contentPane.add(title);
contentPane.invalidate();
validate();
}
else
title.setText(newValue);
setChanged();
}
else if (title != null)
{
contentPane.remove(title);
contentPane.invalidate();
validate();
title = null;
}
}
public boolean isChanged()
{
return changed;
}
private void setChanged()
{
changed = true;
validate();
repaint(); // does this cause double repaint if the component was invalidated?
}
/**
* Add a FitListener that will receive notifications about the
* status of fits being performed by the plot
* @param fitListener The FitListener to add
*/
//TODO: Dont we need a removeFitListener?
public static void addFitListener(final FitListener fitListener)
{
if (fitListeners == null)
fitListeners = new Vector(1, 1);
fitListeners.addElement(fitListener);
}
static void notifyFitListeners(final Fitter fitter)
{
if (fitListeners != null)
{
final Enumeration e = fitListeners.elements();
while (e.hasMoreElements())
((FitListener) e.nextElement()).fitStarted(fitter);
}
}
public void mouseEventNotify(final MouseEvent e)
{
processMouseEvent(e);
}
public void deselected()
{
contentPane.deselected();
}
public StatisticsBlock getStats()
{
return stats;
}
public void setStats(StatisticsBlock newStats)
{
stats = newStats;
}
public Legend getLegend()
{
return legend;
}
public void setLegend(Legend newLegend)
{
legend = newLegend;
}
/**
* Pops up a dialog asking the user to choose a file/format to save the plot.
*/
public void saveAs()
{
//types.add(new SaveAsPluginAdapter(new org.freehep.graphics2d.exportchooser.EPS2DExportFileType()));
//types.add(new SaveAsPluginAdapter(new org.freehep.graphics2d.exportchooser.PDF2DExportFileType()));
//types.add(new SaveAsPluginAdapter(new org.freehep.graphics2d.exportchooser.SVG2DExportFileType()));
SaveAsDialog dlg = new SaveAsDialog(this);
dlg.pack();
dlg.doModal();
}
/**
* Copies the plot to the clipboard
*/
public void copy()
{
VectorGraphicsTransferable t = new VectorGraphicsTransferable(this);
getToolkit().getSystemClipboard().setContents(t,t);
}
static private Vector fitListeners;
private Title title; // The plot title
private StatisticsBlock stats;
private boolean isInit = false;
private boolean changed = false;
private int showLegend = JASHist.LEGEND_AUTOMATIC;
private DataArea dataArea;
private DataManager dataManager;
private Legend legend;
private PlotPanel contentPane = new JASHistPlotPanel();
static final long serialVersionUID = 4433180397297758071L;
final private class JASHistPlotPanel extends PlotPanel implements HasPopupItems
{
void showWarning(Component parent, String text) {
javax.swing.JOptionPane.showMessageDialog(parent, text, "Warning: Deprecated", javax.swing.JOptionPane.WARNING_MESSAGE);;
}
public void print(Graphics g) {
jas.plot.PrintHelper ph = jas.plot.PrintHelper.instance();
Thread t = ph.printingThread();
if ( ! ph.isPrinting() )
ph.setPrintingThread(Thread.currentThread());
super.print(g);
ph.setPrintingThread(t);
}
public void modifyPopupMenu(final JPopupMenu menu, final Component source)
{
if (menu.getComponentCount() > 0) menu.addSeparator();
JCheckBoxMenuItem dl = new JCheckBoxMenuItem("Default Plot Layout")
{
final protected void fireActionPerformed(final ActionEvent e)
{
contentPane.restoreDefaultLayout();
}
};
boolean def = contentPane.hasDefaultLayout();
dl.setSelected(def);
dl.setEnabled(!def);
menu.add(dl);
menu.add(new JMenuItem("Plot Properties...")
{
final protected void fireActionPerformed(final ActionEvent e)
{
String text = "\"Plot Properties...\" is deprecated,\n";
text += "Please try using \"Edit AIDA Style for\" instead";
showWarning(this, text);
showProperties();
}
});
menu.add(new JMenuItem("Copy Plot to Clipboard...")
{
final protected void fireActionPerformed(final ActionEvent e)
{
copy();
}
});
menu.add(new JMenuItem("Save Plot As...")
{
final protected void fireActionPerformed(final ActionEvent e)
{
saveAs();
}
});
menu.add(new JMenuItem("Print Plot...")
{
final protected void fireActionPerformed(final ActionEvent e)
{
try
{
PrintHelper ph = PrintHelper.instance();
ph.printTarget(JASHistPlotPanel.this);
}
catch (Exception x)
{
x.printStackTrace(); // TODO: Something better
}
}
});
}
}
private final class SetTitleMenuItem extends JCheckBoxMenuItem
{
SetTitleMenuItem()
{
super("Show Title");
setSelected(title != null && title.isVisible());
}
protected void fireActionPerformed(final ActionEvent e)
{
if (title == null || title.getText().length() == 0)
{
setTitle("Title");
title.edit();
}
else
{
title.setVisible(!title.isVisible());
}
}
}
private class JASHistDataArea extends DataArea
{
JASHistDataArea(Axis xAxis, Axis yAxis)
{
super(xAxis,yAxis);
}
public void modifyPopupMenu(final JPopupMenu menu, final Component source)
{
if (source == this || !(source instanceof HasPopupItems)) // Not the axis for example
{
// Begin the main histogram popup menu, with bunches of Show....
/*
menu.add(new SetTitleMenuItem());
JCheckBoxMenuItem ss = new JCheckBoxMenuItem("Show Statistics")
{
public void fireActionPerformed(ActionEvent e)
{
setShowStatistics(!getShowStatistics());
}
};
ss.setSelected(getShowStatistics());
menu.add(ss);
*/
dataManager.modifyPopupMenu(menu, source);
super.modifyPopupMenu(menu,source);
}
}
}
}
class JASEvent extends AWTEvent
{
JASEvent(Component target)
{
super(target,AWTEvent.RESERVED_ID_MAX+5000);
}
}
src/main/java/jas/hist/FitUpdate.java 0000644 0001750 0001750 00000001047 11325547132 020201 0 ustar giovanni giovanni package jas.hist;
public class FitUpdate
{
FitUpdate(int state)
{
this.state = state;
this.percent = state == Fitter.FIT ? 100 : 0;
}
FitUpdate(int state, int percent)
{
this.state = state;
this.percent = percent;
}
FitUpdate(int state, FitFailed x)
{
this.state = state;
this.percent = 0;
this.reason = x;
}
public int getState()
{
return state;
}
public int getPercent()
{
return percent;
}
public FitFailed getReason()
{
return reason;
}
private int state;
private int percent;
private FitFailed reason;
}
src/main/java/jas/hist/DoubleScatterDataManager.java 0000644 0001750 0001750 00000002326 11325547132 023142 0 ustar giovanni giovanni package jas.hist;
import jas.plot.DataArea;
import jas.plot.DoubleAxis;
import jas.plot.Legend;
final class DoubleScatterDataManager extends ScatterDataManager
{
DoubleScatterDataManager(JASHist plot, final DataArea da, final Legend l, StatisticsBlock stats)
{
super(plot, da, l, stats);
// Configure the Axes
if (xm.getType() instanceof DoubleAxis)
xAxisType = (DoubleAxis) xm.getType();
else
{
xAxisType = new DoubleAxis();
xm.setType(xAxisType);
}
DoubleAxis yAxisType;
if (ym[0].getType() instanceof DoubleAxis)
yAxisType = (DoubleAxis) ym[0].getType();
else
{
yAxisType = new DoubleAxis();
ym[0].setType(yAxisType);
}
xm.setDataManager(this, false, xAxisType);
ym[0].setDataManager(this, false, yAxisType);
}
final protected void calcXMinMax(double x1, double x2)
{
final double oldXMin = xAxisType.getPlotMin();
final double oldXMax = xAxisType.getPlotMax();
// Only update the axis if the new range is outside of the old range,
// or occupies less than 75% of the old range
if (x1 < oldXMin || x2 > oldXMax || (x2 - x1) / (oldXMax - oldXMin) < 0.75)
{
xAxisType.setMin(x1);
xAxisType.setMax(x2);
xm.invalidate();
}
}
private DoubleAxis xAxisType;
}
src/main/java/jas/hist/DataRenderer.java 0000644 0001750 0001750 00000001570 11325547132 020655 0 ustar giovanni giovanni package jas.hist;
import java.awt.Color;
import java.awt.Component;
import javax.swing.DefaultListCellRenderer;
import javax.swing.JList;
final class DataRenderer extends DefaultListCellRenderer
{
public Component getListCellRendererComponent(
JList list,
Object value,
int index,
boolean isSelected,
boolean cellHasFocus)
{
String s;
if (value instanceof Rebinnable1DHistogramData)
{
s = ((Rebinnable1DHistogramData) value).getTitle();
}
else s = value.toString();
return super.getListCellRendererComponent(list,s,index,isSelected,cellHasFocus);
}
static DataRenderer createRenderer()
{
if (singleton == null) singleton = new DataRenderer();
return singleton;
}
private static DataRenderer singleton = null;
private Color f = getForeground();
private Color b = getBackground();
}
src/main/java/jas/hist/DoubleDataManager.java 0000644 0001750 0001750 00000003112 11325547132 021606 0 ustar giovanni giovanni package jas.hist;
import jas.plot.DataArea;
import jas.plot.DoubleAxis;
import jas.plot.Legend;
import java.io.IOException;
import java.io.ObjectInputStream;
class DoubleDataManager extends BinnedDataManager
{
DoubleDataManager(JASHist plot, DataArea da, Legend l, StatisticsBlock stats, int bins)
{
super(plot,da,l,stats,bins);
// Configure the Axes
xAxis = new DoubleAxis();
DoubleAxis yAxis = new DoubleAxis();
yAxis.setUseSuggestedRange(true);
xm.setDataManager(this,true, xAxis);
ym[0].setDataManager(this,false,yAxis);
new DoubleAxisListener(xm);
xm.setBins(bins);
}
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException
{
in.defaultReadObject();
new DoubleAxisListener(xm);
}
final JASHistData add(DataSource data)
{
if (data instanceof Rebinnable1DHistogramData)
{
Rebinnable1DHistogramData d = (Rebinnable1DHistogramData) data;
// We only support adding items with continuous axes
if (d.getAxisType() != d.DOUBLE) throw new DataManagerException("Incompatible data type for axis");
}
else
{
XYDataSource d = (XYDataSource) data;
if (d.getAxisType() != d.DOUBLE) throw new DataManagerException("Incompatible data type for axis");
}
return super.add(data);
}
final protected void calcMinMaxBins(double x1, double x2)
{
double oldXMin = xAxis.getPlotMin();
double oldXMax = xAxis.getPlotMax();
if (x1 != oldXMin || x2 != oldXMax)
{
xAxis.setMin(x1);
xAxis.setMax(x2);
xm.invalidate();
}
}
private DoubleAxis xAxis;
}
src/main/java/jas/hist/FitFailed.java 0000644 0001750 0001750 00000000156 11325547132 020143 0 ustar giovanni giovanni package jas.hist;
public class FitFailed extends Exception
{
public FitFailed(String s)
{
super(s);
}
}
src/main/java/jas/hist/DateTransformationConverter.java 0000644 0001750 0001750 00000001166 11325547132 024012 0 ustar giovanni giovanni package jas.hist;
import jas.plot.DateCoordinateTransformation;
import jas.plot.DoubleCoordinateTransformation;
class DateTransformationConverter implements DoubleCoordinateTransformation
{
private DateCoordinateTransformation source;
DateTransformationConverter(DateCoordinateTransformation source)
{
this.source = source;
}
public double convert(double d)
{
return source.convert((long) (d*1000));
}
public double unConvert(double i)
{
return source.map(i)/1000.;
}
public double getPlotMin()
{
return source.getAxisMin()/1000.;
}
public double getPlotMax()
{
return source.getAxisMax()/1000.;
}
}
src/main/java/jas/hist/Rebinnable1DVariableHistogramData.java 0000644 0001750 0001750 00000000701 11325547132 024654 0 ustar giovanni giovanni package jas.hist;
/**
* Extends Rebinnable1DHistogramData interface for the case of Histogram1D
* with variable bin width
* Example: edges = (0.2, 1.0, 5.0) yields an axis with 2 in-range bins
* [0.2, 1.0), [1.0, 5.0) and 2 extra bins [-inf, 0.2), [5.0, +inf].
* @see Rebinnable1DHistogramData
*/
public interface Rebinnable1DVariableHistogramData
extends Rebinnable1DHistogramData
{
double[] getBinEdges();
}
src/main/java/jas/hist/FitterFactoryError.java 0000644 0001750 0001750 00000000171 11325547132 022110 0 ustar giovanni giovanni package jas.hist;
class FitterFactoryError extends Exception
{
public FitterFactoryError(String s)
{
super(s);
}
}
src/main/java/jas/hist/JASHist2DHistogramStyle.java 0000644 0001750 0001750 00000014462 11325547132 022653 0 ustar giovanni giovanni package jas.hist;
import java.awt.Color;
import java.io.IOException;
import java.io.Serializable;
public class JASHist2DHistogramStyle extends JASHistStyle implements Serializable
{
final public static int STYLE_BOX = 0;
final public static int STYLE_ELLIPSE = 1;
final public static int STYLE_COLORMAP = 2;
final public static int STYLE_3DLEGOPLOT = 3;
final public static int STYLE_3DSURFACEPLOT = 4;
final public static int COLORMAP_WARM = 0;
final public static int COLORMAP_COOL = 1;
final public static int COLORMAP_THERMAL = 2;
final public static int COLORMAP_RAINBOW = 3;
final public static int COLORMAP_GRAYSCALE = 4;
final public static int COLORMAP_USERDEFINED = 5;
static final Color[] lineColors =
{
Color.blue, Color.red, Color.darkGray, new Color(0,145,0)
};
static final Color[] overflowColors = new Color[lineColors.length];
static
{
for (int i=0; i.oht topics file for the specified book)
*/
public ErrorBox(JFrame parent, String message, String helpTopic)
{
this(parent, message, null, helpTopic);
}
/**
* Opens an ErrorBox that displays a Throwable, but has no help button. Book objects
* are accessible through static constants in the Application class.
* @see Application
* @param parent the parent JFrame
* @param message a String to display as a message
* @param throwable the Error or Exception that was generated
*/
public ErrorBox(JFrame parent, String message, Throwable throwable)
{
this(parent,message,throwable,null);
}
/**
* Opens an ErrorBox that displays a Throwable and has a Help button
* that opens the specified topic. Book objects are available through
* the Application class.
* @see Application
* @param parent the parent JFrame
* @param message a String to display as a message
* @param throwable the Error or Exception that was generated
* @param helpTopic the help topic (XML target)
*/
public ErrorBox(JFrame parent, String message, Throwable throwable, String helpTopic)
{
super(parent, "Error...", true, OK_BUTTON |
(throwable != null ? APPLY_BUTTON | CANCEL_BUTTON : 0) |
(helpTopic != null ? HELP_BUTTON : 0));
if (helpTopic != null) setHelpTopic(helpTopic);
init(message, throwable,parent);
}
private void init(String m, Throwable t,JFrame parent)
{
setApplyLabel("Details");
setApplyMnemonic('D');
setCancelLabel("Traceback");
setCancelMnemonic('T');
JPanel p = new JPanel();
p.add(new JLabel(UIManager.getIcon("OptionPane.errorIcon")));
p.add(new JLabel(m));
getContentPane().add(p,BorderLayout.NORTH);
m_frame = parent;
m_throw = t;
m_details = (t != null);
pack();
getToolkit().beep();
}
/** Inherited from JASDialog; do not call. */
final protected void enableApply(JASState state)
{
state.setEnabled(m_details);
}
/** Inherited from JASDialog; do not call. */
final protected void onCancel()
{
// We used to use a JASDialog here, but it needs a Frame as its parent.
// This cannot be fixed while maintaining JDK 1.1 compatibility, so instead
// we swicthed to using a JOptionPane.
JTextArea ta = new JTextArea();
PrintWriter pw = new PrintWriter(new DocumentOutputStream(ta.getDocument()));
m_throw.printStackTrace(pw);
pw.close();
ta.setEditable(false);
ta.addMouseListener(new PopupListener(new PopupMenu(ta)));
JScrollPane scroll = new JScrollPane(ta);
scroll.setPreferredSize(new Dimension(500,300));
JOptionPane.showMessageDialog(this,scroll,"Traceback...",JOptionPane.PLAIN_MESSAGE);
}
/** Inherited from JASDialog; do not call. */
final protected void onApply()
{
JTextArea text = new JTextArea(m_throw.toString());
text.setEditable(false);
text.addMouseListener(new PopupListener(new PopupMenu(text)));
JScrollPane scroll = new JScrollPane();
scroll.setViewportView(text);
getContentPane().add(scroll,BorderLayout.CENTER);
pack();
m_details = false;
callEnable();
}
private static class PopupMenu extends OnScreenPopupMenu implements ActionListener
{
private JTextArea parent;
JMenuItem copy = new JMenuItem("Copy",'C');
JMenuItem select = new JMenuItem("Select All",'S');
PopupMenu(JTextArea parent)
{
this.parent = parent;
copy.addActionListener(this);
select.addActionListener(this);
add(copy);
add(select);
}
public void actionPerformed(ActionEvent e)
{
Object source = e.getSource();
if (source == select) parent.selectAll();
else if (source == copy) parent.copy();
}
}
private static class PopupListener extends MouseAdapter
{
private JPopupMenu menu;
PopupListener(JPopupMenu menu)
{
this.menu = menu;
}
public void mouseReleased(MouseEvent me)
{
maybePopup(me);
}
public void mousePressed(MouseEvent me)
{
maybePopup(me);
}
private void maybePopup(MouseEvent me)
{
if (menu.isPopupTrigger(me)) menu.show(me.getComponent(),me.getX(),me.getY());
}
}
private Throwable m_throw;
private boolean m_details;
private JFrame m_frame;
} src/main/java/jas/util/JASIcon.java 0000644 0001750 0001750 00000013615 11325547132 017554 0 ustar giovanni giovanni package jas.util;
import java.awt.Image;
import java.awt.Toolkit;
import java.io.IOException;
import java.io.InputStream;
import java.util.Hashtable;
import javax.swing.ImageIcon;
/**
* A convenience class for creating small icons where the source file is stored in the
* CLASSPATH of the application, typically in the same JAR file as the class creating the
* image
*
* @author Tony Johnson
*/
public class JASIcon extends ImageIcon
{
/**
* Create a JASIcon, for use within the jas.util package
* The file is interpreted to be relative to jas.util
*/
JASIcon(String file) throws ImageException
{
this(null,file);
}
/**
* Create a JASIcon from the CLASSPATH.
* @param obj The object used as the root of the file path
* @param file The path to the image source file, relative to obj
* @exception ImageException Thrown if the image source file can not be found
* @see #create(Object obj, String file)
*/
public JASIcon(Object obj,String file) throws ImageException
{
this(obj == null ? null : obj.getClass(),file);
}
/**
* Create a JASIcon from the CLASSPATH.
* @param c The class used as the root of the file path
* @param file The path to the image source file, relative to the root class
* @exception ImageException Thrown if the image source file can not be found
* @see #create(Object c, String file)
*/
public JASIcon(Class c, String file) throws ImageException
{
m_c = c == null ? JASIcon.class : c;
setImageImpl(file);
}
/**
* Create a JASIcon without specifing the source
* @param Class c The class used as the root of the file path when setImage is called
* @see #setImage(String file)
*/
public JASIcon(Class c)
{
m_c = c == null ? JASIcon.class : c;
}
/**
* This method sets the image of the JASIcon to be that referenced by file.
* The image will display as "broken" if the file can not be found, no exception is thrown
* @param file The path to the image source file, relative to the root class
*
*/
public void setImage(String file)
{
try
{
setImageImpl(file);
}
catch (ImageException x)
{
setImage(brokenIcon.getImage());
}
}
private void setImageImpl(String file) throws ImageException
{
m_file = file;
Image image = (Image) imageCache.get(this);
if (image == null)
{
try
{
// First try getting a URL for the image, and loading the image using the URL.
java.net.URL url = m_c.getResource(file);
if (url != null)
{
image = Toolkit.getDefaultToolkit().getImage(url);
}
// Some classloaders (notably our own custom class loader for JAR files) cannot
// return a resource URL but can return the resource as an InputStream, so....
else
{
byte[] data = this.getImageBytes(m_c,m_file);
if (data == null) throw new ImageException();
image = Toolkit.getDefaultToolkit().createImage(data);
}
imageCache.put(this,image);
}
catch (ImageException x)
{
imageCache.put(this,noImage);
throw x;
}
}
else if (image == noImage) throw new ImageException();
setImage(image);
}
/**
* Read a string of byes from a file.
* We do this to work around a limitation in our custom class loader which results in them
* being able to suport getResourceAsStream but not getResource
* @see jas.loader.ClassPathLoader#getResource
*/
private byte[] getImageBytes(Class c, String file) throws ImageException
{
try
{
//System.out.println("JASIcon: Using fallback method of loading image "+file);
InputStream stream = c.getResourceAsStream(file);
if (stream == null) return null;
//TODO: There is no realiable way to tell how many bytes are in the stream
// so we have this horrible hack here.
byte[] result = new byte[Math.min(10000,stream.available())];
int size = 0;
for (;;)
{
if (size == result.length) throw new ImageException("Image too big for buffer");
int rc = stream.read(result,result.length-size,size);
if (rc<=0) break;
size += rc;
}
stream.close();
return result;
}
catch (IOException x)
{
return null;
}
}
/**
* Override Objects hashCode method
*/
public int hashCode()
{
return m_file.hashCode() + m_c.hashCode();
}
/**
* Override Objects equals method. Two images are considered equal if they have the same
* class and file.
*/
public boolean equals(Object in)
{
if (!(in instanceof JASIcon)) return false;
JASIcon icon = (JASIcon) in;
if (icon.m_c != m_c) return false;
return icon.m_file.equals(m_file);
}
/**
* Create a JASIcon but do not throw an exception if the source cannot be found
* (just displays a "broken" icon instead)
* @param obj The object used as the root of the file path
* @param file The path to the image source file, relative to obj
* @return The resulting JASIcon
*/
public static JASIcon create(Object obj,String file)
{
try
{
return new JASIcon(obj,file);
}
catch (ImageException x)
{
return brokenIcon;
}
}
/**
* Create a JASIcon but do not throw an exception if the source cannot be found
* (just displays a "broken" icon instead)
* //TODO: Should create return a cached version of the JASIcon, instead of a cached
* // version of the image with a new JASIcon object?
* @param obj The class used as the root of the file path
* @param file The path to the image source file, relative to obj
* @return The resulting JASIcon
*/
public static JASIcon create(Class c,String file)
{
try
{
return new JASIcon(c,file);
}
catch (ImageException x)
{
return brokenIcon;
}
}
private Class m_c;
private String m_file;
private static Hashtable imageCache = new Hashtable();
private static JASIcon brokenIcon;
private static Image noImage; // Used to flag non existent image in cache
static
{
try
{
brokenIcon = new JASIcon("brokenIcon.gif");
noImage = brokenIcon.getImage();
}
catch (ImageException x)
{
System.err.println("Could not load brokenIcon .. this looks bad!");
}
}
}
src/main/java/jas/util/gui/ 0000755 0001750 0001750 00000000000 11325547132 016241 5 ustar giovanni giovanni src/main/java/jas/util/gui/JDirectoryChooser.java 0000644 0001750 0001750 00000033772 11325547132 022521 0 ustar giovanni giovanni package jas.util.gui;
import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.Cursor;
import java.awt.FlowLayout;
import java.awt.Frame;
import java.awt.Window;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.File;
import java.util.Vector;
import javax.swing.JButton;
import javax.swing.JComponent;
import javax.swing.JDialog;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextField;
import javax.swing.JTree;
import javax.swing.SwingUtilities;
import javax.swing.event.EventListenerList;
import javax.swing.event.TreeModelEvent;
import javax.swing.event.TreeModelListener;
import javax.swing.event.TreeSelectionEvent;
import javax.swing.event.TreeSelectionListener;
import javax.swing.filechooser.FileFilter;
import javax.swing.filechooser.FileSystemView;
import javax.swing.filechooser.FileView;
import javax.swing.tree.DefaultTreeCellRenderer;
import javax.swing.tree.TreeModel;
import javax.swing.tree.TreePath;
import javax.swing.tree.TreeSelectionModel;
/**
* A class which allows a user to select directories or files, similar to JFileChooser,
* except that it display files as a tree, and is better suited to selecting directories
* than the current file chooser (see java bug id 4239219).
*
* TODO: Understand issue with moving mouse between double clicks
* (seems like MOUSE_PRESSED and MOUSE_RELEASED events are generated, but not MOUSE_CLICKED)
* See Bug ID 4218549
*
* @author Tony Johnson (tony_johnson@slac.stanford.edu)
*/
public class JDirectoryChooser extends JComponent
{
/**
* Create a JDirectoryChooser with the default FileSystemView
*/
public JDirectoryChooser()
{
this(FileSystemView.getFileSystemView());
}
/**
* Create a JDirectoryChooser with the default FileSystemView
* @param currentDirectory The directory to which the tree is initially set
*/
public JDirectoryChooser(File currentDirectory)
{
this();
setCurrentDirectory(currentDirectory);
}
/**
* Create a JDirectoryChooser with the default FileSystemView
* @param currentDirectory The directory to which the tree is initially set
*/
public JDirectoryChooser(String currentDirectory)
{
this();
if (currentDirectory != null) setCurrentDirectory(new File(currentDirectory));
}
/**
* Create a JDirectoryChooser
* @param currentDirectory The directory to which the tree is initially set
* @param view The FileSystemView to use
*/
public JDirectoryChooser(File currentDirectory, FileSystemView view)
{
this(view);
setCurrentDirectory(currentDirectory);
}
/**
* Create a JDirectoryChooser
* @param currentDirectory The directory to which the tree is initially set
* @param view The FileSystemView to use
*/
public JDirectoryChooser(String currentDirectory, FileSystemView view)
{
this(view);
setCurrentDirectory(new File(currentDirectory));
}
/**
* Create a JDirectoryChooser
* @param view The FileSystemView to use
*/
public JDirectoryChooser(FileSystemView view)
{
setup(view);
ButtonListener al = new ButtonListener();
tree = new JTree();
tree.setRootVisible(false);
tree.setShowsRootHandles(true);
tree.setCellRenderer(new FileRenderer());
tree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
tree.addTreeSelectionListener(al);
approve.addActionListener(al);
cancel.addActionListener(al);
approve.setEnabled(false);
setLayout(new BorderLayout());
add(new JScrollPane(tree));
JPanel p = new JPanel(new FlowLayout());
p.add(approve);
p.add(cancel);
add(p,BorderLayout.SOUTH);
}
public void addNotify()
{
tree.setModel(model);
makeCurrentDirectoryVisible();
super.addNotify();
}
private void makeCurrentDirectoryVisible()
{
if (currentDirectory != null)
{
File dir = currentDirectory;
FileSystemView view = foo.getFileSystemView();
Vector v = new Vector();
while (true)
{
if (dir == null) return; // Something wrong, ignore dir
v.addElement(dir);
if (view.isRoot(dir)) break;
dir = view.getParentDirectory(dir);
}
Object[] files = new File[v.size()+1];
Object node = model.getRoot();
files[0] = node;
for (int i=1; iflags
* parameter. For example,JASDialog.OK_BUTTON | JASDialog.CANCEL_BUTTON | JASDialog.HELP_BUTTONflags parameter will create a button
* that has an OK button, a Cancel button, and a Help button.
* @param dlg the parent Dialog
* @param title the title for the dialog box
* @param modal whether the dialog box is modal
* @param flags option flags
*/
public JASDialog(Frame f,String t,boolean modal,int flags)
{
super(f,t,modal);
init(f,flags);
}
/**
* Creates a modal dialog with OK and Cancel buttons.
* @param frame the parent frame
* @param title the title for the dialog box
*/
public JASDialog(Dialog dlg, String title)
{
this(dlg, title, true, OK_BUTTON | CANCEL_BUTTON);
}
/**
* Creates a dialog with OK and Cancel buttons.
* @param dlg the parent Dialog
* @param title the title for the dialog box
* @param modal whether the dialog box is modal
*/
public JASDialog(Dialog dlg, String title, boolean modal)
{
this(dlg, title, modal, OK_BUTTON | CANCEL_BUTTON);
}
/**
* Creates a dialog box with any combination of buttons. Use bitwise
* logic to specify the appropriate flags in the flags
* parameter. For example,JASDialog.OK_BUTTON | JASDialog.CANCEL_BUTTON | JASDialog.HELP_BUTTONflags parameter will create a button
* that has an OK button, a Cancel button, and a Help button.
* @param dlg the parent Dialog
* @param title the title for the dialog box
* @param modal whether the dialog box is modal
* @param flags option flags
*/
public JASDialog(Dialog dlg,String t,boolean modal,int flags)
{
super(dlg,t,modal);
init(dlg,flags);
}
private void init(Window w, int flags)
{
m_window = w;
m_flags = flags;
ActionListener l = new ActionEventHandler();
m_ok = new JButton("OK");
m_ok.addActionListener(l);
m_ok.setMnemonic('O');
m_apply = new JButton("Apply");
m_apply.setMnemonic('A');
m_apply.addActionListener(l);
m_cancel = new JButton("Cancel");
m_cancel.setMnemonic('C');
m_cancel.addActionListener(l);
m_help = new JButton("Help");
m_help.setMnemonic('H');
m_help.addActionListener(l);
m_buttonPanel = new JPanel();
super.getContentPane().add(m_buttonPanel,BorderLayout.SOUTH);
enableEvents(AWTEvent.WINDOW_EVENT_MASK);
JPanel p = new JPanel(new BorderLayout());
p.setBorder(BorderFactory.createEmptyBorder(5,5,5,5));
super.getContentPane().add(p,BorderLayout.CENTER);
m_contentPane = p;
}
/**
* Causes a default pack(), but also places the dialog in the center
* of the parent frame.
* @see java.awt.Window#pack()
*/
public void pack()
{
defaultPack();
setLocationRelativeTo(m_window);
}
/** Causes default pack; does not move dialog. */
public void defaultPack()
{
if (m_buttonPanel.getComponentCount() == 0)
{
if ((m_flags & OK_BUTTON) !=0) m_buttonPanel.add(m_ok);
if ((m_flags & APPLY_BUTTON) !=0) m_buttonPanel.add(m_apply);
if ((m_flags & CANCEL_BUTTON) !=0) m_buttonPanel.add(m_cancel);
if ((m_flags & HELP_BUTTON) !=0) m_buttonPanel.add(m_help);
}
super.pack();
}
/** This method is public as an implementation side effect; do not call or override. */
public void processEvent(AWTEvent e)
{
if (e.getID() == WindowEvent.WINDOW_CLOSING) onCancel();
super.processEvent(e);
}
/**
* Forces a modal display of the dialog box
* @return true if the OK button was pushed, otherwise false
*/
public boolean doModal()
{
m_result = false;
setModal(true);
show();
return m_result;
}
public void show()
{
callEnable();
if (isModal() && app != null) app.modalDialogOpening(this);
super.show();
if (isModal() && app != null) app.modalDialogClosing(this);
}
/**
* Set the label on the OK button. Allows for
* customized button labels.
*/
public void setOKLabel(String label)
{
m_ok.setText(label);
}
/**
* Sets the mnnemonic (or keyboard shortcut) for the
* OK button. If you have changed the label
* using setOKLabel(String) the default
* mnemonic ('O') may not be appropriate, so use
* this method to set a better one.
* @param mnemonic the new key shortcut to use
* @see JASDialog#setOKLabel(String)
*/
public void setOKMnemonic(char mnemonic)
{
m_ok.setMnemonic(mnemonic);
}
/**
* Set the label on the Cancel button. Allows for
* customized button labels.
*/
public void setCancelLabel(String label)
{
m_cancel.setText(label);
}
/**
* Sets the mnnemonic (or keyboard shortcut) for the
* Cancel button. If you have changed the label
* using setCancelLabel(String) the default
* mnemonic ('C') may not be appropriate, so use
* this method to set a better one.
* @param mnemonic the new key shortcut to use
* @see JASDialog#setCancelLabel(String)
*/
public void setCancelMnemonic(char mnemonic)
{
m_cancel.setMnemonic(mnemonic);
}
/**
* Set the label on the Apply button. Allows for
* customized button labels.
*/
public void setApplyLabel(String label)
{
m_apply.setText(label);
}
/**
* Sets the mnnemonic (or keyboard shortcut) for the
* Apply button. If you have changed the label
* using setApplyLabel(String) the default
* mnemonic ('A') may not be appropriate, so use
* this method to set a better one.
* @param mnemonic the new key shortcut to use
* @see JASDialog#setApplyLabel(String)
*/
public void setApplyMnemonic(char mnemonic)
{
m_apply.setMnemonic(mnemonic);
}
/**
* Called when the OK button is pushed. Override to provide customized
* functionality for derived dialog boxes.
*/
protected void onOK()
{
m_result = true;
dispose();
}
/**
* Called when the Cancel button is pushed. Override to provide customized
* functionality for derived dialog boxes.
*/
protected void onCancel()
{
dispose();
}
/**
* Called when the Apply button is pushed. Override to provide customized
* functionality for derived dialog boxes.
*/
protected void onApply()
{
}
/** Forces the dialog to re-evaluate button enabling. */
protected void callEnable()
{
if (m_ok != null)
{
enableOK(new ButtonState(m_ok));
getRootPane().setDefaultButton(m_ok);
}
if (m_apply != null) enableApply(new ButtonState(m_apply));
if (m_help != null) enableHelp(new ButtonState(m_help));
}
/**
* Override to customize when OK is enabled. OK is enabled by
* default.
*/
protected void enableOK(JASState state)
{
}
/**
* Override to customize when Help is enabled. By default, Help
* is enabled if both a help book and help topic have been set.
* @see JASDialog#setHelpTopic(String)
*/
protected void enableHelp(JASState state)
{
state.setEnabled(m_helpTopic != null);
}
/**
* Override to customize when Apply is enabled. By default,
* Apply is disenabled.
*/
protected void enableApply(JASState state)
{
state.setEnabled(false);
}
/**
* Returns the content pane for the JASDialog, which is the
* panel (not including the buttons) where components can be
* added. Add components to this container to have them appear
* in the dialog.
*/
public Container getContentPane()
{
return m_contentPane;
}
/**
* Sets the content pane. The buttons are not members of this
* content pane.
*/
public void setContentPane(Container c)
{
m_contentPane = c;
super.getContentPane().add(m_contentPane,BorderLayout.CENTER);
}
/**
* Sets the name for the help topic that the Help button opens.
* Note: This is now being used to set the XML target for JavaHelp.
*/
public final void setHelpTopic(String topic)
{
m_flags |= HELP_BUTTON;
m_helpTopic = topic;
}
private void onHelp()
{
Application.getApplication().showHelpTopic(m_helpTopic,this);
}
private class ActionEventHandler implements ActionListener
{
public void actionPerformed(ActionEvent e)
{
Object source = e.getSource();
if (source == m_ok) onOK();
else if (source == m_apply) onApply();
else if (source == m_cancel) onCancel();
else if (source == m_help) onHelp();
}
}
private class ButtonState implements JASState
{
ButtonState(JButton b)
{
m_button = b;
}
public void setEnabled(boolean state)
{
m_button.setEnabled(state);
}
private JButton m_button;
}
/**
* Does nothing by default. To use this class as a MouseListener,
* override only the method(s) you need.
*/
public void mouseClicked(MouseEvent e){}
/**
* Does nothing by default. To use this class as a MouseListener,
* override only the method(s) you need.
*/
public void mousePressed(MouseEvent e){}
/**
* Does nothing by default. To use this class as a MouseListener,
* override only the method(s) you need.
*/
public void mouseReleased(MouseEvent e){}
/**
* Does nothing by default. To use this class as a MouseListener,
* override only the method(s) you need.
*/
public void mouseEntered(MouseEvent e){}
/**
* Does nothing by default. To use this class as a MouseListener,
* override only the method(s) you need.
*/
public void mouseExited(MouseEvent e){}
// Implements DocumentListener as a convenience to subclasses so
// that they only need to overload the desired functions
/**
* Calls callEnable() by default. To use this class
* as a DocumentListener, override only the method(s) you need.
* @see JASDialog#callEnable()
*/
public void insertUpdate(DocumentEvent e){callEnable();}
/**
* Calls callEnable() by default. To use this class
* as a DocumentListener, override only the method(s) you need.
* @see JASDialog#callEnable()
*/
public void removeUpdate(DocumentEvent e){callEnable();}
/**
* Calls callEnable() by default. To use this class
* as a DocumentListener, override only the method(s) you need.
* @see JASDialog#callEnable()
*/
public void changedUpdate(DocumentEvent e){callEnable();}
private Application app = Application.getApplication();
private String m_helpTopic = null;
private int m_flags;
private JPanel m_buttonPanel;
private JButton m_ok;
private JButton m_cancel;
private JButton m_apply;
private JButton m_help;
private boolean m_result;
private Window m_window;
private Container m_contentPane;
}
src/main/java/jas/util/DocumentOutputStream.java 0000644 0001750 0001750 00000005145 11325547132 022500 0 ustar giovanni giovanni package jas.util;
import java.io.IOException;
import java.io.OutputStream;
import javax.swing.text.AttributeSet;
import javax.swing.text.BadLocationException;
import javax.swing.text.Document;
/**
* An OutputStream implementation that places it's
* output in a swing text model (Document). The
* Document can be either a plain text or styled
* document implementation. If styled, the attributes
* assigned to the output stream will be used in
* the display of the output.
*
* @author Timothy Prinzing
* @version 1.1 02/05/99
*/
public class DocumentOutputStream extends OutputStream {
/**
* Constructs an output stream that will output to the
* given document with the given set of character attributes.
*
* @param doc the document to write to.
* @param a the character attributes to use for the written
* text.
*/
public DocumentOutputStream(Document doc, AttributeSet a) {
this.doc = doc;
this.a = a;
}
/**
* Constructs an output stream that will output to the
* given document with whatever the default attributes
* are.
*
* @param doc the document to write to.
*/
public DocumentOutputStream(Document doc) {
this(doc, null);
}
/**
* Writes the specified byte to this output stream.
*
* Subclasses of OutputStream must provide an
* implementation for this method.
*
* @param b the byte.
* @exception IOException if an I/O error occurs.
* @since JDK1.0
*/
public void write(int b) throws IOException {
one[0] = (byte) b;
write(one, 0, 1);
}
/**
* Writes len bytes from the specified byte array
* starting at offset off to this output stream.
*
* The
// A framework for classes that encode and write out an image in
// a particular file format.
//
// This provides a simplified rendition of the ImageConsumer interface.
// It always delivers the pixels as ints in the RGBdefault color model.
// It always provides them in top-down left-right order.
// If you want more flexibility you can always implement ImageConsumer
// directly.
//
// Fetch the software.
// @see GifEncoder
// @see PpmEncoder
// @see Acme.JPM.Decoders.ImageDecoder
public abstract class ImageEncoder implements ImageConsumer
{
protected OutputStream out;
private ImageProducer producer;
private int width = -1;
private int height = -1;
private int hintflags = 0;
private boolean started = false;
private boolean encoding;
private IOException iox;
private static final ColorModel rgbModel = ColorModel.getRGBdefault();
private Hashtable props = null;
/// Constructor.
// @param img The image to encode.
// @param out The stream to write the bytes to.
public ImageEncoder( Image img, OutputStream out ) throws IOException
{
this( img.getSource(), out );
}
/// Constructor.
// @param producer The ImageProducer to encode.
// @param out The stream to write the bytes to.
public ImageEncoder( ImageProducer producer, OutputStream out ) throws IOException
{
this.producer = producer;
this.out = out;
}
// Methods that subclasses implement.
/// Subclasses implement this to initialize an encoding.
abstract void encodeStart( int w, int h ) throws IOException;
/// Subclasses implement this to actually write out some bits. They
// are guaranteed to be delivered in top-down-left-right order.
// One int per pixel, index is row * scansize + off + col,
// RGBdefault (AARRGGBB) color model.
abstract void encodePixels(
int x, int y, int w, int h, int[] rgbPixels, int off, int scansize )
throws IOException;
/// Subclasses implement this to finish an encoding.
abstract void encodeDone() throws IOException;
// Our own methods.
/// Call this after initialization to get things going.
public synchronized void encode() throws IOException
{
encoding = true;
iox = null;
producer.startProduction( this );
while ( encoding )
try
{
wait();
}
catch ( InterruptedException e ) {}
if ( iox != null )
throw iox;
}
private boolean accumulate = false;
private int[] accumulator;
private void encodePixelsWrapper(
int x, int y, int w, int h, int[] rgbPixels, int off, int scansize )
throws IOException
{
if ( ! started )
{
started = true;
encodeStart( width, height );
if ( ( hintflags & TOPDOWNLEFTRIGHT ) == 0 )
{
accumulate = true;
accumulator = new int[width * height];
}
}
if ( accumulate )
for ( int row = 0; row < h; ++row )
System.arraycopy(
rgbPixels, row * scansize + off,
accumulator, ( y + row ) * width + x,
w );
else
encodePixels( x, y, w, h, rgbPixels, off, scansize );
}
private void encodeFinish() throws IOException
{
if ( accumulate )
{
encodePixels( 0, 0, width, height, accumulator, 0, width );
accumulator = null;
accumulate = false;
}
}
private synchronized void stop()
{
encoding = false;
notifyAll();
}
// Methods from ImageConsumer.
public void setDimensions( int width, int height )
{
this.width = width;
this.height = height;
}
public void setProperties( Hashtable props )
{
this.props = props;
}
public void setColorModel( ColorModel model )
{
// Ignore.
}
public void setHints( int hintflags )
{
this.hintflags = hintflags;
}
public void setPixels(
int x, int y, int w, int h, ColorModel model, byte[] pixels,
int off, int scansize )
{
int[] rgbPixels = new int[w];
for ( int row = 0; row < h; ++row )
{
int rowOff = off + row * scansize;
for ( int col = 0; col < w; ++col )
rgbPixels[col] = model.getRGB( pixels[rowOff + col] & 0xff );
try
{
encodePixelsWrapper( x, y + row, w, 1, rgbPixels, 0, w );
}
catch ( IOException e )
{
iox = e;
stop();
return;
}
}
}
public void setPixels(
int x, int y, int w, int h, ColorModel model, int[] pixels,
int off, int scansize )
{
if ( model == rgbModel )
{
try
{
encodePixelsWrapper( x, y, w, h, pixels, off, scansize );
}
catch ( IOException e )
{
iox = e;
stop();
return;
}
}
else
{
int[] rgbPixels = new int[w];
for ( int row = 0; row < h; ++row )
{
int rowOff = off + row * scansize;
for ( int col = 0; col < w; ++col )
rgbPixels[col] = model.getRGB( pixels[rowOff + col] );
try
{
encodePixelsWrapper( x, y + row, w, 1, rgbPixels, 0, w );
}
catch ( IOException e )
{
iox = e;
stop();
return;
}
}
}
}
public void imageComplete( int status )
{
producer.removeConsumer( this );
if ( status == ImageConsumer.IMAGEABORTED )
iox = new IOException( "image aborted" );
else
{
try
{
encodeFinish();
encodeDone();
}
catch ( IOException e )
{
iox = e;
}
}
stop();
}
}
src/main/java/jas/util/encoder/IntHashtable.java 0000644 0001750 0001750 00000025640 11325547132 022314 0 ustar giovanni giovanni // IntHashtable - a Hashtable that uses ints as the keys
//
// This is 90% based on JavaSoft's java.util.Hashtable.
//
// Visit the ACME Labs Java page for up-to-date versions of this and other
// fine Java utilities: http://www.acme.com/java/
package jas.util.encoder;
import java.util.Dictionary;
import java.util.Enumeration;
import java.util.NoSuchElementException;
/// A Hashtable that uses ints as the keys.
//
// Use just like java.util.Hashtable, except that the keys must be ints.
// This is much faster than creating a new Integer for each access.
//
// Fetch the software.
// @see java.util.Hashtable
public class IntHashtable extends Dictionary implements Cloneable
{
/// The hash table data.
private IntHashtableEntry table[];
/// The total number of entries in the hash table.
private int count;
/// Rehashes the table when count exceeds this threshold.
private int threshold;
/// The load factor for the hashtable.
private float loadFactor;
/// Constructs a new, empty hashtable with the specified initial
// capacity and the specified load factor.
// @param initialCapacity the initial number of buckets
// @param loadFactor a number between 0.0 and 1.0, it defines
// the threshold for rehashing the hashtable into
// a bigger one.
// @exception IllegalArgumentException If the initial capacity
// is less than or equal to zero.
// @exception IllegalArgumentException If the load factor is
// less than or equal to zero.
public IntHashtable( int initialCapacity, float loadFactor )
{
if ( initialCapacity <= 0 || loadFactor <= 0.0 )
throw new IllegalArgumentException();
this.loadFactor = loadFactor;
table = new IntHashtableEntry[initialCapacity];
threshold = (int) ( initialCapacity * loadFactor );
}
/// Constructs a new, empty hashtable with the specified initial
// capacity.
// @param initialCapacity the initial number of buckets
public IntHashtable( int initialCapacity )
{
this( initialCapacity, 0.75f );
}
/// Constructs a new, empty hashtable. A default capacity and load factor
// is used. Note that the hashtable will automatically grow when it gets
// full.
public IntHashtable()
{
this( 101, 0.75f );
}
/// Returns the number of elements contained in the hashtable.
public int size()
{
return count;
}
/// Returns true if the hashtable contains no elements.
public boolean isEmpty()
{
return count == 0;
}
/// Returns an enumeration of the hashtable's keys.
// @see IntHashtable#elements
public synchronized Enumeration keys()
{
return new IntHashtableEnumerator( table, true );
}
/// Returns an enumeration of the elements. Use the Enumeration methods
// on the returned object to fetch the elements sequentially.
// @see IntHashtable#keys
public synchronized Enumeration elements()
{
return new IntHashtableEnumerator( table, false );
}
/// Returns true if the specified object is an element of the hashtable.
// This operation is more expensive than the containsKey() method.
// @param value the value that we are looking for
// @exception NullPointerException If the value being searched
// for is equal to null.
// @see IntHashtable#containsKey
public synchronized boolean contains( Object value )
{
if ( value == null )
throw new NullPointerException();
IntHashtableEntry tab[] = table;
for ( int i = tab.length ; i-- > 0 ; )
{
for ( IntHashtableEntry e = tab[i] ; e != null ; e = e.next )
{
if ( e.value.equals( value ) )
return true;
}
}
return false;
}
/// Returns true if the collection contains an element for the key.
// @param key the key that we are looking for
// @see IntHashtable#contains
public synchronized boolean containsKey( int key )
{
IntHashtableEntry tab[] = table;
int hash = key;
int index = ( hash & 0x7FFFFFFF ) % tab.length;
for ( IntHashtableEntry e = tab[index] ; e != null ; e = e.next )
{
if ( e.hash == hash && e.key == key )
return true;
}
return false;
}
/// Gets the object associated with the specified key in the
// hashtable.
// @param key the specified key
// @returns the element for the key or null if the key
// is not defined in the hash table.
// @see IntHashtable#put
public synchronized Object get( int key )
{
IntHashtableEntry tab[] = table;
int hash = key;
int index = ( hash & 0x7FFFFFFF ) % tab.length;
for ( IntHashtableEntry e = tab[index] ; e != null ; e = e.next )
{
if ( e.hash == hash && e.key == key )
return e.value;
}
return null;
}
/// A get method that takes an Object, for compatibility with
// java.util.Dictionary. The Object must be an Integer.
public Object get( Object okey )
{
if ( ! ( okey instanceof Integer ) )
throw new InternalError( "key is not an Integer" );
Integer ikey = (Integer) okey;
int key = ikey.intValue();
return get( key );
}
/// Rehashes the content of the table into a bigger table.
// This method is called automatically when the hashtable's
// size exceeds the threshold.
protected void rehash()
{
int oldCapacity = table.length;
IntHashtableEntry oldTable[] = table;
int newCapacity = oldCapacity * 2 + 1;
IntHashtableEntry newTable[] = new IntHashtableEntry[newCapacity];
threshold = (int) ( newCapacity * loadFactor );
table = newTable;
for ( int i = oldCapacity ; i-- > 0 ; )
{
for ( IntHashtableEntry old = oldTable[i] ; old != null ; )
{
IntHashtableEntry e = old;
old = old.next;
int index = ( e.hash & 0x7FFFFFFF ) % newCapacity;
e.next = newTable[index];
newTable[index] = e;
}
}
}
/// Puts the specified element into the hashtable, using the specified
// key. The element may be retrieved by doing a get() with the same key.
// The key and the element cannot be null.
// @param key the specified key in the hashtable
// @param value the specified element
// @exception NullPointerException If the value of the element
// is equal to null.
// @see IntHashtable#get
// @return the old value of the key, or null if it did not have one.
public synchronized Object put( int key, Object value )
{
// Make sure the value is not null.
if ( value == null )
throw new NullPointerException();
// Makes sure the key is not already in the hashtable.
IntHashtableEntry tab[] = table;
int hash = key;
int index = ( hash & 0x7FFFFFFF ) % tab.length;
for ( IntHashtableEntry e = tab[index] ; e != null ; e = e.next )
{
if ( e.hash == hash && e.key == key )
{
Object old = e.value;
e.value = value;
return old;
}
}
if ( count >= threshold )
{
// Rehash the table if the threshold is exceeded.
rehash();
return put( key, value );
}
// Creates the new entry.
IntHashtableEntry e = new IntHashtableEntry();
e.hash = hash;
e.key = key;
e.value = value;
e.next = tab[index];
tab[index] = e;
++count;
return null;
}
/// A put method that takes an Object, for compatibility with
// java.util.Dictionary. The Object must be an Integer.
public Object put( Object okey, Object value )
{
if ( ! ( okey instanceof Integer ) )
throw new InternalError( "key is not an Integer" );
Integer ikey = (Integer) okey;
int key = ikey.intValue();
return put( key, value );
}
/// Removes the element corresponding to the key. Does nothing if the
// key is not present.
// @param key the key that needs to be removed
// @return the value of key, or null if the key was not found.
public synchronized Object remove( int key )
{
IntHashtableEntry tab[] = table;
int hash = key;
int index = ( hash & 0x7FFFFFFF ) % tab.length;
for ( IntHashtableEntry e = tab[index], prev = null ; e != null ; prev = e, e = e.next )
{
if ( e.hash == hash && e.key == key )
{
if ( prev != null )
prev.next = e.next;
else
tab[index] = e.next;
--count;
return e.value;
}
}
return null;
}
/// A remove method that takes an Object, for compatibility with
// java.util.Dictionary. The Object must be an Integer.
public Object remove( Object okey )
{
if ( ! ( okey instanceof Integer ) )
throw new InternalError( "key is not an Integer" );
Integer ikey = (Integer) okey;
int key = ikey.intValue();
return remove( key );
}
/// Clears the hash table so that it has no more elements in it.
public synchronized void clear()
{
IntHashtableEntry tab[] = table;
for ( int index = tab.length; --index >= 0; )
tab[index] = null;
count = 0;
}
/// Creates a clone of the hashtable. A shallow copy is made,
// the keys and elements themselves are NOT cloned. This is a
// relatively expensive operation.
public synchronized Object clone()
{
try
{
IntHashtable t = (IntHashtable) super.clone();
t.table = new IntHashtableEntry[table.length];
for ( int i = table.length ; i-- > 0 ; )
t.table[i] = ( table[i] != null ) ?
(IntHashtableEntry) table[i].clone() : null;
return t;
}
catch ( CloneNotSupportedException e)
{
// This shouldn't happen, since we are Cloneable.
throw new InternalError();
}
}
/// Converts to a rather lengthy String.
public synchronized String toString()
{
int max = size() - 1;
StringBuffer buf = new StringBuffer();
Enumeration k = keys();
Enumeration e = elements();
buf.append( "{" );
for ( int i = 0; i <= max; ++i )
{
String s1 = k.nextElement().toString();
String s2 = e.nextElement().toString();
buf.append( s1 + "=" + s2 );
if ( i < max )
buf.append( ", " );
}
buf.append( "}" );
return buf.toString();
}
}
class IntHashtableEntry
{
int hash;
int key;
Object value;
IntHashtableEntry next;
protected Object clone()
{
IntHashtableEntry entry = new IntHashtableEntry();
entry.hash = hash;
entry.key = key;
entry.value = value;
entry.next = ( next != null ) ? (IntHashtableEntry) next.clone() : null;
return entry;
}
}
class IntHashtableEnumerator implements Enumeration
{
boolean keys;
int index;
IntHashtableEntry table[];
IntHashtableEntry entry;
IntHashtableEnumerator( IntHashtableEntry table[], boolean keys )
{
this.table = table;
this.keys = keys;
this.index = table.length;
}
public boolean hasMoreElements()
{
if ( entry != null )
return true;
while ( index-- > 0 )
if ( ( entry = table[index] ) != null )
return true;
return false;
}
public Object nextElement()
{
if ( entry == null )
while ( ( index-- > 0 ) && ( ( entry = table[index] ) == null ) )
;
if ( entry != null )
{
IntHashtableEntry e = entry;
entry = e.next;
return keys ? new Integer( e.key ) : e.value;
}
throw new NoSuchElementException( "IntHashtableEnumerator" );
}
}
src/main/java/jas/util/encoder/GifEncoder.java 0000644 0001750 0001750 00000042564 11325547132 021757 0 ustar giovanni giovanni // GifEncoder - write out an image as a GIF
//
// Transparency handling and variable bit size courtesy of Jack Palevich.
//
// Copyright (C)1996,1998 by Jef Poskanzer
// Fetch the software.
// @see ToGif
public class GifEncoder extends ImageEncoder
{
private boolean interlace = false;
/// Constructor from Image.
// @param img The image to encode.
// @param out The stream to write the GIF to.
public GifEncoder( Image img, OutputStream out ) throws IOException
{
super( img, out );
}
/// Constructor from Image with interlace setting.
// @param img The image to encode.
// @param out The stream to write the GIF to.
// @param interlace Whether to interlace.
public GifEncoder( Image img, OutputStream out, boolean interlace ) throws IOException
{
super( img, out );
this.interlace = interlace;
}
/// Constructor from ImageProducer.
// @param prod The ImageProducer to encode.
// @param out The stream to write the GIF to.
public GifEncoder( ImageProducer prod, OutputStream out ) throws IOException
{
super( prod, out );
}
/// Constructor from ImageProducer with interlace setting.
// @param prod The ImageProducer to encode.
// @param out The stream to write the GIF to.
public GifEncoder( ImageProducer prod, OutputStream out, boolean interlace ) throws IOException
{
super( prod, out );
this.interlace = interlace;
}
int width, height;
int[][] rgbPixels;
void encodeStart( int width, int height ) throws IOException
{
this.width = width;
this.height = height;
rgbPixels = new int[height][width];
}
void encodePixels(
int x, int y, int w, int h, int[] rgbPixels, int off, int scansize )
throws IOException
{
// Save the pixels.
for ( int row = 0; row < h; ++row )
System.arraycopy(
rgbPixels, row * scansize + off,
this.rgbPixels[y + row], x, w );
}
IntHashtable colorHash;
void encodeDone() throws IOException
{
int transparentIndex = -1;
int transparentRgb = -1;
// Put all the pixels into a hash table.
colorHash = new IntHashtable();
int index = 0;
for ( int row = 0; row < height; ++row )
{
int rowOffset = row * width;
for ( int col = 0; col < width; ++col )
{
int rgb = rgbPixels[row][col];
boolean isTransparent = ( ( rgb >>> 24 ) < 0x80 );
if ( isTransparent )
{
if ( transparentIndex < 0 )
{
// First transparent color; remember it.
transparentIndex = index;
transparentRgb = rgb;
}
else if ( rgb != transparentRgb )
{
// A second transparent color; replace it with
// the first one.
rgbPixels[row][col] = rgb = transparentRgb;
}
}
GifEncoderHashitem item =
(GifEncoderHashitem) colorHash.get( rgb );
if ( item == null )
{
if ( index >= 256 )
throw new IOException( "too many colors for a GIF" );
item = new GifEncoderHashitem(
rgb, 1, index, isTransparent );
++index;
colorHash.put( rgb, item );
}
else
++item.count;
}
}
// Figure out how many bits to use.
int logColors;
if ( index <= 2 )
logColors = 1;
else if ( index <= 4 )
logColors = 2;
else if ( index <= 16 )
logColors = 4;
else
logColors = 8;
// Turn colors into colormap entries.
int mapSize = 1 << logColors;
byte[] reds = new byte[mapSize];
byte[] grns = new byte[mapSize];
byte[] blus = new byte[mapSize];
for ( Enumeration e = colorHash.elements(); e.hasMoreElements(); )
{
GifEncoderHashitem item = (GifEncoderHashitem) e.nextElement();
reds[item.index] = (byte) ( ( item.rgb >> 16 ) & 0xff );
grns[item.index] = (byte) ( ( item.rgb >> 8 ) & 0xff );
blus[item.index] = (byte) ( item.rgb & 0xff );
}
GIFEncode(
out, width, height, interlace, (byte) 0, transparentIndex,
logColors, reds, grns, blus );
}
byte GetPixel( int x, int y ) throws IOException
{
GifEncoderHashitem item =
(GifEncoderHashitem) colorHash.get( rgbPixels[y][x] );
if ( item == null )
throw new IOException( "color not found" );
return (byte) item.index;
}
static void writeString( OutputStream out, String str ) throws IOException
{
byte[] buf = str.getBytes();
out.write( buf );
}
// Adapted from ppmtogif, which is based on GIFENCOD by David
// Rowley
* The value of the alignment argument must be one of
*
* Basically, a ChangeEvent is a dual purpose event. One is sent to listeners
* both when a KeyEvent is generated from the text field, and one is sent when
* an ItemEvent is generated (which happens when an item is selected from the
* drop-down list). This means that somebody who wants to know when the actual
* text showing has changed only needs to implement ChangeListener instead of
* both ItemListener and KeyListener.
* @author Jonas Gifford
*/
final public class JASEditableComboBox extends JComboBox implements KeyListener
{
/**
* Creates a JASEditableComboBox with the given list of drop-down items. You are
* responsible for keeping and providing an updated list.
* @param dropDownItems the items to show in the drop-down list (can safely be
* It is used by some local data interface modules when field names are
* not specified, and it is used to assign names to the coefficents of
* polynomial functions.
*
* @author Jonas Gifford
*/
public class ArbitraryNameGenerator
{
/**
* Fills a String array with names.
* @param s the array to fill
*/
public void fillArray(String[] s)
{
char c = 'A';
if (s.length < 26) // the simple and predominant case
for (int i = 0; i < s.length; i++)
s[i] = String.valueOf(c++);
else // the highly unlikely case that there
// are more than 26 items
{
int nLetters = 1;
for (int i = 0; i < s.length; i++)
{
s[i] = "";
for (int j = 0; j < nLetters; j++)
s[i] += (c);
if (c == 'Z')
{
c = 'A';
nLetters++;
}
else
c++;
}
}
}
}
src/main/java/jas/util/FieldBinding.java 0000644 0001750 0001750 00000001037 11325547132 020637 0 ustar giovanni giovanni package jas.util;
import java.util.Observable;
abstract class FieldBinding extends Observable
{
// override to implement a test for valid input
boolean hasValidInput()
{
return true;
}
abstract void set(Object value) throws UnsupportedType;
abstract Object get(Class type) throws UnsupportedType;
protected void reset() { valueChanged = false; }
protected void setChanged()
{
super.setChanged();
valueChanged = true;
}
protected boolean hasValueChanged()
{
return valueChanged;
}
private boolean valueChanged = false;
}
src/main/java/jas/util/JASRadioMenuItem.java 0000644 0001750 0001750 00000002341 11325547132 021360 0 ustar giovanni giovanni package jas.util;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Observable;
import java.util.Observer;
import javax.swing.JRadioButtonMenuItem;
public class JASRadioMenuItem
extends JRadioButtonMenuItem
implements Observer,ActionListener,JASCheckboxState, CommandSource
{
public JASRadioMenuItem()
{
super();
setEnabled(false);
Application.getApplication().getCommandManager().add(this); // register with CommandTargetManager
addActionListener(this);
}
public void actionPerformed(ActionEvent evt)
{
m_target.invoke();
}
public void setCheckbox(boolean state)
{
setSelected(state);
}
public boolean setTarget(CommandTarget t)
{
if (t instanceof SimpleCommandTarget)
{
m_target = (SimpleCommandTarget) t;
m_target.enable(this);
return true;
}
else return false;
}
public void clearTarget()
{
m_target = null;
setEnabled(false);
}
public CommandTarget getTarget()
{
return m_target;
}
public String getCommand()
{
return getActionCommand();
}
public void update(Observable o, Object arg)
{
m_target.enable(this);
}
public void setEnabled(boolean state)
{
super.setEnabled(state);
}
private SimpleCommandTarget m_target = null;
}
src/main/java/jas/util/CheckBoxBorderPanel.java 0000644 0001750 0001750 00000005373 11325547132 022134 0 ustar giovanni giovanni package jas.util;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.Graphics;
import java.awt.Insets;
import java.awt.LayoutManager;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import javax.swing.BorderFactory;
import javax.swing.JButton;
import javax.swing.JCheckBox;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.border.Border;
/**
* A JPanel which has a checkbox embedded in its border. The contents of the panel
* are automatically insensitized when the checkbox is turned off.
*/
public class CheckBoxBorderPanel extends JPanel implements ItemListener
{
public CheckBoxBorderPanel(String title)
{
this(title,null,null);
}
public CheckBoxBorderPanel(String title, Border border)
{
this(title,border,null);
}
public CheckBoxBorderPanel(String title, LayoutManager layout)
{
this(title,null,layout);
}
public CheckBoxBorderPanel(String title, Border border, LayoutManager layout)
{
if (layout == null) layout = new FlowLayout();
if (border == null) border = BorderFactory.createEtchedBorder();
checkbox = new JCheckBox(title);
setLayout(layout);
setBorder(border);
add(checkbox,0);
checkbox.addItemListener(this);
}
public void doLayout()
{
setEnabled();
checkbox.setVisible(false);
super.doLayout();
checkbox.setVisible(true);
Dimension size = checkbox.getPreferredSize();
checkbox.setSize(size);
checkbox.setLocation(20,0);
}
public void itemStateChanged(ItemEvent e)
{
setEnabled();
}
private void setEnabled()
{
boolean set = checkbox.isSelected();
Component[] children = getComponents();
for (int i=0; i
* This class is a KeyListener and has implemented the interface
* with non-final methods. If you do not override these
* methods, Use the method Labels are displayed in the order as they appear in the array given to the method
* Note that this is not the same as dates. A date represents a particular
* point in time (e.g., when an event took place). This axis represents
* time values, such as the time between two events. Therefore, while a date
* value may be represented as "Jan 31, 1994", a time value might be represented as "3 weeks".
* @see DateAxis
* @author Jonas Gifford
*/
final public class TimeAxis extends AxisType implements TimeCoordinateTransformation
{
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* begin code for handling unit size
*/
/** The integer code for millisecond units. */
public static final int MILLISECONDS = 0;
/** The integer code for second units. */
public static final int SECONDS = 1;
/** The integer code for minute units. */
public static final int MINUTES = 2;
/** The integer code for hour units. */
public static final int HOURS = 3;
/** The integer code for day units. */
public static final int DAYS = 4;
/** The integer code for week units. */
public static final int WEEKS = 5;
/** The integer code for month units. */
public static final int MONTHS = 6;
/** The integer code for year units. */
public static final int YEARS = 7;
/**
* Set write method of OutputStream calls
* the write method of one argument on each of the bytes to be
* written out. Subclasses are encouraged to override this method and
* provide a more efficient implementation.
*
* @param b the data.
* @param off the start offset in the data.
* @param len the number of bytes to write.
* @exception IOException if an I/O error occurs.
* @since JDK1.0
*/
public void write(byte b[], int off, int len) throws IOException {
try {
doc.insertString(doc.getLength(), new String(b, off, len), a);
} catch (BadLocationException ble) {
throw new IOException(ble.getMessage());
}
}
private byte[] one = new byte[1];
private Document doc;
private AttributeSet a;
}
src/main/java/jas/util/JASToolBarButton.java 0000644 0001750 0001750 00000002075 11325547132 021420 0 ustar giovanni giovanni package jas.util;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Observable;
import java.util.Observer;
import javax.swing.JButton;
public class JASToolBarButton extends JButton
implements Observer,ActionListener,JASState,CommandSource
{
public JASToolBarButton()
{
setEnabled(false);
Application.getApplication().getCommandManager().add(this);
addActionListener(this);
}
public boolean setTarget(CommandTarget t)
{
if (t instanceof SimpleCommandTarget)
{
m_target = (SimpleCommandTarget) t;
m_target.enable(this);
return true;
}
else return false;
}
public void clearTarget()
{
m_target = null;
setEnabled(false);
}
public CommandTarget getTarget()
{
return m_target;
}
public String getCommand()
{
return getActionCommand();
}
public void update(Observable o, Object arg)
{
m_target.enable(this);
}
public void actionPerformed(ActionEvent evt)
{
m_target.invoke();
}
public void setEnabled(boolean state)
{
super.setEnabled(state);
}
private SimpleCommandTarget m_target;
}
src/main/java/jas/util/JSpinnerFieldBinding.java 0000644 0001750 0001750 00000002026 11325547132 022307 0 ustar giovanni giovanni package jas.util;
import javax.swing.JSpinner;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
class JSpinnerFieldBinding extends FieldBinding implements ChangeListener
{
JSpinnerFieldBinding(JSpinner field)
{
m_field = field;
field.addChangeListener(this);
}
void set(Object value) throws UnsupportedType
{
if (!m_oldVal.equals(value))
{
m_field.setValue(value);
m_oldVal = value;
}
}
Object get(Class type) throws UnsupportedType
{
Object result = m_field.getValue();
if (type == Float.TYPE && result instanceof Double) return new Float(((Double) result).floatValue());
return result;
}
public void stateChanged(ChangeEvent e)
{
Object x = m_field.getValue();
if (!x.equals(m_oldVal)) setChanged();
notifyObservers();
}
protected void reset()
{
super.reset();
m_oldVal = m_field.getValue();
}
private Object m_oldVal = new Integer(0);
private JSpinner m_field;
}
src/main/java/jas/util/JCheckBoxFieldBinding.java 0000644 0001750 0001750 00000001777 11325547132 022373 0 ustar giovanni giovanni package jas.util;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import javax.swing.JCheckBox;
class JCheckBoxFieldBinding extends FieldBinding implements ItemListener
{
JCheckBoxFieldBinding(JCheckBox field)
{
m_field = field;
field.addItemListener(this);
}
void set(Object value) throws UnsupportedType
{
if (!(value instanceof Boolean)) throw new UnsupportedType(m_field,value.getClass());
boolean x = ((Boolean) value).booleanValue();
if (m_oldVal != x)
{
m_field.setSelected(x);
m_oldVal = x;
}
}
Object get(Class type) throws UnsupportedType
{
if (type != Boolean.TYPE) throw new UnsupportedType(m_field,type);
boolean x = m_field.isSelected();
return new Boolean(x);
}
public void itemStateChanged(ItemEvent e)
{
boolean x = m_field.isSelected();
if (x != m_oldVal) setChanged();
notifyObservers();
}
protected void reset()
{
super.reset();
m_oldVal = m_field.isSelected();
}
private boolean m_oldVal = false;
private JCheckBox m_field;
}
src/main/java/jas/util/JASCheckboxMenuItem.java 0000644 0001750 0001750 00000004022 11325547132 022046 0 ustar giovanni giovanni package jas.util;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Observable;
import java.util.Observer;
import javax.swing.JCheckBoxMenuItem;
public class JASCheckboxMenuItem
extends JCheckBoxMenuItem
implements Observer,ActionListener,JASCheckboxState, CommandSource
{
public JASCheckboxMenuItem()
{
super();
setEnabled(false);
Application.getApplication().getCommandManager().add(this);
addActionListener(this);
}
public JASCheckboxMenuItem(String s, char mnemonic)
{
super(s);
setMnemonic(mnemonic);
setEnabled(false);
Application.getApplication().getCommandManager().add(this); // register with CommandTargetManager
addActionListener(this);
}
public void actionPerformed(ActionEvent evt)
{
m_target.invoke(getState());
}
public void setCheckbox(boolean state)
{
setState(state);
}
public boolean setTarget(CommandTarget t)
{
if (t instanceof BooleanCommandTarget)
{
m_target = (BooleanCommandTarget) t;
m_target.enable(this);
return true;
}
else return false;
}
public void clearTarget()
{
m_target = null;
setEnabled(false);
}
public CommandTarget getTarget()
{
return m_target;
}
public String getCommand()
{
return getText();
}
public void update(Observable o, Object arg)
{
m_target.enable(this);
}
public void setEnabled(boolean state)
{
if (correspondingToolBarFloating) {
//We need to do this since when the menu is refreshed calling setEnabled
//wipes out the previous setting, which we might have adjusted based on whether
//the user has undocked the corresponding toolbar IF this JASCheckboxMenuItem
//controls the visibility of a toolbar. (Yes, this is a bit ugly but when we
//move to JDK 1.2 this issue will go away.)
super.setEnabled(false);
} else {
super.setEnabled(state);
}
}
public void setCorrespondingToolBarFloating(boolean state) {
correspondingToolBarFloating = state;
}
private boolean correspondingToolBarFloating = false;
private BooleanCommandTarget m_target = null;
}
src/main/java/jas/util/PropertyDialog.java 0000644 0001750 0001750 00000004733 11325547132 021273 0 ustar giovanni giovanni package jas.util;
import java.awt.Frame;
import javax.swing.JTabbedPane;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
public class PropertyDialog extends JASDialog implements PropertySite, ChangeListener
{
protected PropertyDialog(Frame f,String title,Object bean)
{
super(f,title,true,OK_BUTTON|APPLY_BUTTON|CANCEL_BUTTON|HELP_BUTTON);
m_tab_manager = new JTabbedPane();
m_tab_manager.addChangeListener(this);
setContentPane(m_tab_manager);
m_currentPage = null;
m_bean = bean;
}
protected void addPage(final String name, final PropertyPage p, final boolean select)
{
m_tab_manager.addTab(name,p);
p.setPropertySite(this);
if (select) m_tab_manager.setSelectedComponent(p);
}
public void stateChanged(ChangeEvent evt)
{
if (m_suppressChangeEvents) return; // don't receive change events that this method creates
if (m_currentPage == null || m_currentPage.hasValidInput())
// notification of invalid input is the responsibility of the field binding
{
doDataExchange(true);
if (m_currentPage != null) m_currentPage.deactivate();
m_currentPage = (PropertyPage) m_tab_manager.getSelectedComponent();
m_currentPage.activate();
doDataExchange(false);
setHelpTopic(m_currentPage.getHelpTopic());
super.callEnable();
}
else
{
m_suppressChangeEvents = true; // ignore change event from the call below
m_tab_manager.setSelectedComponent(m_currentPage); // return to page that was not valid
m_suppressChangeEvents = false; // allow change events again
}
}
private void doDataExchange(boolean set)
{
// guaranteed by this point to be valid input
if (m_currentPage != null) m_currentPage.doDataExchange(set,m_bean);
}
public void enableApply(JASState state)
{
state.setEnabled(m_currentPage.hasChanged());
}
public void callEnable()
{
super.callEnable();
}
public void onApply()
{
if (m_currentPage.hasValidInput())
// notification of invalid input is the responsibility of the field binding
{
doDataExchange(true);
doDataExchange(false); // In case other values change
super.onApply();
super.callEnable();
}
}
public void onOK()
{
if (m_currentPage.hasValidInput())
{
doDataExchange(true);
m_currentPage.deactivate();
super.onOK();
}
}
public void onCancel()
{
m_currentPage.deactivate();
super.onCancel();
}
private Object m_bean;
private JTabbedPane m_tab_manager;
private PropertyPage m_currentPage;
private boolean m_suppressChangeEvents = false;
}
src/main/java/jas/util/WrappingTextArea.java 0000644 0001750 0001750 00000003143 11325547132 021546 0 ustar giovanni giovanni package jas.util;
import java.awt.Color;
import java.awt.Dimension;
import javax.swing.JEditorPane;
import javax.swing.text.DefaultEditorKit;
import javax.swing.text.Element;
import javax.swing.text.View;
import javax.swing.text.ViewFactory;
import javax.swing.text.WrappedPlainView;
/** Use this class to implement a component that contains line-wrapping text. */
public class WrappingTextArea extends JEditorPane
{
/**
* @param text the text to display
* @param editable whether the text is editable
* @param background use getBackground() from the parent component
* @param size the preferred size of this component
*/
public WrappingTextArea(final String text, final boolean editable, final Color background,
final Dimension size)
{
final WrappingEditorKit kit = new WrappingEditorKit();
setEditorKitForContentType("text/wrapping", kit);
setContentType("text/wrapping");
setBackground(background);
setCaretColor(new Color(0, 0, 0));
if (editable)
{
getCaret().setBlinkRate(500);
getCaret().setVisible(true);
}
setEditable(editable);
setFont(new java.awt.Font("Dialog", 0, 12));
setText(text);
m_size = size;
}
public Dimension getPreferredSize()
{
return m_size;
}
private Dimension m_size;
}
class WrappingEditorKit extends DefaultEditorKit
{
public ViewFactory getViewFactory()
{
if (m_viewFactory == null)
m_viewFactory = new WrappingViewFactory();
return m_viewFactory;
}
private ViewFactory m_viewFactory;
}
class WrappingViewFactory implements ViewFactory
{
public View create(Element elem) {
return new WrappedPlainView(elem, true);
}
}
src/main/java/jas/util/ColorFieldBinding.java 0000644 0001750 0001750 00000001762 11325547132 021643 0 ustar giovanni giovanni package jas.util;
import java.awt.Color;
class ColorFieldBinding extends FieldBinding implements ColorListener
{
ColorFieldBinding(ColorChooser field)
{
m_field = field;
field.addColorListener(this);
}
void set(Object value) throws UnsupportedType
{
if (!(value instanceof Color)) throw new UnsupportedType(m_field,value.getClass());
Color c = (Color) value;
if (!m_oldVal.equals(c))
{
m_field.setColor(c);
m_oldVal = c;
}
}
Object get(Class type) throws UnsupportedType
{
Color c = m_field.getColor();
if (!type.isInstance(c)) throw new UnsupportedType(m_field,type);
return c;
}
public void colorChanged(ColorEvent e)
{
Color c = m_field.getColor();
if (c != m_oldVal) setChanged();
notifyObservers();
}
protected void reset()
{
super.reset();
m_oldVal = m_field.getColor();
}
private Color m_oldVal = Color.black;
private ColorChooser m_field;
}
src/main/java/jas/util/JASTextField.java 0000644 0001750 0001750 00000003626 11325547132 020555 0 ustar giovanni giovanni package jas.util;
/**
* Works just like a JTextField, except that the default button
* for this component's root pane will is clicked when the user clicks on Enter
* in this field. In a normal JTextField, clicking on Enter
* produces an ActionEvent, but it does not do a click on
* the default button as most users would expect.
* @author Jonas Gifford
* @see javax.swing.JRootPane
* @see javax.swing.JTextField
*/
public class JASTextField extends javax.swing.JTextField
{
/**
* Just like calling JTextField()
* except that the default button for this component's root pane will
* be clicked when Enter is clicked in the field.
*/
public JASTextField()
{
super();
}
/**
* Just like calling JTextField(String)
* except that the default button for this component's root pane will
* be clicked when Enter is clicked in the field.
*/
public JASTextField(String text)
{
super(text);
}
/**
* Just like calling JTextField(int)
* except that the default button for this component's root pane will
* be clicked when Enter is clicked in the field.
*/
public JASTextField(int columns)
{
super(columns);
}
/**
* Just like calling JTextField(String, int)
* except that the default button for this component's root pane will
* be clicked when Enter is clicked in the field.
*/
public JASTextField(String text, int columns)
{
super(text, columns);
}
/**
* Just like calling JTextField(Document, String, int)
* except that the default button for this component's root pane will
* be clicked when Enter is clicked in the field.
*/
public JASTextField(javax.swing.text.Document doc, String text, int columns)
{
super(doc, text, columns);
}
protected void fireActionPerformed()
{
super.fireActionPerformed();
javax.swing.JButton b = getRootPane().getDefaultButton();
if (b != null) b.doClick();
}
}
src/main/java/jas/util/ColorEvent.java 0000644 0001750 0001750 00000000532 11325547132 020400 0 ustar giovanni giovanni package jas.util;
import java.awt.AWTEvent;
import java.awt.Color;
public class ColorEvent extends AWTEvent
{
public final static int COLOREVENT = AWTEvent.RESERVED_ID_MAX + 9000;
ColorEvent(Object source, Color c)
{
super(source,COLOREVENT);
this.color = c;
}
public Color getColor()
{
return this.color;
}
private Color color;
}
src/main/java/jas/util/JComboBoxFieldBinding.java 0000644 0001750 0001750 00000002071 11325547132 022401 0 ustar giovanni giovanni package jas.util;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import javax.swing.JComboBox;
class JComboBoxFieldBinding extends FieldBinding implements ItemListener
{
JComboBoxFieldBinding(JComboBox field)
{
m_field = field;
field.addItemListener(this);
}
void set(Object value) throws UnsupportedType
{
if (!(value instanceof Integer)) throw new UnsupportedType(m_field,value.getClass());
int x = ((Integer) value).intValue();
if (x != m_oldVal)
{
m_field.setSelectedIndex(x);
m_oldVal = x;
m_field.repaint(); // should not really be necessary??
}
}
Object get(Class type) throws UnsupportedType
{
if (type != Integer.TYPE) throw new UnsupportedType(m_field,type);
int x = m_field.getSelectedIndex();
return new Integer(x);
}
public void itemStateChanged(ItemEvent e)
{
int x = m_field.getSelectedIndex();
if (x != m_oldVal) setChanged();
notifyObservers();
}
protected void reset()
{
super.reset();
m_oldVal = m_field.getSelectedIndex();
}
private int m_oldVal = 0;
private JComboBox m_field;
}
src/main/java/jas/util/CommandSource.java 0000644 0001750 0001750 00000001715 11325547132 021063 0 ustar giovanni giovanni package jas.util;
/**
* A CommandSource represents a source of a command, such as a MenuItem or Toolbar Button.
* A CommandSource may have a CommandTarget associated with it. The CommandTarget represents
* the command that will be fired when the CommandSource is activated. Typically a
* CommandTargetManager is responsible for setting the CommandTarget.
*
* The CommandSource will typically be dimmed out if either there is no CommandTarget associated
* with it, or if the CommandTarget is not enabled.
*/
public interface CommandSource
{
/**
* Returns the command associated with the CommandSource
*/
String getCommand();
/**
* Sets a CommandTarget associated with the CommandSource
*/
boolean setTarget(CommandTarget target);
/**
* Clears the CommandTarget associated with the CommandSource
*/
void clearTarget();
/**
* Returns the current CommandTarget, or null of there isnt a current command target
*/
CommandTarget getTarget();
}
src/main/java/jas/util/encoder/ 0000755 0001750 0001750 00000000000 11325547132 017074 5 ustar giovanni giovanni src/main/java/jas/util/encoder/ImageEncoder.java 0000644 0001750 0001750 00000016147 11325547132 022272 0 ustar giovanni giovanni // ImageEncoder - abstract class for writing out an image
//
// Copyright (C) 1996 by Jef Poskanzer
// Fetch the entire Acme package.
//
// Fetch the entire Acme package.
//
// Fetch the entire Acme package.
//
* public void onXXX()
*
* to handle the command XXX. Also
*
* public void enableXXX(JASState state)
*
* to determine if the command is active or not.
* @dependency jas.util.CommandProcessor$SimpleTarget creates
* @dependency jas.util.CommandProcessor$BooleanTarget creates
*/
public class CommandProcessor extends Observable
{
protected String translate(String command)
{
if (command.endsWith("..."))
command = command.substring(0,command.length()-3);
for (int i=command.indexOf(" "); i >= 0; i=command.indexOf(" "))
command = command.substring(0,i)+command.substring(i+1);
return command;
}
protected void setChanged()
{
super.setChanged();
notifyObservers();
}
protected void setManager(CommandTargetManager m)
{
}
/**
* The CommandTargetManager called acceptCommand to find out if this CommandProcessor
* can respond to the specified command. If it can it returns a CommandTarget for the command,
* otherwise it returns null.
*
*/
protected CommandTarget acceptCommand(String command)
{
String t = translate(command);
String c = "on"+t;
String e = "enable"+t;
Method mc,me;
try
{
mc = this.getClass().getMethod(c,noArg);
try
{
me = this.getClass().getMethod(e,simpleEnableArg);
}
catch (NoSuchMethodException x)
{
me = null;
}
try // Support for RadioMenuItem
{
if (me == null) me = this.getClass().getMethod(e,booleanEnableArg);
}
catch (NoSuchMethodException x)
{
me = null;
}
return new SimpleTarget(mc,me);
}
catch (NoSuchMethodException x)
{
}
try
{
mc = this.getClass().getMethod(c,boolArg);
try
{
me = this.getClass().getMethod(e,booleanEnableArg);
}
catch (NoSuchMethodException x)
{
me = null;
}
return new BooleanTarget(mc,me);
}
catch (NoSuchMethodException x)
{
}
return null;
}
protected void invoke(Method method,Object[] args)
throws IllegalAccessException,InvocationTargetException
{
method.invoke(this,args);
}
protected void invokeEnable(Method method,Object[] args)
throws IllegalAccessException,InvocationTargetException
{
invoke(method,args);
}
protected void invokeCommand(Method method,Object[] args)
throws IllegalAccessException,InvocationTargetException
{
invoke(method,args);
}
protected void invokeCommand(SimpleTarget t)
{
try
{
t.doCommand();
}
catch (CommandInvocationException x)
{
System.err.println("Error during command invocation: "+x.getTargetException());
}
}
protected void invokeCommand(BooleanTarget t, boolean arg)
{
try
{
t.doCommand(arg);
}
catch (CommandInvocationException x)
{
System.err.println("Error during command invocation: "+x.getTargetException());
}
}
private static final Class noArg[] = {};
private static final Object noArgs[] = {};
private static final Class boolArg[] = {java.lang.Boolean.TYPE};
private static final Class simpleEnableArg[] = {JASState.class};
private static final Class booleanEnableArg[] = {JASCheckboxState.class};
/**
* A SimpleTarget is an implementation of CommandTarget which implements its
*
*/
protected class SimpleTarget implements SimpleCommandTarget
{
SimpleTarget(Method command, Method enable)
{
m_command = command;
m_enable = enable;
}
public void invoke()
{
CommandProcessor.this.invokeCommand(this);
}
public void doCommand() throws CommandInvocationException
{
try
{
invokeCommand(m_command,noArgs);
}
catch (IllegalAccessException x)
{
throw new RuntimeException("IllegalAccessException during command invocation");
}
catch (InvocationTargetException x)
{
throw new CommandInvocationException(x.getTargetException());
}
}
public void enable(JASState state)
{
if (m_enable == null) state.setEnabled(true);
else
{
try
{
Object[] args = { state };
invokeEnable(m_enable, args);
}
catch (IllegalAccessException x)
{
state.setEnabled(false);
}
catch (InvocationTargetException x)
{
state.setEnabled(false);
}
}
}
public CommandProcessor getProcessor()
{
return CommandProcessor.this;
}
private Method m_command;
private Method m_enable;
}
protected class BooleanTarget implements BooleanCommandTarget
{
BooleanTarget(Method command, Method enable)
{
m_command = command;
m_enable = enable;
}
public void invoke(boolean arg)
{
CommandProcessor.this.invokeCommand(this,arg);
}
public void enable(JASState state)
{
if (m_enable == null) state.setEnabled(true);
else
{
try
{
Object[] args = { (JASCheckboxState) state };
invokeEnable(m_enable, args);
}
catch (IllegalAccessException x)
{
state.setEnabled(false);
}
catch (InvocationTargetException x)
{
state.setEnabled(false);
}
}
}
public void doCommand(boolean arg) throws CommandInvocationException
{
try
{
Object[] args = { new Boolean(arg) };
invokeCommand(m_command,args);
}
catch (IllegalAccessException x)
{
throw new RuntimeException("IllegalAccessException during command invocation");
}
catch (InvocationTargetException x)
{
throw new CommandInvocationException(x.getTargetException());
}
}
public CommandProcessor getProcessor()
{
return CommandProcessor.this;
}
private Method m_command;
private Method m_enable;
}
}
src/main/java/jas/util/FileReaderWithProgressBar.java 0000644 0001750 0001750 00000006524 11325547132 023337 0 ustar giovanni giovanni package jas.util;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import javax.swing.BoundedRangeModel;
/**
* This class should be used when you want to have a BoundedRangeModel
* display the progress as a file is being opened. The model is updated
* with each call to read, so it is ideally used in a
* BufferedReader where the stream is read in buffer-sized amounts.
* That way, the model updates only when the buffer is filled.
* For example, you might use it like this:
* BufferedReader input = new BufferedReader(new InputStreamReader(new FileReaderWithProgressBar(name, model)));
* @see javax.swing.BoundedRangeModel
* @see java.io.BufferedReader
* @see java.io.InputStreamReader
* @author Jonas Gifford
*/
public class FileReaderWithProgressBar extends FileInputStream
{
/**
* Creates a new FileReaderWithProgressBar.
* @param fileName the file to read
* @param model the BoundedRangeModel to update
* @see javax.swing.BoundedRangeModel
* @exception FileNotFoundException thrown from the constructor of FileInputStream
*/
public FileReaderWithProgressBar(String fileName, BoundedRangeModel model)
throws FileNotFoundException
{
super(fileName);
m_fileLength = new File(fileName).length();
if (m_fileLength == 0) m_fileLength = 1; // just to be on the safe side (we will be dividing by this number)
m_model = model;
m_modelMin = model.getMinimum();
m_modelRange = model.getMaximum() - m_modelMin;
}
/**
* Works just like the equivalent method in FileInputStream, except that
* it updates the model to reflect the progress in reading the file.
* @see java.io.FileInputStream
* @see java.io.FileInputStream#read()
*/
public int read() throws IOException
{
int i = super.read();
if (i != -1)
m_bytesRead++;
updateModel();
return i;
}
/**
* Works just like the equivalent method in FileInputStream, except that
* it updates the model to reflect the progress in reading the file.
* @see java.io.FileInputStream
* @see java.io.FileInputStream#read(byte[])
*/
public int read(byte[] cbuf) throws IOException
{
int i = super.read(cbuf);
if (i > 0)
m_bytesRead += i;
updateModel();
return i;
}
/**
* Works just like the equivalent method in FileInputStream, except that
* it updates the model to reflect the progress in reading the file.
* @see java.io.FileInputStream
* @see java.io.FileInputStream#read(byte[], int, int)
*/
public int read(byte[] cbuf, int off, int len) throws IOException
{
int i = super.read(cbuf, off, len);
if (i > 0)
m_bytesRead += i;
updateModel();
return i;
}
/**
* Works just like the equivalent method in FileInputStream, except that
* it updates the model to reflect the progress in reading the file.
* @see java.io.FileInputStream
* @see java.io.FileInputStream#skip(long)
*/
public long skip(long n) throws IOException
{
long rc = super.skip(n);
m_bytesRead += n;
updateModel();
return rc;
}
private void updateModel()
{
long l = (m_modelRange * m_bytesRead) / m_fileLength;
m_model.setValue(m_modelMin + (int) l); // l in range 0:100, so cast to int is safe
}
private BoundedRangeModel m_model;
private long m_bytesRead = 0;
private long m_fileLength;
private long m_modelRange;
private int m_modelMin;
}
src/main/java/jas/util/HelpInterface.java 0000644 0001750 0001750 00000001611 11325547132 021030 0 ustar giovanni giovanni package jas.util;
import java.awt.Dialog;
import java.awt.Window;
/**
* HelpInterface is the interface which users of the help system deal with.
*
* @author Peter Armstrong
*
*/
public interface HelpInterface
{
/**
* Shows the specified JavaHelp topic with the TOC visible
* @param helpTopicTarget the JavaHelp XML target name which maps to the .html page in the map file
*/
void showHelpTopic(String helpTopicTarget, Window owner);
/**
* Shows the specified JavaHelp topic according to the display parameters provided.
* @param helpTopicTarget the JavaHelp XML target name which maps to the .html page in the map file
* @param navigatorView the string specifying which of the three views to have visible
*/
void showHelpTopic(String helpTopicTarget, String navigatorView, Window owner);
void modalDialogOpening(Dialog dlg);
void modalDialogClosing(Dialog dlg);
}
src/main/java/jas/util/DateChooser.java 0000644 0001750 0001750 00000027456 11325547132 020536 0 ustar giovanni giovanni package jas.util;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.Frame;
import java.awt.Insets;
import java.awt.Point;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.text.DecimalFormat;
import java.text.Format;
import java.util.Calendar;
import java.util.Date;
import java.util.Enumeration;
import java.util.Vector;
import javax.swing.AbstractListModel;
import javax.swing.ComboBoxModel;
import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JList;
import javax.swing.SwingConstants;
import javax.swing.UIManager;
import javax.swing.plaf.basic.BasicComboBoxRenderer;
interface DateListener
{
void dateChanged();
}
class DateModel
{
DateModel(Calendar date)
{
this.date = date;
}
DateModel(Date date)
{
this.date = Calendar.getInstance();
this.date.setTime(date);
}
synchronized void addDateListener(DateListener l)
{
listeners.addElement(l);
}
synchronized void removeDateListener(DateListener l)
{
listeners.removeElement(l);
}
synchronized void fireDateChanged()
{
Enumeration e = listeners.elements();
while (e.hasMoreElements())
{
DateListener l = (DateListener) e.nextElement();
l.dateChanged();
}
}
void set(int field,int value)
{
date.set(field,value);
fireDateChanged();
}
void roll(int field, boolean up)
{
date.roll(field,up);
fireDateChanged();
}
void add(int field, int delta)
{
date.add(field,delta);
fireDateChanged();
}
int get(int field)
{
return date.get(field);
}
Calendar getCalendar()
{
return date;
}
int getDaysInMonth()
{
return( date.getActualMaximum( Calendar.DAY_OF_MONTH ) );
}
Date getTime()
{
return date.getTime();
}
private Vector listeners = new Vector();
private Calendar date;
}
class AbstractDateComboModel extends AbstractListModel implements ComboBoxModel, DateListener
{
AbstractDateComboModel(DateModel model, int field)
{
this.model = model;
this.field = field;
model.addDateListener(this);
}
public void dateChanged()
{
fireContentsChanged(this,0,100);
}
public Object getElementAt(int index)
{
return element[index];
}
public int getSize()
{
return model.getCalendar().getMaximum(field)+1;
}
public Object getSelectedItem()
{
int i = model.get(field);
return element[i];
}
public void setSelectedItem(Object value)
{
int i = ((Integer) value).intValue();
model.set(field,i);
}
DateModel model;
int field;
static Integer[] element;
static
{
element = new Integer[100];
for (int i=0; idispose() in JASWizardPage.
* @see JASWizardPage
* @see JASWizardPage#dispose()
*/
public void dispose()
{
m_firstPage.clear();
/*
* References in it and all pages linked to
* it are set to null.
*/
JASWizardPage.pageNumber = 0;
// next time the pages start at zero, so that the number doesn't get too big
if (getCursor() == m_wait)
m_frame.setCursor(m_wait);
super.dispose();
}
private void onFinish()
{
setToWaitCursor();
try
{
((Finishable) m_currentPage).onFinish();
}
catch (Throwable t)
{
handleError("Error during wizard processing",t);
}
finally
{
setToDefaultCursor();
}
}
private void onCancel()
{
setToWaitCursor();
try
{
m_firstPage.doCancel();
dispose();
}
catch (Throwable t)
{
handleError("Error during wizard processing",t);
}
finally
{
setToDefaultCursor();
}
}
void setToWaitCursor()
{
// should set it on frame too, but doesn't work with modal dialog
setCursor(m_wait);
}
void setToDefaultCursor()
{
setCursor(m_default);
m_frame.setCursor(m_default);
}
/** Public as an implementation side effect; do not call. */
public void actionPerformed(final ActionEvent e)
{
final Object source = e.getSource();
if (source == m_cancel) onCancel();
else if (source == m_help) onHelp();
else if (source == m_prev) onPrev();
else if (source == m_next) onNext();
else if (source == m_finish) onFinish();
}
/** Public as an implementation side effect; do not call. */
public void processWindowEvent(final WindowEvent e)
{
// super.processWindowEvent(e);
final int id = e.getID();
if (id == WindowEvent.WINDOW_CLOSING)
onCancel();
else if (id == WindowEvent.WINDOW_ACTIVATED)
setDefaultButton();
}
protected void handleError(String message, Throwable t)
{
Application app = Application.getApplication();
if (app != null) app.error("Error during wizard processing",t);
else t.printStackTrace();
}
private final JFrame m_frame;
private final Cursor m_default = Cursor.getDefaultCursor(), m_wait = new Cursor(Cursor.WAIT_CURSOR);
private boolean m_currentPageHasAmbiguousDefault;
final private JRootPane m_rootPane;
final private java.awt.Container m_contentPane;
final private JPanel m_wizardPagePanel;
final private JASWizardPage m_firstPage;
private JASWizardPage m_currentPage;
final private JButton m_cancel, m_help, m_prev, m_next, m_finish;
final private CardLayout m_layout;
}
src/main/java/jas/util/SimpleCommandTarget.java 0000644 0001750 0001750 00000000452 11325547132 022220 0 ustar giovanni giovanni package jas.util;
/**
* A CommandTarget which does not have a selected/deselected state associated with it
* @see BooleanCommandTarget
*/
public interface SimpleCommandTarget extends CommandTarget
{
/**
* The invoke method is called to actually perform the command.
*/
void invoke();
}
src/main/java/jas/util/GetOptions.java 0000644 0001750 0001750 00000031255 11325547132 020421 0 ustar giovanni giovanni /*
* @(#)GetOptions.java
*/
package jas.util;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Vector;
/**
* GetOptions is used to help parse command line arguments. It is loosely
* based on Paul Raines' GetOpt module with modifications to handle multiple
* classes wanting access to the same arguments. The main design difference
* is that instead of doing all the work in the constructor we do it with
* addOption() and parseArgs(). Furthermore, the Hashtables are different, etc.
*
* @author Peter Armstrong
*
*/
public class GetOptions extends Object {
/**
* Creates an empty GetOptions object.
*
* Options are added to the object using the addOption method, unlike
* GetOpt which adds them in the constructor.
*/
public GetOptions()
{
shortToLongMap = new Hashtable();
longToIsFlagMap = new Hashtable();
longToOptionsMap = new Hashtable();
longToComment = new Hashtable();
params = new String[0];
}
/**
* Adds an option to be recognized by parseArgs.
*
* @param longName the full name of the option
* @param flag true if the option is a flag (takes 0 parameters), false otherwise
*/
public void addOption(String longName, boolean flag)
{
longToIsFlagMap.put(longName, new Boolean(flag));
}
/**
* Adds an option to be recognized by parseArgs.
*
* @param longName the full name of the option
* @param flag true if the option is a flag (takes 0 parameters), false otherwise
* @param comment description of the arguments to the option
*/
public void addOption(String longName, boolean flag, String comment)
{
longToIsFlagMap.put(longName, new Boolean(flag));
longToComment.put(longName, comment);
}
/**
* Adds an option to be recognized by parseArgs.
*
* @param shortName the single character name of the option
* @param flag true if the option is a flag (takes 0 parameters), false otherwise
*/
public void addOption(char shortName, boolean flag)
{
addOption((new Character(shortName)).toString(), shortName, flag);
}
/**
* Adds an option to be recognized by parseArgs.
*
* @param shortName the single character name of the option
* @param flag true if the option is a flag (takes 0 parameters), false otherwise
* @param comment description of the arguments to the option
*/
public void addOption(char shortName, boolean flag, String comment)
{
addOption((new Character(shortName)).toString(), shortName, flag, comment);
}
/**
* Adds an option to be recognized by parseArgs.
*
* @param longName the full name of the option
* @param shortName the single character name of the option
* @param flag true if the option is a flag (takes 0 parameters), false otherwise
*/
public void addOption(String longName, char shortName, boolean flag)
{
addOption(longName, shortName, flag, null);
}
/**
* Adds an option to be recognized by parseArgs.
*
* @param longName the full name of the option
* @param shortName the single character name of the option
* @param flag true if the option is a flag (takes 0 parameters), false otherwise
* @param comment description of the arguments to the option
*/
public void addOption(String longName, char shortName, boolean flag, String comment)
{
shortToLongMap.put((new Character(shortName)).toString(), longName);
longToIsFlagMap.put(longName, new Boolean(flag));
if (comment != null) {
longToComment.put(longName, comment);
}
}
/**
* Returns true or false depending on if the option with the long name longName
* is in fact a real option.
*
* @param longName a string describing the option to query for.
* @return true or false.
*/
public boolean isLegalOption(String longName)
{
return longToIsFlagMap.containsKey(longName);
}
/**
* Returns true or false depending on if the option with the long name longName was given
* in either the short (if one exists) or the long form.
*
* @param longName a string describing the option to query for.
* @return true or false.
*/
public boolean hasOption(String longName)
{
return longToOptionsMap.containsKey(longName);
}
/**
* Returns the value given for the option with the long name longName.
* Returns "FLAG" if the option was given but is a flag (takes no arguments).
*
* @param longName a string describing the option to query for.
* @return value of option, "FLAG" or null.
*/
public String getOption(String longName)
{
return longToOptionsMap.get(longName).toString();
}
/**
* Returns the comment given for the option with the long name longName.
*
* @param longName a string describing the option to query for.
* @return value of comment or null if no comment exists.
*/
public String getComment(String longName)
{
if (longToComment.containsKey(longName))
{
return longToComment.get(longName).toString();
}
return null;
}
/**
* Exception to throw when an invalid argument is encountered.
*/
public static class BadArguments extends Exception
{
public BadArguments() { super(); }
public BadArguments(String s) { super(s); }
}
public void dumpOptions()
{
System.out.println("Options:");
System.out.println();
System.out.println("Short Long Value Comment");
System.out.println("Name Name Required");
System.out.println("----- ------------ -------- ---------------------------");
Enumeration vo = getValidOptions();
while (vo.hasMoreElements()) System.out.println(vo.nextElement());
}
/**
* Return an enumeration of String representations of ToolbarLayout.RIGHT,
* or ToolbarLayout.CENTER.
* @param align the alignment value
*/
public ToolbarLayout(int align) {
this(align, 5, 5);
}
/**
* Creates a new ToolbarLayout with the indicated alignment
* and the indicated horizontal and vertical gaps.
* ToolbarLayout.LEFT, ToolbarLayout.RIGHT,
* or ToolbarLayout.CENTER.
* @param align the alignment value.
* @param hgap the horizontal gap between components.
* @param vgap the vertical gap between components.
*/
public ToolbarLayout(int align, int hgap, int vgap) {
this.align = align;
this.hgap = hgap;
this.vgap = vgap;
}
/**
* Gets the alignment for this layout.
* Possible values are ToolbarLayout.LEFT,
* ToolbarLayout.RIGHT, or ToolbarLayout.CENTER.
* @return the alignment value for this layout.
* @see ToolbarLayout#setAlignment
*/
public int getAlignment() {
return align;
}
/**
* Sets the alignment for this layout.
* Possible values are ToolbarLayout.LEFT,
* ToolbarLayout.RIGHT, and ToolbarLayout.CENTER.
* @param align the alignment value.
* @see ToolbarLayout#getAlignment
*/
public void setAlignment(int align) {
this.align = align;
}
/**
* Gets the horizontal gap between components.
* @return the horizontal gap between components.
* @see ToolbarLayout#setHgap
*/
public int getHgap() {
return hgap;
}
/**
* Sets the horizontal gap between components.
* @param hgap the horizontal gap between components
* @see ToolbarLayout#getHgap
*/
public void setHgap(int hgap) {
this.hgap = hgap;
}
/**
* Gets the vertical gap between components.
* @return the vertical gap between components.
* @see ToolbarLayout#setVgap
*/
public int getVgap() {
return vgap;
}
/**
* Sets the vertical gap between components.
* @param vgap the vertical gap between components
* @see ToolbarLayout#getVgap
*/
public void setVgap(int vgap) {
this.vgap = vgap;
}
/**
* Adds the specified component to the layout. Sets the orientation to be horizontal.
* @param name the name of the component
* @param comp the component to be added
*/
public void addLayoutComponent(String name, Component comp) {
try {
((JToolBar)comp).setOrientation(JToolBar.HORIZONTAL);
} catch (Exception e){
}
}
/**
* Removes the specified component from the layout. Not used by
* this class.
* @param comp the component to remove
* @see java.awt.Container#removeAll
*/
public void removeLayoutComponent(Component comp) {
}
/**
* Returns the preferred dimensions for this layout given the components
* in the specified target container. This method is the difference
* between ToolbarLayout and FlowLayout.
* @param target the component which needs to be laid out
* @return the preferred dimensions to lay out the
* subcomponents of the specified container.
* @see Container
* @see #minimumLayoutSize
* @see java.awt.Container#getPreferredSize
*/
public Dimension preferredLayoutSize(Container target) {
synchronized (target.getTreeLock()) {
Dimension dim = new Dimension(0, 0);
int nmembers = target.getComponentCount();
Insets insets = target.getInsets();
int numRows = 1; //the number of rows
int rowSumWidth = insets.left + insets.right; //the width of the row so far
int rowMaxWidth = target.getSize().width; //the width that the ToolbarLayout is in
int rowHeight = 0; //the height of each row
int numOnRow = 0; //the number of components on the row
for (int i = 0 ; i < nmembers ; i++) {
Component m = target.getComponent(i);
if (m.isVisible()) {
Dimension d = m.getPreferredSize();
rowHeight = Math.max(rowHeight, d.height); //make each row the height of the biggest component of all
if (i > 0) {
rowSumWidth += hgap;//add on the pre-spacing if this is not the first component
}
rowSumWidth += d.width; //add the width of the component
//if it overflowed and if there are components already on this row then bump this component to next row
if ((rowSumWidth + hgap) > rowMaxWidth) {
if (numOnRow > 0) {
numRows++;
rowSumWidth = insets.left + insets.right + d.width;
numOnRow = 0;//reset the number of components on the next row (we ++ no matter what later)
}
}
numOnRow++;//add this component to the count of the number on the row
}
}
dim.width = rowMaxWidth;
dim.height = insets.top + insets.bottom + numRows*rowHeight + vgap*(numRows + 1);
return dim;
}
}
/**
* Returns the minimum dimensions needed to layout the components
* contained in the specified target container.
* @param target the component which needs to be laid out
* @return the minimum dimensions to lay out the
* subcomponents of the specified container.
* @see #preferredLayoutSize
* @see java.awt.Container
* @see java.awt.Container#doLayout
*/
public Dimension minimumLayoutSize(Container target) {
synchronized (target.getTreeLock()) {
Dimension dim = new Dimension(0, 0);
int nmembers = target.getComponentCount();
for (int i = 0 ; i < nmembers ; i++) {
Component m = target.getComponent(i);
if (m.isVisible()) {
Dimension d = m.getMinimumSize();
dim.height = Math.max(dim.height, d.height);
if (i > 0) {
dim.width += hgap;
}
dim.width += d.width;
}
}
Insets insets = target.getInsets();
dim.width += insets.left + insets.right + hgap*2;
dim.height += insets.top + insets.bottom + vgap*2;
return dim;
}
}
/**
* Centers the elements in the specified row, if there is any slack.
* @param target the component which needs to be moved
* @param x the x coordinate
* @param y the y coordinate
* @param width the width dimensions
* @param height the height dimensions
* @param rowStart the beginning of the row
* @param rowEnd the the ending of the row
*/
private void moveComponents(Container target, int x, int y, int width, int height, int rowStart, int rowEnd) {
synchronized (target.getTreeLock()) {
switch (align) {
case LEFT:
break;
case CENTER:
x += width / 2;
break;
case RIGHT:
x += width;
break;
}
for (int i = rowStart ; i < rowEnd ; i++) {
Component m = target.getComponent(i);
if (m.isVisible()) {
m.setLocation(x, y + (height - m.getSize().height) / 2);//JDK1.2 porting: replace with getHeight()
x += hgap + m.getSize().width; //JDK1.2 porting: replace with getWidth()
}
}
}
}
/**
* Lays out the container. This method lets each component take
* its preferred size by reshaping the components in the
* target container in order to satisfy the constraints of
* this ToolbarLayout object.
* @param target the specified component being laid out.
* @see Container
* @see java.awt.Container#doLayout
*/
public void layoutContainer(Container target) {
synchronized (target.getTreeLock()) {
Insets insets = target.getInsets();
int maxwidth = target.getSize().width - (insets.left + insets.right + hgap*2);//JDK1.2 porting: replace with getWidth()
int nmembers = target.getComponentCount();
int x = 0, y = insets.top + vgap;
int rowh = 0, start = 0;
for (int i = 0 ; i < nmembers ; i++) {
Component m = target.getComponent(i);
if (m.isVisible()) {
Dimension d = m.getPreferredSize();
m.setSize(d.width, d.height);
if ((x == 0) || ((x + d.width) <= maxwidth)) {
if (x > 0) {
x += hgap;
}
x += d.width;
rowh = Math.max(rowh, d.height);
} else {
moveComponents(target, insets.left + hgap, y, maxwidth - x, rowh, start, i);
x = d.width;
y += vgap + rowh;
rowh = d.height;
start = i;
}
}
}
moveComponents(target, insets.left + hgap, y, maxwidth - x, rowh, start, nmembers);
}
}
/**
* Returns a string representation of this ToolbarLayout
* object and its values.
* @return a string representation of this layout.
*/
public String toString() {
String str = "";
switch (align) {
case LEFT: str = ",align=left"; break;
case CENTER: str = ",align=center"; break;
case RIGHT: str = ",align=right"; break;
}
return getClass().getName() + "[hgap=" + hgap + ",vgap=" + vgap + str + "]";
}
}
src/main/java/jas/util/NestedRuntimeException.java 0000644 0001750 0001750 00000002654 11325547132 022774 0 ustar giovanni giovanni package jas.util;
public class NestedRuntimeException extends RuntimeException implements HasNestedException
{
private Throwable detail;
/**
* Create a nested exception with the specified string
*/
public NestedRuntimeException(Throwable ex)
{
super();
detail = ex;
}
/**
* Create a remote exception with the specified string, and the
* exception specified.
*/
public NestedRuntimeException(String s, Throwable ex)
{
super(s);
detail = ex;
}
public Throwable getNestedException()
{
return detail;
}
/**
* Produce the message, include the message from the nested
* exception if there is one.
*/
public String getMessage()
{
return NestedException.formatNestedException(this);
}
/**
* Return just the super classes message
*/
public String getSimpleMessage()
{
return super.getMessage();
}
public void printStackTrace()
{
super.printStackTrace();
if (detail != null)
{
System.err.println("Nested Exception is:");
detail.printStackTrace();
}
}
public void printStackTrace(java.io.PrintStream s)
{
super.printStackTrace(s);
if (detail != null)
{
s.println("Nested Exception is:");
detail.printStackTrace(s);
}
}
public void printStackTrace(java.io.PrintWriter s)
{
super.printStackTrace(s);
if (detail != null)
{
s.println("Nested Exception is:");
detail.printStackTrace(s);
}
}
}
src/main/java/jas/util/HasNestedException.java 0000644 0001750 0001750 00000000243 11325547132 022054 0 ustar giovanni giovanni package jas.util;
public interface HasNestedException
{
public Throwable getNestedException();
public String getSimpleMessage();
public String getMessage();
}
src/main/java/jas/util/SplashScreen.java 0000644 0001750 0001750 00000004130 11325547132 020710 0 ustar giovanni giovanni package jas.util;
import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.Toolkit;
import javax.swing.ImageIcon;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JProgressBar;
import javax.swing.JWindow;
import javax.swing.SwingUtilities;
import javax.swing.border.BevelBorder;
public class SplashScreen extends JWindow
{
private JProgressBar progress;
// SplashScreen's constructor
public SplashScreen(ImageIcon CoolPicture, String message, String title)
{
// Create a JPanel so we can use a BevelBorder
JPanel PanelForBorder=new JPanel(new BorderLayout());
PanelForBorder.setLayout(new BorderLayout());
PanelForBorder.add(new JLabel(CoolPicture),BorderLayout.CENTER);
PanelForBorder.add(new JLabel(title,JLabel.CENTER),BorderLayout.NORTH);
progress = new JProgressBar(0,80);
progress.setStringPainted(true);
progress.setString(message);
PanelForBorder.add(progress,BorderLayout.SOUTH);
PanelForBorder.setBorder(new BevelBorder(BevelBorder.RAISED));
getContentPane().add(PanelForBorder);
}
public void setVisible(boolean show)
{
if (show)
{
pack();
// Plonk it on center of screen
Dimension WindowSize=getSize(),
ScreenSize=Toolkit.getDefaultToolkit().getScreenSize();
setBounds((ScreenSize.width-WindowSize.width)/2,
(ScreenSize.height-WindowSize.height)/2,WindowSize.width,
WindowSize.height);
}
super.setVisible(show);
}
public void showStatus(String CurrentStatus, int percent)
{
if (isVisible())
{
SwingUtilities.invokeLater(new UpdateStatus(CurrentStatus,percent));
}
}
public void close()
{
if (isVisible())
{
SwingUtilities.invokeLater(new CloseSplashScreen());
}
}
private class UpdateStatus implements Runnable
{
public UpdateStatus(String status, int pc)
{
message = status;
value = pc;
}
public void run()
{
progress.setValue(value);
progress.setString(message);
}
private String message;
private int value;
}
private class CloseSplashScreen implements Runnable
{
public void run()
{
setVisible(false);
dispose();
}
}
}
src/main/java/jas/util/JASEditableComboBox.java 0000644 0001750 0001750 00000024124 11325547132 022023 0 ustar giovanni giovanni package jas.util;
import java.awt.Dimension;
import java.awt.event.ActionListener;
import java.awt.event.ItemEvent;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.JTextField;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
/**
* This class is ideal if you want to have a text field for user input but
* also have a list of recently selected items available to choose from.
* Some notes on using this class:
*
*
* It is important to point this out because the KeyEvents, ActionEvents,
* and ChangeEvents described above are not how a normal editable combo
* box will generate them.
* clickDefault
* is true. This behaviour may be desirable because
* the default button is normally "clicked" when the user clicks on
* the "Enter" key, but this behaviour doesn't normally happen unless
* you add an ActionListener to the text field.addActionListener(ActionListener) on this
* object causes the ActionListener to be added to the text field.null)
* @param clickDefault whether the default button should be clicked when Enter is pressed
* @see javax.swing.JRootPane#defaultButton
*/
public JASEditableComboBox(String[] dropDownItems, boolean clickDefault)
{
m_clickDefault = clickDefault;
init(dropDownItems);
}
/**
* Creates a JASEditableComboBox with a dropDown list that will be stored in
* the UserProperties object for the Application. Invoke the saveState()
* method to have the list be updated to include the selected item.
* @param key the key that the drop-down items will be stored by
* @param nItems the maximum number of items that will be stored on the drop-down list
* @param clickDefault whether the default button should be clicked when Enter is pressed
* @see UserProperties
* @see javax.swing.JRootPane#defaultButton
*/
public JASEditableComboBox(String key, int nItems, boolean clickDefault)
{
m_clickDefault = clickDefault;
m_prop = UserProperties.getUserProperties();
m_nItems = nItems;
m_key = key;
init(m_prop.getStringArray(m_key, null));
}
/**
* Creates a JASEditableComboBox with a dropDown list that will be stored in
* the UserProperties object for the Application. Invoke the saveState()
* method to have the list be updated to include the selected item.
* @param key the key that the drop-down items will be stored by
* @param lengthKey the key that maps to the maximum number of items that will be stored on the drop-down list
* @param clickDefault whether the default button should be clicked when Enter is pressed
* @see UserProperties
* @see javax.swing.JRootPane#defaultButton
*/
public JASEditableComboBox(String key, String lengthKey, boolean clickDefault)
{
this(key, Application.getApplication().getUserProperties().getInteger(lengthKey, 4), clickDefault);
}
private void init(String[] dropDownItems)
{
// addItem(""); // the first line is blank
// JComboBox has trouble with an empty first line (it causes a tiny drop-down list)
m_dropDownItems = dropDownItems;
if (m_dropDownItems != null)
for (int i = 0; i < m_dropDownItems.length; i++)
addItem(m_dropDownItems[i]);
setEditable(true);
m_textField = (JTextField) getEditor().getEditorComponent();
m_textField.addKeyListener(this);
// super.addKeyListener(this);
}
/**
* If a key was supplied to the constructor, the drop-down list will be updated to
* include the currently selected item.
*/
public void saveState()
{
if (m_key != null)
m_prop.setStringArray(m_key,
UserProperties.updateStringArray(m_dropDownItems, getText(), m_nItems));
}
/** Returns the text currently showing in the text field. */
public String getText()
{
return m_textField.getText();
}
/** Sets the text showing in the text field. */
public void setText(String s)
{
// removeItem(""); // delete the first item (if it is blank)
if (s.equals(getItemAt(0))) return; // it's already there; nothing to do
removeItem(s); // if the item is already there, just move it to the top
insertItemAt(s, 0); // put the new text at the top
setSelectedIndex(0);
}
/** Adds a key listener to the text field, not to the JComboBox. */
public void addKeyListener(KeyListener kl)
{
if (m_textField != null)
m_textField.addKeyListener(kl);
// super.addKeyListener(kl); (suppress default key events)
}
/** This method is public as an implementation side effect; do not call. */
final public void keyReleased(KeyEvent e) {}
/** This method is public as an implementation side effect; do not call. */
final public void keyPressed(KeyEvent e)
{
if (e.getSource() != m_textField) return; // avoid cases where this listens to another by accident
fireStateChanged(); // for any key released, notify listeners with ChangeEvent
if (e.getKeyCode() == KeyEvent.VK_ENTER)
{
if (m_clickDefault)
{
JButton b = getRootPane().getDefaultButton();
if (b != null) b.doClick();
}
}
}
private void fireStateChanged()
{
Object[] listeners = listenerList.getListenerList();
for (int i = listeners.length - 2; i >= 0; i -= 2)
{
if (listeners[i] == ChangeListener.class)
{
if (m_changeEvent == null)
m_changeEvent = new ChangeEvent(this);
((ChangeListener) listeners[i+1]).stateChanged(m_changeEvent);
}
}
}
/**
* Change listeners will be notified any time the text visible in the text field changes.
* This is equivalent to having a KeyListener and an ItemListener.
* @param l the ChangeListener to add
*/
public void addChangeListener(ChangeListener l) {
listenerList.add(ChangeListener.class, l);
}
/**
* Adds an the given ActionListener to the text field.
*/
public void addActionListener(ActionListener l) {
m_textField.addActionListener(l);
}
/** This method is protected as an implementation side effect. */
final protected void fireItemStateChanged(ItemEvent event)
{
// if (m_isHandlingItemEvent) return;
// m_isHandlingItemEvent = true;
/* Object item = event.getItem();
removeItem(item);
insertItemAt(item, 0);
Causes mysterious problems on the line with removeItem(item)
This method was meant to move the selected item to the top of
the list, but an IllegalArgumentException is caused for some reason.
*/
super.fireItemStateChanged(event); // allow normal ItemEvent firing
fireStateChanged(); // when an ItemEvent is generated, also notify listeners of ChangeEvent
// m_isHandlingItemEvent = false;
}
/** Requests focus for the text field of the box. */
final public void requestFocus()
{
m_textField.requestFocus();
}
/** This method is public as an implementation side effect; do not call. */
final public void keyTyped(KeyEvent e)
{
}
/**
* Set the maximum width of the box. The default is used if this method is not called.
* @param maxWidth give a number in pixels, or -1 to use default
*/
final public void setMaxWidth(int maxWidth)
{
m_maxWidth = maxWidth;
}
/**
* Set the minimum width of the box. The default is used if this method is not called.
* @param minWidth give a number in pixels, or -1 to use default
*/
final public void setMinWidth(int minWidth)
{
m_minWidth = minWidth;
}
/**
* Encorporates the maximum width if it has been set.
* @see #setMaxWidth(int)
*/
final public Dimension getMaximumSize()
{
final Dimension d = super.getMaximumSize();
if (m_maxWidth > 0 && m_maxWidth < d.width) d.width = m_maxWidth;
return d;
}
/**
* Encorporates the minimum width if it has been set.
* @see #setMinWidth(int)
*/
final public Dimension getMinimumSize()
{
final Dimension d = super.getMinimumSize();
if (m_minWidth > 0 && m_minWidth > d.width) d.width = m_minWidth;
return d;
}
/**
* Encorporates the minimum and maximum widths if they have been set.
* @see #setMinWidth(int)
* @see #setMaxWidth(int)
*/
final public Dimension getPreferredSize()
{
final Dimension d = super.getPreferredSize();
if (m_minWidth > 0 && m_minWidth > d.width) d.width = m_minWidth;
if (m_maxWidth > 0 && m_maxWidth < d.width) d.width = m_maxWidth;
return d;
}
private int m_minWidth = -1, m_maxWidth = -1; // -1 indicates use default
private int m_nItems;
// private boolean m_isHandlingItemEvent = false;
private String[] m_dropDownItems;
private String m_key = null;
private JTextField m_textField;
private ChangeEvent m_changeEvent = null;
// private final javax.swing.plaf.ComboBoxUI m_ui = getUI();
private UserProperties m_prop = null;
private boolean m_clickDefault;
} src/main/java/jas/util/BooleanCommandTarget.java 0000644 0001750 0001750 00000000604 11325547132 022345 0 ustar giovanni giovanni package jas.util;
/**
* A boolean command target is a CommandTarget which corresponds to a command which
* may have an on/off state associated with it.
* @see SimpleCommandTarget
* @see CommandTarget
*/
public interface BooleanCommandTarget extends CommandTarget
{
/**
* Called when the on/off state changes (i.e. when the comamnd is invoked)
*/
void invoke(boolean onOff);
}
src/main/java/jas/util/ColorMenu.java 0000644 0001750 0001750 00000013462 11325547132 020231 0 ustar giovanni giovanni package jas.util;
import java.awt.Color;
import java.awt.Component;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.util.Enumeration;
import javax.swing.ButtonGroup;
import javax.swing.Icon;
import javax.swing.JColorChooser;
import javax.swing.JMenu;
import javax.swing.JMenuItem;
import javax.swing.JRadioButtonMenuItem;
import javax.swing.colorchooser.ColorSelectionModel;
import javax.swing.colorchooser.DefaultColorSelectionModel;
public class ColorMenu extends JMenu
{
public ColorMenu(String name, ColorSelectionModel model)
{
this(name, model,false);
}
public ColorMenu(String name)
{
this(name,false);
}
public ColorMenu(String name, boolean extendedColors)
{
this(name, new DefaultColorSelectionModel(),extendedColors);
}
public ColorMenu(String name, ColorSelectionModel model, boolean extendedColors)
{
this(name,model,
extendedColors ? EXTENDED_COLORS : BASIC_COLORS,
extendedColors ? EXTENDED_COLOR_NAMES : BASIC_COLOR_NAMES);
}
public ColorMenu(String name, ColorSelectionModel model, Color[] colors, String[] names)
{
super(name);
this.colorModel = model;
for (int i=0; ijava.awt.Color.
*
* @see #BASIC_COLORS
*/
public final static String[] BASIC_COLOR_NAMES =
{
"black", "dark gray", "gray",
"light gray", "blue", "cyan",
"green", "magenta", "red",
"pink", "orange", "yellow",
"white"
};
// all hail to Crayola
/**
* An array containing an expanded selection of colors.
*/
public final static Color[] EXTENDED_COLORS =
{
Color.black, new Color(0.1f, 0.1f, 0.1f),
new Color(0.2f, 0.2f, 0.2f), new Color(0.3f, 0.3f, 0.3f),
new Color(0.4f, 0.4f, 0.4f), new Color(0.5f, 0.5f, 0.5f),
new Color(0.6f, 0.6f, 0.6f), new Color(0.7f, 0.7f, 0.7f),
new Color(0.8f, 0.8f, 0.8f), new Color(0.9f, 0.9f, 0.9f),
Color.white, Color.red,
new Color(255, 136, 28), new Color(120, 62, 27),
new Color(0, 125, 32), new Color(11, 157, 150),
Color.blue, new Color(109, 0, 168),
new Color(168, 0, 126), Color.pink,
Color.orange, Color.yellow,
Color.green, Color.cyan,
new Color(164, 207, 255), new Color(225, 170, 255),
new Color(255, 170, 210)
};
/**
* An array containing names of the expanded selection of colors.
*
* @see #EXTENDED_COLORS
*/
public final static String[] EXTENDED_COLOR_NAMES =
{
"black", "grey 10%",
"grey 20%", "grey 30%",
"grey 40%", "grey 50%",
"grey 60%", "grey 70%",
"grey 80%", "grey 90%",
"white", "red",
"orange", "brown",
"green", "turquoise",
"blue", "purple",
"magenta", "pink",
"light orange", "yellow",
"light green", "cyan",
"sky blue", "violet",
"light magenta"
};
// inner classes
private class ColorMenuItem extends JRadioButtonMenuItem implements Icon
{
ColorMenuItem(Color c, String s)
{
super(s);
setIcon(this);
color = c;
group.add(this);
}
public void fireActionPerformed(ActionEvent e)
{
colorModel.setSelectedColor(color);
}
void setSelectedColor(Color c)
{
this.setSelected(c == color);
}
public int getIconHeight()
{
return size;
}
public int getIconWidth()
{
return size;
}
public void paintIcon(Component p1, Graphics g, int x, int y)
{
Color save = g.getColor();
g.setColor(color == null ? getBackground() : color);
g.fill3DRect(x,y,size,size,true);
g.setColor(save);
}
private Color color;
}
private final static int size = 12;
private class OtherColorMenuItem extends JMenuItem
{
OtherColorMenuItem()
{
super("Other...");
}
public void fireActionPerformed(ActionEvent e)
{
Color c = JColorChooser.showDialog(this,"Choose color...",colorModel.getSelectedColor());
if (c != null) colorModel.setSelectedColor(c);
}
}
}
src/main/java/jas/util/ArbitraryNameGenerator.java 0000644 0001750 0001750 00000001735 11325547132 022735 0 ustar giovanni giovanni package jas.util;
/**
* This class is a utility provided for generating arbitrary names. It
* follows the pattern A, B, C, D, ... , Z, AA, BB, CC, DD, ... , ZZ, AAA, ...
* getText() to get the file name selected.
*
*
* Be sure to invoke the saveState() method when you are done. This will set
* include the selected file in the drop-down list for the next time the panel is used.
* @author Jonas Gifford
* @author Tony Johnson
* @see JASEditableComboBox
* @see UserProperties
* @see #getText()
* @see #saveState()
*/
public class OpenLocalFilePanel extends JPanel implements ActionListener, ChangeListener
{
/**
* Creates an OpenLocalFilePanel component that you can add to a container.
* @param includePreviewButton whether a "Preview" button should be shown
* @param includeGZIP whether the GZip option should be shown
* @param key the key used to store the drop-down items and the last directory for the browse dialog
* @param filter sets a FileFilter for the browse dialog
*/
public OpenLocalFilePanel(boolean includePreviewButton, boolean includeGZIP, String key, FileFilter filter)
{
this(includePreviewButton, includeGZIP, key);
m_filter = filter;
}
/**
* Creates an OpenLocalFilePanel component that you can add to a container.
* @param includePreviewButton whether a "Preview" button should be shown
* @param includeGZIP whether the GZip option should be shown
* @param key the key used to store the drop-down items and the last directory for the browse dialog
*/
public OpenLocalFilePanel(boolean includePreviewButton, boolean includeGZIP, String key)
{
m_lastLocalDirectory_Key = key +"-directory";
m_fileName = new JASEditableComboBox(key +"-files", 4, true);
m_fileName.addChangeListener(this);
m_fileName.setMinWidth(250);
m_fileName.setMaxWidth(250);
add(m_fileName);
m_browse = new JButton("Browse...");
m_browse.addActionListener(this);
m_browse.setMnemonic('B');
add(m_browse);
if (includePreviewButton)
{
m_view = new JButton("Preview");
m_view.addActionListener(this);
m_view.setMnemonic('V');
add(m_view);
m_view.setEnabled(false);
}
if (includeGZIP)
{
m_gzip = new JCheckBox("GZIPed");
m_gzip.addActionListener(this);
m_gzip.setMnemonic('Z');
add(m_gzip);
m_gzip.setEnabled(false);
}
setBorder(BorderFactory.createTitledBorder("Enter the data file name"));
setViewEnabled();
}
/**
* The given ChangeListener will be notified when the visible
* text changes in the file name field.
*/
public void addChangeListener(ChangeListener cl)
{
m_fileName.addChangeListener(cl);
}
/**
* The given ActionListener will be notified when the "Enter" button
* is clicked in the file name text field.
*/
public void addActionListener(ActionListener al)
{
m_fileName.addActionListener(al);
}
/** This method is public as an implelentation side effect; do not call. */
public final void stateChanged(ChangeEvent e)
{
setViewEnabled();
}
private void setViewEnabled()
{
String text = m_fileName.getText();
boolean enable = text.length() > 0;
if (m_view != null) m_view.setEnabled(enable);
if (m_gzip != null)
{
m_gzip.setEnabled(enable);
m_gzip.setSelected(text.endsWith(".gz"));
}
}
/** This method is public as an implelentation side effect; do not call. */
public final void actionPerformed(ActionEvent e)
{
Object source = e.getSource();
if (source == m_browse)
{
JFileChooser dlg = new JFileChooser(m_prop.getString(m_lastLocalDirectory_Key, System.getProperty("user.home")));
dlg.setDialogTitle("Select a file");
if (m_filter != null)
dlg.setFileFilter(m_filter);
if (dlg.showDialog(this, "Select") == JFileChooser.APPROVE_OPTION)
{
final File file = dlg.getSelectedFile();
m_fileName.setText(file.getAbsolutePath());
m_prop.setString(m_lastLocalDirectory_Key, file.getParent());
}
}
else if (source == m_view)
{
try
{
java.awt.Component c = this;
while (! (c instanceof java.awt.Frame)) c = c.getParent();
new FilePreview((java.awt.Frame) c, new File(m_fileName.getText()),
m_gzip == null ? false : m_gzip.isSelected());
}
catch (Exception x)
{
JOptionPane.showMessageDialog(this,
x instanceof FileNotFoundException ? "File not found" : "Could not read file",
"Error...", JOptionPane.ERROR_MESSAGE);
}
}
}
/**
* Returns the file name showing in the text field.
* @return the selected file name
*/
public String getText()
{
String fileName = m_fileName.getText();
return fileName;
}
/**
* Includes the currently selected file name in the drop-down list for the next time
* this class is instantiated. It merely invokes the saveState() method in the
* JASEditableComboBox that is shown on the panel.
* @see JASEditableComboBox
* @see JASEditableComboBox#saveState()
*/
public void saveState()
{
m_fileName.saveState();
}
/**
* Returns whether the user has selected the GZip option. If the GZip option was not
* available (i.e., in the constructor the parameter includeGZIP was false) then it will
* return false.
* @return whether the GZip option was selected
*/
public boolean getGZIPed()
{
return m_gzip == null ? false : m_gzip.isSelected();
}
private String m_lastLocalDirectory_Key;
private JASEditableComboBox m_fileName;
private JButton m_browse, m_view = null;
private JCheckBox m_gzip = null;
final private UserProperties m_prop = UserProperties.getUserProperties();
private FileFilter m_filter = null;
}
class FilePreview extends JDialog
{
FilePreview(java.awt.Frame frame, File f, boolean gzip) throws IOException, FileNotFoundException
{
super(frame, "File preview");
JTextArea text = new JTextArea();
if (!gzip) text.read(new PreviewReader(new FileReader(f)), f);
else text.read(new PreviewReader(new InputStreamReader(new GZIPInputStream(new FileInputStream(f)))), f);
text.setEditable(false);
JScrollPane pane = new JScrollPane(text);
setContentPane(pane);
pack();
Dimension screenSize = getToolkit().getScreenSize();
Dimension dialogSize = getPreferredSize();
int maxHeight = (int) (screenSize.height * 0.6);
if (dialogSize.height > maxHeight)
dialogSize.height = maxHeight;
int maxWidth = (int) (screenSize.width * 0.9);
if (dialogSize.width > maxWidth)
dialogSize.width = maxWidth;
else dialogSize.width += 50;
Point position = getLocation();
position.translate((screenSize.width-dialogSize.width)/2,
(screenSize.height-dialogSize.height)/2);
setLocation(position);
setSize(dialogSize);
show();
}
}
class PreviewReader extends LineNumberReader
{
PreviewReader(Reader r)
{
super(r);
}
public int read() throws IOException
{
return getLineNumber()>maxLines ? -1 : super.read();
}
public int read(char[] cbuf, int off, int len) throws IOException
{
return getLineNumber()>maxLines ? -1 : super.read(cbuf,off,len);
}
public String readLine() throws IOException
{
return getLineNumber()>maxLines ? null : super.readLine();
}
private final int maxLines = 100;
} src/main/java/jas/util/UserProperties.java 0000644 0001750 0001750 00000024476 11325547132 021330 0 ustar giovanni giovanni package jas.util;
import java.awt.Rectangle;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Properties;
/**
* This class is used to store user prorerties. There is one instance for the application. The
* UserProperties object used is available from the Application object using a getUserProperties()
* method.
* @see Application
* @see Application#getUserProperties()
* @author Tony Johnson
* @author Jonas Gifford
*/
public class UserProperties extends Properties
{
/**
* The Application object will create an instance for the application and save it just before
* the application closes. Therefore, you should not have to use the constructor yourself. The
* UserProperties object used is available from the Application object using a getUserProperties()
* method.
* @see Application
* @see Application#getUserProperties()
*/
public UserProperties()
{
try
{
final InputStream input = new FileInputStream(custFile);
load(input);
input.close();
// Ignore personal customization files from early releases
if (getFloat("property-version",0)<0.9) clear();
}
catch (IOException x) {}
setFloat("property-version",0.91f);
theUserProperties = this;
}
// Constructor for use while migrating to freehep framework
protected UserProperties(Properties def)
{
super(def);
theUserProperties = this;
}
/**
* @param key the key used to store this property
* @param def a default in case the property cannot be retrieved
*/
public Rectangle getRectangle(final String key, final Rectangle def)
{
try
{
final Rectangle result = new Rectangle();
result.x = getInteger(key.concat("-x"));
result.y = getInteger(key.concat("-y"));
result.width = getInteger(key.concat("-w"));
result.height = getInteger(key.concat("-h"));
return result;
}
catch (Exception e)
{
return def;
}
}
/**
* @param key the key used to store this property
* @param rect the value to store
*/
public void setRectangle(final String key, final Rectangle rect)
{
put(key.concat("-x"), String.valueOf(rect.x));
put(key.concat("-y"), String.valueOf(rect.y));
put(key.concat("-w"), String.valueOf(rect.width));
put(key.concat("-h"), String.valueOf(rect.height));
}
/**
* @param key the key used to store this property
* @param def a default in case the property cannot be retrieved
*/
public java.awt.Color getColor(final String key, final java.awt.Color def)
{
try
{
return new java.awt.Color(getInteger(key.concat("-r")), getInteger(key.concat("-g")),
getInteger(key.concat("-b")));
}
catch (Exception e)
{
return def;
}
}
/**
* @param key the key used to store this property
* @param c the value to store
*/
public void setColor(final String key, final java.awt.Color c)
{
put(key.concat("-r"), String.valueOf(c.getRed()));
put(key.concat("-g"), String.valueOf(c.getGreen()));
put(key.concat("-b"), String.valueOf(c.getBlue()));
}
/**
* @param key the key used to store this property
* @param def a default in case the property cannot be retrieved
*/
public String[] getStringArray(final String key, final String[] def)
{
try
{
final String[] result = new String[getInteger(key +"-length")];
for (int i = 0; i < result.length; i++)
result[i] = getProperty(key +"-"+ i);
return result;
}
catch (Exception e)
{
return def;
}
}
/**
* @param key the key used to store this property
* @param sa the value to store
*/
public void setStringArray(final String key, String[] sa)
{
if (sa == null)
sa = new String[0];
// just output an array of size zero
put( key +"-length", String.valueOf(sa.length) );
for (int i = 0; i < sa.length; i++)
put(key +"-"+ i, sa[i]);
}
/**
* @param key the key used to store this property
* @param def a default in case the property cannot be retrieved
*/
public String getString(final String key, final String def)
{
try
{
final String s = getProperty(key);
return s == null ? def : s;
}
catch (Exception e)
{
return def;
}
}
/**
* @param key the key used to store this property
* @param s the value to store
*/
public void setString(final String key, String s)
{
if (s == null) s="";
put(key, s);
}
/**
* @param key the key used to store this property
* @param def a default in case the property cannot be retrieved
*/
public boolean getBoolean(final String key, final boolean def)
{
final String value = getProperty(key);
return value==null ? def : Boolean.valueOf(value).booleanValue();
}
/**
* @param key the key used to store this property
* @param value the value to store
*/
public void setBoolean(final String key, final boolean value)
{
put(key,String.valueOf(value));
}
/**
* @exception NumberFormatException if the property retrieved cannot be converted to int
* @param key the key used to store this property
*/
public int getInteger(final String key) throws NumberFormatException
{
return Integer.valueOf(getProperty(key)).intValue();
}
/**
* @param key the key used to store this property
* @param def a default in case the property cannot be retrieved
*/
public int getInteger(final String key, final int def)
{
try
{
return Integer.valueOf(getProperty(key)).intValue();
}
catch (Exception e)
{
return def;
}
}
/**
* @param key the key used to store this property
* @param f the value to store
*/
public void setFloat(final String key, final float f)
{
put(key, String.valueOf(f));
}
/**
* @param key the key used to store this property
* @param def a default in case the property cannot be retrieved
*/
public float getFloat(final String key, final float def)
{
try
{
return Float.valueOf(getProperty(key)).floatValue();
}
catch (Exception e)
{
return def;
}
}
/**
* @param key the key used to store this property
* @param i the value to store
*/
public void setInteger(final String key, final int i)
{
put(key, String.valueOf(i));
}
/**
* Saves the properties. The application does this for you just before closing, so
* you don't have to call this method.
*/
public void save() throws IOException
{
final OutputStream output = new FileOutputStream(custFile);
save(output,"Java Analysis Studio Custom Properties");
output.close();
}
/**
* This is a utility method for updating a string array of recently used items.
* Supply it with an old array and a new item. If the new item was already in the
* old array, then it is simply moved to the beginning. If it was not in the old
* array then it is placed at the front and the other items are shuffled back.
* The method will return an array with a maximum size of 4.
* @param oldArray the array to update (may safely be null)
* @param newString the new item to include
* @return the updated array
*/
public static String[] updateStringArray(final String[] oldArray, final String newString)
{
return updateStringArray(oldArray, newString, 4);
}
/**
* This is a utility method for updating a string array of recently used items.
* Supply it with an old array and a new item. If the new item was already in the
* old array, then it is simply moved to the beginning. If it was not in the old
* array then it is placed at the front and the other items are shuffled back.
* The method will return an array with a maximum size defined by the integer
* stored by the given key, or 4 if such an integer cannot be found.
* @param oldArray the array to update (may safely be null)
* @param newString the new item to include
* @param lengthKey the key used to find the maximum length of the resulting array
* @return the updated array
*/
public String[] updateStringArray(final String[] oldArray, final String newString, final String lengthKey)
{
return updateStringArray(oldArray, newString, getInteger(lengthKey, 4));
}
/**
* This is a utility method for updating a string array of recently used items.
* Supply it with an old array and a new item. If the new item was already in the
* old array, then it is simply moved to the beginning. If it was not in the old
* array then it is placed at the front and the other items are shuffled back.
* The method will return an array of a maximum size given by the nStored parameter.
* @param oldArray the array to update (may safely be null)
* @param newString the new item to include
* @param nStored the maximum size of the updated array
* @return the updated array
*/
public static String[] updateStringArray(String[] oldArray, final String newString, final int nStored)
// called by either updateRecentClasses or by updateRecentServers
// (both do basically the same thing so a private method that
// contains the essential parts of both is practical)
{
if (newString == null) return oldArray;
if (oldArray != null && oldArray.length > 0)
{
if (oldArray[0].equals(newString)) return oldArray;
/*
* If the new String is already at the front, then
* there is nothing left to do.
*/
for (int i = 1; i < oldArray.length; i++)
/*
* Begin checking from the second element
* onwards: is the String already there?
*/
{
if (oldArray[i].equals(newString))
/*
* If it is already there, put
* the new one at the front and
* shuffle the others backward.
*/
{
while (i > 0)
{
oldArray[i] = oldArray[i-1];
i--;
}
oldArray[0] = newString;
return oldArray;
}
}
if (oldArray.length < nStored)
{
final String[] result = new String[oldArray.length + 1];
result[0] = newString;
for (int i = 0; i < oldArray.length; i++)
result[i + 1] = oldArray[i];
return result;
}
else
{
for (int i = nStored-1; i > 0; i--)
oldArray[i] = oldArray[i-1];
oldArray[0] = newString;
return oldArray;
}
}
else
{
oldArray = new String[1];
oldArray[0] = newString;
return oldArray;
}
}
public static UserProperties getUserProperties()
{
return theUserProperties;
}
final private String custFile = System.getProperty("user.home").concat(File.separator+"jas.properties");
private static UserProperties theUserProperties;
}
src/main/java/jas/util/ChoiceFieldBinding.java 0000644 0001750 0001750 00000001741 11325547132 021754 0 ustar giovanni giovanni package jas.util;
import java.awt.Choice;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
class ChoiceFieldBinding extends FieldBinding implements ItemListener
{
ChoiceFieldBinding(Choice field)
{
m_field = field;
field.addItemListener(this);
}
void set(Object value) throws UnsupportedType
{
if (!(value instanceof Integer)) throw new UnsupportedType(m_field,value.getClass());
int x = ((Integer) value).intValue();
if (x != m_oldVal)
{
m_field.select(x);
m_oldVal = x;
}
}
Object get(Class type) throws UnsupportedType
{
if (type != Integer.TYPE) throw new UnsupportedType(m_field,type);
int x = m_field.getSelectedIndex();
return new Integer(x);
}
public void itemStateChanged(ItemEvent e)
{
int x = m_field.getSelectedIndex();
if (x != m_oldVal) setChanged();
notifyObservers();
}
protected void reset()
{
super.reset();
m_oldVal = m_field.getSelectedIndex();
}
private int m_oldVal = 0;
private Choice m_field;
}
src/main/java/jas/util/ColorConverter.java 0000644 0001750 0001750 00000011264 11325547132 021272 0 ustar giovanni giovanni package jas.util;
import java.awt.Color;
import java.util.Hashtable;
public final class ColorConverter
{
static final Color hexToColor(String value) throws ColorConversionException
{
try
{
return Color.decode("0x" + value.substring(1));
}
catch (Throwable t)
{
throw new ColorConversionException(value);
}
}
static final Color rgbToColor(String value) throws ColorConversionException
{
String red, blue, green;
int comma1, comma2;
int r,g,b;
comma1 = value.indexOf(",");
comma2 = value.indexOf(",", comma1 + 1);
if (comma1<2 || comma2getFinishEnabled()
* to control how the "Next" and "Finish" buttons enable.
* doEnable() will be called when a key
* is released on components registered as KeyListeners.
* This implementation is designed for when the buttons
* enable when text is added to them. For example, if you page had
*
* m_text = new JASTextField();
* text.addKeyListener(this);
*
* then the "Next" and "Finish" buttons would enable each time a key is released
* in the field text. You might define getNextEnabled()
* as follows:
*
* protected boolean getNextEnabled()
* {
* final String s = m_text.getText();
* return s != null && s.length() > 0;
* }
*
* @author Jonas Gifford
* @see JASWizard
* @see HasNextPages
* @see Finishable
* @see HasHelpPage
*/
public abstract class JASWizardPage extends JPanel implements KeyListener
{
/**
* Supply a layout manager for the panel to use. See Sun's notes on
* using
* layout managers. In the constructor of your subclass, add components
* to the page as you would add components to a regular container, using the
* add(..) methods. It is not a good idea to use AWT components
* here because those heavy-weight components do not mix well with swing's
* light-weight components. You should use only
* swing components.
* The jas.util package has a number of
* utility
* components that may be useful for these pages.
* @param lm the layout manager to use for this page.
* @see java.awt.LayoutManager
*/
public JASWizardPage(final java.awt.LayoutManager lm)
{
super(lm);
m_isFinishable = (this instanceof Finishable);
m_hasNextPages = (this instanceof HasNextPages);
}
final JASWizardPage getPrev()
{
return m_prev;
}
final void addTo(final Container c, final JASWizard wizard, final JASWizardPage prev)
{
c.add(m_number = String.valueOf(pageNumber++), this);
if (m_hasNextPages)
{
m_nextWizardPages = ((HasNextPages) this).getNextWizardPages();
if (m_nextWizardPages != null)
for (int i = 0; i < m_nextWizardPages.length; i++)
if (m_nextWizardPages[i] != null)
m_nextWizardPages[i].addTo(c, wizard, this);
}
m_wizard = wizard;
m_prev = prev;
}
/**
* Override to provide customized behaviour for enabling the "Next" button. By
* default, this method returns whether the page implements HasNextPages. If
* your page does not implement that interface, the "Next" button will never
* enable. Call doEnable() to call this method, or add your
* page as a key listener to a component, and then doEnable() will
* be called each time a key is released in that component.
* @see JASWizardPage#doEnable()
* @see HasNextPages
* @return whether to enable the "Next" button
*/
protected boolean getNextEnabled()
{
return m_hasNextPages;
}
/**
* Override to provide customized behaviour for enabling the "Finish" button. By
* default, this method returns whether the page implements Finishable. If
* your page does not implement that interface, the "Finish" button will never
* enable. Call doEnable() to call this method, or add your
* page as a key listener to a component, and then doEnable() will
* be called each time a key is released in that component.
* @see JASWizardPage#doEnable()
* @see Finishable
* @return whether to enable the "Finish" button
*/
protected boolean getFinishEnabled()
{
return m_isFinishable;
}
/**
* Forces the wizard to call getNextEnabled() and getFinishEnabled() to enable the
* buttons on the wizard. This method is called by the keyReleased(KeyEvent) method
* if you add this class as a KeyListener to a text field.
* @see JASWizardPage#getNextEnabled()
* @see JASWizardPage#getFinishEnabled()
* @see JASWizardPage#keyReleased(KeyEvent)
* @see java.awt.event.KeyEvent
* @see java.awt.event.KeyListener
*/
protected void doEnable()
{
// if (m_wizard == null) return;
m_wizard.setNextEnabled(getNextEnabled());
m_wizard.setFinishEnabled(getFinishEnabled());
m_wizard.doPrevEnabled();
if (m_isFinishable && m_hasNextPages) m_wizard.setDefaultButton();
}
final void clear()
{
if (m_hasNextPages)
{
for (int i = 0; i < m_nextWizardPages.length; i++)
if (m_nextWizardPages[i] != null)
m_nextWizardPages[i].clear();
m_nextWizardPages = null;
}
m_prev = null;
m_wizard = null;
}
/** This method is public as an implementation side effect; do not call. */
public String toString()
{
return m_number;
}
/** Call to dispose the wizard (i.e., to have it close). */
protected void dispose()
{
m_wizard.dispose();
}
final void doCancel() // preorder tree trversal
{
if (m_nextWizardPages != null)
for (int i = 0; i < m_nextWizardPages.length; i++)
if (m_nextWizardPages[i] != null)
m_nextWizardPages[i].doCancel();
onCancel();
}
/**
* This method is called if the user has canceled the wizard. By default it does nothing,
* but you can override it to perform cleanup if necessary. The wizard follows a preorder
* tree traversal, so the onCancel() methods are called starting from the bottom
* and working up each branch separately to the root.
*/
public void onCancel()
{
}
/** Override this to provide your own behaviour for key events; does nothing by default. */
public void keyPressed(final KeyEvent e) {}
/**
* If you add this class as a KeyListener and don't override this method then
* the buttons will be enabled on every key event in the definition for this method.
*/
public void keyReleased(final KeyEvent e)
{
if (e.getKeyCode() != KeyEvent.VK_ENTER) doEnable();
}
final boolean isFinishable()
{
return m_isFinishable;
}
final boolean hasNextPages()
{
return m_hasNextPages;
}
/**
* This method is called just before the page is brought to the screen. By default, it
* does nothing but you can override it to do some last-minute setup on your page.
*/
public void beforeShowing()
{
}
public void doBusy(Runnable run)
{
m_wizard.setToWaitCursor();
try
{
run.run();
}
finally
{
m_wizard.setToDefaultCursor();
}
}
protected void handleError(String message, Throwable t)
{
m_wizard.handleError(message,t);
}
/** Override this to provide your own behaviour for key events; does nothing by default. */
public void keyTyped(final KeyEvent e) {}
private JASWizardPage m_prev = null;
private JASWizard m_wizard;
private JASWizardPage[] m_nextWizardPages = null;
private final boolean m_isFinishable, m_hasNextPages;
static int pageNumber = 0;
private String m_number;
}
src/main/java/jas/util/NestedException.java 0000644 0001750 0001750 00000003272 11325547132 021425 0 ustar giovanni giovanni package jas.util;
public class NestedException extends Exception implements HasNestedException
{
private Throwable detail;
/**
* Create a remote exception
*/
public NestedException() {}
/**
* Create a remote exception with the specified string
*/
public NestedException(String s) {
super(s);
}
/**
* Create a remote exception with the specified string, and the
* exception specified.
*/
public NestedException(String s, Throwable ex) {
super(s);
detail = ex;
}
public Throwable getNestedException()
{
return detail;
}
/**
* Produce the message, include the message from the nested
* exception if there is one.
*/
public String getMessage()
{
return formatNestedException(this);
}
/**
* Return just the super classes message
*/
public String getSimpleMessage()
{
return super.getMessage();
}
public static String formatNestedException(HasNestedException t)
{
Throwable nest = t.getNestedException();
if (nest == null) return t.getSimpleMessage();
else return t.getSimpleMessage() +
"; nested exception is: \n\t" +
nest.toString();
}
public void printStackTrace()
{
super.printStackTrace();
if (detail != null)
{
System.err.println("Nested Exception is:");
detail.printStackTrace();
}
}
public void printStackTrace(java.io.PrintStream s)
{
super.printStackTrace(s);
if (detail != null)
{
s.println("Nested Exception is:");
detail.printStackTrace(s);
}
}
public void printStackTrace(java.io.PrintWriter s)
{
super.printStackTrace(s);
if (detail != null)
{
s.println("Nested Exception is:");
detail.printStackTrace(s);
}
}
}
src/main/java/jas/util/CommandTargetManager.java 0000644 0001750 0001750 00000006431 11325547132 022344 0 ustar giovanni giovanni package jas.util;
import java.util.Enumeration;
import java.util.Observer;
import java.util.Vector;
/**
* A CommandTargetManager manages a set of CommandSources and a set of CommandProcessors,
* and figure out the wiring from the CommandSources to the CommandTargets within the CommandProcessors.
* The CommandProcessors can be dynamically added and removed from the CommandTargetManager,
* as sets of commands become available or not.
*/
final public class CommandTargetManager
{
public synchronized void add(CommandProcessor processor)
{
processors.addElement(processor);
if (started)
{
Enumeration es = sources.elements();
while (es.hasMoreElements())
{
CommandSource s = (CommandSource) es.nextElement();
if (s.getTarget() == null)
{
String command = s.getCommand();
CommandTarget target = processor.acceptCommand(command);
if (target != null)
{
if (s.setTarget(target) && s instanceof Observer) processor.addObserver((Observer) s);
}
}
}
}
processor.setManager(this);
}
public synchronized void remove(CommandProcessor processor)
{
processors.removeElement(processor);
if (started)
{
Enumeration es = sources.elements();
while (es.hasMoreElements())
{
CommandSource s = (CommandSource) es.nextElement();
CommandTarget target = s.getTarget();
if (target != null)
{
if (target.getProcessor() == processor)
{
s.clearTarget();
if (s instanceof Observer) processor.deleteObserver((Observer) s);
}
}
}
}
processor.setManager(null);
}
public synchronized void add(CommandSource source)
{
sources.addElement(source);
if (started)
{
linkCommandSource(source);
}
}
public synchronized void remove(CommandSource source)
{
sources.removeElement(source);
final String command = source.getCommand();
final Enumeration ep = processors.elements();
while (ep.hasMoreElements())
{
final CommandProcessor p = (CommandProcessor) ep.nextElement();
final CommandTarget t = p.acceptCommand(command);
if (t != null)
{
source.clearTarget();
if (source instanceof Observer) p.deleteObserver((Observer) source);
}
}
}
public synchronized void start()
{
started = true;
Enumeration es = sources.elements();
while (es.hasMoreElements())
{
linkCommandSource((CommandSource) es.nextElement());
}
}
/**
* This method just links the CommandSource to the first CommandProcessor it hits
* that contains a CommandTarget that accepts the CommandSource--which is a problem
* if we want to have two simultaneously active CommandProcessors which both contain
* (different) CommandTargets of the same name (e.g. the case of the ProgramPage and
* the Console window both having a Copy command).
*/
private void linkCommandSource(final CommandSource s)
{
final String command = s.getCommand();
final Enumeration ep = processors.elements();
while (ep.hasMoreElements())
{
final CommandProcessor p = (CommandProcessor) ep.nextElement();
final CommandTarget t = p.acceptCommand(command);
if (t != null)
{
if (s.setTarget(t) && s instanceof Observer) p.addObserver((Observer) s);
}
}
}
private boolean started = false;
private final Vector processors = new Vector();
private final Vector sources = new Vector();
}
src/main/java/jas/util/UnsupportedType.java 0000644 0001750 0001750 00000000272 11325547132 021513 0 ustar giovanni giovanni package jas.util;
import java.awt.Component;
class UnsupportedType extends Exception
{
UnsupportedType(Component c,Class t)
{
super("Cannot bind type "+t+" to "+c.getClass());
}
}
src/main/java/jas/util/HasNextPages.java 0000644 0001750 0001750 00000002437 11325547132 020660 0 ustar giovanni giovanni package jas.util;
/**
* A JASWizardPage that implements this interface will have one or more subsequent
* pages. When a page that implements this interface is showing in a JASWizard,
* the "Next" button will be enabled. A sensible wizard page would implement this
* interface, or the Finishable interface, or both. If you implement neither then
* neither the "Next" nor "Finish" button will enable on the wizard, and you page
* will be a "dead end".
* @author Jonas Gifford
* @see JASWizardPage
* @see JASWizard
* @see Finishable
*/
public interface HasNextPages
{
/**
* Returns an array of all possible next pages. There could, of course, be just
* one element in this array. This method will be called before the wizard
* shows on the screen. The wizard needs to know all of the possible pages so that
* it can size itself to fit them all.
* @return an array of all possible subsequent pages
*/
public abstract JASWizardPage[] getNextWizardPages();
/**
* This method is called when the user clicks on the "Next" button. You must
* return a page that was in the array returned by getNextWizardPages.
* @return a JASWizardPage that was included in the array returned by getNextWizardPages
*/
public abstract JASWizardPage getNext();
}
src/main/java/jas/util/PropertyPage.java 0000644 0001750 0001750 00000005147 11325547132 020750 0 ustar giovanni giovanni package jas.util;
import java.util.Enumeration;
import java.util.Observable;
import java.util.Observer;
import java.util.Vector;
import javax.swing.JPanel;
public abstract class PropertyPage extends JPanel implements Observer
{
public PropertyPage()
{
}
public void addNotify()
{
super.addNotify();
if (getParent() instanceof PropertyPage)
((PropertyPage) getParent()).addInnerPropertyPage(this);
// If the parent is a property page then notify the parent.
}
void addInnerPropertyPage(PropertyPage p)
{
if (getParent() instanceof PropertyPage)
// pass the notification to the topmost page
((PropertyPage) getParent()).addInnerPropertyPage(p);
else
{
// this is the top page, so deal with the notification...
if (m_innerPropPages == null) m_innerPropPages = new Vector();
m_innerPropPages.addElement(p); // keep a list of inner pages
}
}
public void setPropertySite(PropertySite dlg)
{
m_dlg = dlg;
}
public void doDataExchange(boolean set,Object hist)
{
Enumeration e = m_propertyBindings.elements();
while (e.hasMoreElements())
{
PropertyBinding p = (PropertyBinding) e.nextElement();
p.doDataExchange(set,hist);
}
m_changed = false;
}
protected void addBinding(PropertyBinding bind)
{
m_propertyBindings.addElement(bind);
bind.addObserver(this);
}
public void update(Observable o, Object arg)
{
setChanged(true);
}
protected void setChanged(boolean set)
{
m_changed = set;
if (m_dlg != null) m_dlg.callEnable();
}
boolean hasChanged()
{
return m_changed;
}
/**
* called when the page is deactivated, either due to another page
* being selected, or due to the dialog being disposed of.
*/
protected void deactivate()
{
}
/**
* called when the page is activated, either because it is the default
* page, or because its tab was selected. This is called before doDataExchanged
*/
protected void activate()
{
}
boolean hasValidInput()
{
Enumeration e = m_propertyBindings.elements();
PropertyBinding b;
while (e.hasMoreElements())
{
b = (PropertyBinding) e.nextElement();
if (! b.hasValidInput())
return false;
}
if (m_innerPropPages != null) // check also all inner pages
{
e = m_innerPropPages.elements();
while (e.hasMoreElements())
if (!((PropertyPage) e.nextElement()).hasValidInput())
return false;
}
return true;
}
// default return indicates no help topic; override to specify otherwise
public String getHelpTopic()
{
return null;
}
private PropertySite m_dlg;
private boolean m_changed = false;
private Vector m_propertyBindings = new Vector();
private Vector m_innerPropPages = null;
}
src/main/java/jas/util/Debug.java 0000644 0001750 0001750 00000004700 11325547132 017347 0 ustar giovanni giovanni package jas.util;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;
import java.io.PrintWriter;
public class Debug {
public static void init() {
if (debugInitialized) return;
try {
theStdOutFile = new File(theStdOutFileName);
theStdErrFile = new File(theStdErrFileName);
PrintStream outFile = new PrintStream(
new BufferedOutputStream(
new FileOutputStream(theStdOutFile)));
PrintStream errFile = new PrintStream(
new BufferedOutputStream(
new FileOutputStream(theStdErrFile)));
theFileOutWriter = new PrintWriter(outFile, true);
theFileErrWriter = new PrintWriter(errFile, true);
} catch (IOException eh) {
System.out.println("IOException initializing Debug system!");
eh.printStackTrace();
}
debugInitialized = true;
}
public static void setFileOutput() {
redirectToFile = true;
}
public static void setNormalOutput() {
redirectToFile = false;
}
public static void pushFileOutput() {
oldRedirectValue = redirectToFile;
redirectToFile = true;
}
public static void pushNormalOutput() {
oldRedirectValue = redirectToFile;
redirectToFile = false;
}
public static void popOutput() {
redirectToFile = oldRedirectValue;
}
public static void say(String s) {
init();
if (redirectToFile) {
theFileOutWriter.println(s);
} else {
theConsoleOutWriter.println(s);
}
}
public static void complain(String s) {
init();
if (redirectToFile) {
theFileErrWriter.println(s);
} else {
theConsoleErrWriter.println(s);
}
}
public static void debugSay(String s) {
if (debugMode) {
say(s);
}
}
public static void debugComplain(String s) {
if (debugMode) {
complain(s);
}
}
private static File theStdOutFile;
private static File theStdErrFile;
private static final PrintWriter theConsoleOutWriter = new PrintWriter(System.out, true);
private static final PrintWriter theConsoleErrWriter = new PrintWriter(System.err, true);
private static PrintWriter theFileOutWriter;
private static PrintWriter theFileErrWriter;
private static final String theStdOutFileName = "stdout.txt";
private static final String theStdErrFileName = "stderr.txt";
private static final boolean debugMode = true;
private static boolean debugInitialized = false;
private static boolean redirectToFile = false;
private static boolean oldRedirectValue = false;
}
src/main/java/jas/util/HelpInterfaceImpl.java 0000644 0001750 0001750 00000006341 11325547132 021657 0 ustar giovanni giovanni /*
* @(#)HelpInterfaceImpl.java
*/
package jas.util;
import java.awt.Window;
import java.net.URL;
import java.util.Enumeration;
import javax.help.DefaultHelpBroker;
import javax.help.HelpSet;
import javax.help.HelpSetException;
import javax.help.Map.ID;
import javax.swing.SwingUtilities;
/**
* HelpInterfaceImpl implements the HelpInterface. It is the only class which contains
* references to javax.help.* Since it is only referred to as a String in a Class.forName
* call, this allows the system to function if the help system is missing.
*
* @author Peter Armstrong
*
*/
class HelpInterfaceImpl implements HelpInterface
{
HelpInterfaceImpl() throws HelpException
{
createHelpSet();
}
public void showHelpTopic(String helpTopicTarget, Window owner)
{
showHelpTopic(helpTopicTarget, "TOC", owner);
}
public void showHelpTopic(String helpTopicTarget, String navigatorView, Window owner)
{
try
{
ID id = ID.create(helpTopicTarget, mainHS);
if (id == null) { id = mainHS.getHomeID(); }
mainHB.setActivationWindow(owner);
mainHB.setCurrentView(navigatorView);
mainHB.setCurrentID(id);
mainHB.setDisplayed(true);
}
catch (Exception eek)
{
Application.getApplication().error("Sorry, the help topic could not be found.");
}
}
public void modalDialogOpening(final java.awt.Dialog dlg)
{
if (debugHelp) System.out.println("modelDialogOpening "+mainHB.isDisplayed());
// It turns out that the modal dialog workaround must be done AFTER the dialog
// has become modal. This code seems to do the trick, but how robust is it??
// TODO: If we were smarter, we could keep track of who owned the help broker
// before the dialog was opened, and put things back afterwards.
// If java were smarter (and allowed multiple independent GUI apps within one
// JVM), this would all be unnecessary.
if (mainHB.isDisplayed()) SwingUtilities.invokeLater(new Runnable()
{
public void run()
{
mainHB.setActivationWindow(dlg);
mainHB.setDisplayed(true);
}
});
}
public void modalDialogClosing(java.awt.Dialog dlg)
{
if (debugHelp) System.out.println("modelDialogClosing "+mainHB.isDisplayed());
mainHB.setActivationWindow(null);
}
/**
* Find the HelpSet and initialize the main HelpBroker (mainHB).
*/
private void createHelpSet() throws HelpException
{
Enumeration e = Application.getApplication().getHelpLocations();
while (e.hasMoreElements())
{
try
{
URL u = (URL) e.nextElement();
if (debugHelp) System.out.print("Looking for hs at: "+u+" ... ");
mainHS = new HelpSet(null, u);
if (debugHelp) System.out.println("Success");
break;
}
catch (HelpSetException e1)
{
if (debugHelp) System.out.println("Failed");
}
}
if (mainHS == null) throw new HelpException("No HelpSet found");
try
{
mainHB = (DefaultHelpBroker) mainHS.createHelpBroker();
}
catch (Throwable x)
{
throw new HelpException("Could not create Help Broker",x);
}
}
private HelpSet mainHS;
private DefaultHelpBroker mainHB;
private final boolean debugHelp = System.getProperty("debugHelp") != null;
}
class HelpException extends NestedException
{
HelpException(String s) { super(s); }
HelpException(String s, Throwable t) { super(s,t); }
}
src/main/java/jas/util/NestedCommandProcessor.java 0000644 0001750 0001750 00000001413 11325547132 022740 0 ustar giovanni giovanni package jas.util;
import java.util.Enumeration;
import java.util.Vector;
public class NestedCommandProcessor extends CommandProcessor
{
public synchronized void addSubProcessor(CommandProcessor p)
{
subProcessors.addElement(p);
if (manager != null) manager.add(p);
}
public synchronized void removeSubProcessor(CommandProcessor p)
{
subProcessors.removeElement(p);
if (manager != null) manager.remove(p);
}
protected void setManager(CommandTargetManager m)
{
Enumeration e = subProcessors.elements();
while (e.hasMoreElements())
{
CommandProcessor p = (CommandProcessor) e.nextElement();
if (m == null) manager.remove(p);
else m.add(p);
}
manager = m;
}
private CommandTargetManager manager;
private Vector subProcessors = new Vector();
}
src/main/java/jas/util/JASState.java 0000644 0001750 0001750 00000000131 11325547132 017731 0 ustar giovanni giovanni package jas.util;
public interface JASState
{
public void setEnabled(boolean state);
}
src/main/java/jas/util/border/ 0000755 0001750 0001750 00000000000 11325547132 016732 5 ustar giovanni giovanni src/main/java/jas/util/border/ShadowBorder.java 0000644 0001750 0001750 00000004704 11325547132 022165 0 ustar giovanni giovanni package jas.util.border;
import java.awt.Color;
import java.awt.Component;
import java.awt.Graphics;
import java.awt.Insets;
import javax.swing.border.AbstractBorder;
/**
* Draws a drop shadow border. Designed to be used as part of
* a compound border in combination with a line border.
*/
public class ShadowBorder extends AbstractBorder
{
public final int NORTHEAST = 1;
public final int NORTHWEST = 2;
public final int SOUTHEAST = 3;
public final int SOUTHWEST = 4;
/**
* Creates a ShadowBorder with default properties
*/
public ShadowBorder()
{
this(null,0,5);
}
/**
* Creates a ShadowBorder
* @param c The color for the shadow. If null the border will be drawn using a darker version of the components background color.
* @param orientation One of NORTHEAST, NORTHWEST, SOUTHEAST, SOUTHWEST
* @param size The size of the shadow in pixels
*/
public ShadowBorder(Color c,int orientation, int size)
{
this.color = c;
this.orientation = orientation;
this.size = size;
}
public static ShadowBorder createShadowBorder()
{
return defaultInstance;
}
public void paintBorder(Component comp, Graphics g, int x, int y, int width, int height)
{
g.setColor(color == null ? comp.getBackground().darker() : color);
switch (orientation)
{
case NORTHWEST:
g.fillRect(x,y,width-size,size); // horiz
g.fillRect(x,y,size,height-size); // vert
case NORTHEAST:
g.fillRect(x+size,y,width-size,size); // horiz
g.fillRect(x+width-size,y,size,height-size); // vert
case SOUTHWEST:
g.fillRect(x,y+height-size,width-size,size); // horiz
g.fillRect(x,y+size,size,height-size); // vert
case SOUTHEAST:
default:
g.fillRect(x+size,y+height-size,width-size,size); // horiz
g.fillRect(x+width-size,y+size,size,height-size); // vert
}
}
public Insets getBorderInsets(Component c)
{
return getBorderInsets(c,new Insets(0,0,0,0));
}
public Insets getBorderInsets(Component c, Insets i)
{
switch (orientation)
{
case NORTHWEST:
i.left=size;
i.right=0;
i.top=size;
i.bottom=0;
break;
case NORTHEAST:
i.left=0;
i.right=size;
i.top=size;
i.bottom=0;
break;
case SOUTHWEST:
i.left=size;
i.right=0;
i.top=0;
i.bottom=size;
break;
case SOUTHEAST:
default:
i.left=0;
i.right=size;
i.top=0;
i.bottom=size;
}
return i;
}
private int size;
private Color color;
private int orientation;
private static ShadowBorder defaultInstance = new ShadowBorder();
}
src/main/java/jas/plot/ 0000755 0001750 0001750 00000000000 11325547132 015456 5 ustar giovanni giovanni src/main/java/jas/plot/MutableLegendEntry.java 0000644 0001750 0001750 00000000213 11325547132 022047 0 ustar giovanni giovanni package jas.plot;
public interface MutableLegendEntry extends LegendEntry
{
void setTitle(String newTitle);
boolean titleIsChanged();
}
src/main/java/jas/plot/ColorMap.java 0000644 0001750 0001750 00000021332 11325547132 020036 0 ustar giovanni giovanni package jas.plot;
import jas.hist.JASHist2DHistogramStyle;
import java.awt.Color;
/**
*
* @author The FreeHEP team @ SLAC.
*
*/
public class ColorMap {
private JASHist2DHistogramStyle style;
public ColorMap(JASHist2DHistogramStyle style) {
this.style = style;
}
public Color getColor(double value) {
int colorMode = style.getColorMapScheme();
int Red;
int Green;
int Blue;
Color tempColor;
if (colorMode == 0) //warm
{
if (value <= 0) {
return new Color(255, 0, 0);
} else if (value >= 1) {
return new Color(255, 255, 0);
} else {
return new Color(255, 155 + (int) (100 * value), 0);
}
} else if (colorMode == 1) { //cool
if (value <= 0) {
return new Color(0, 0, 255);
} else if (value >= 1) {
return new Color(0, 255, 255);
} else {
return new Color(0, 155 + (int) (100 * value), 255);
}
} else if (colorMode == 2) { //thermal
if (value <= 0) {
return new Color(0, 0, 0);
} else if (value >= 1) {
return new Color(255, 0, 0);
} else {
return new Color(155 + (int) (100 * value), 0, 0);
}
} else if (colorMode == 3) {
return getRainbowColor(value,1);
} else if (colorMode == 4) { //GrayScale
if (value <= 0) {
return new Color(0, 0, 0);
} else if (value >= 1) {
return new Color(255, 255, 255);
} else {
return new Color(155 + (int) (100 * value), 155 + (int) (100 * value), 155 + (int) (100 * value));
}
} else { //User Defined
///////////Calculate Red Values///////////
if (style.getStartDataColor().getRed() > style.getEndDataColor().getRed()) {
Red = style.getStartDataColor().getRed() - (int) ((style.getStartDataColor().getRed() - style.getEndDataColor().getRed()) * value);
} else if (style.getStartDataColor().getRed() < style.getEndDataColor().getRed()) {
Red = style.getStartDataColor().getRed() + (int) ((style.getEndDataColor().getRed() - style.getStartDataColor().getRed()) * value);
} else {
Red = style.getStartDataColor().getRed();
}
///////////Calculate Green Values///////////
if (style.getStartDataColor().getGreen() > style.getEndDataColor().getGreen()) {
Green = style.getStartDataColor().getGreen() - (int) ((style.getStartDataColor().getGreen() - style.getEndDataColor().getGreen()) * value);
} else if (style.getStartDataColor().getGreen() < style.getEndDataColor().getGreen()) {
Green = style.getStartDataColor().getGreen() + (int) ((style.getEndDataColor().getGreen() - style.getStartDataColor().getGreen()) * value);
} else {
Green = style.getStartDataColor().getGreen();
}
///////////Calculate Blue Values///////////
if (style.getStartDataColor().getBlue() > style.getEndDataColor().getBlue()) {
Blue = style.getStartDataColor().getBlue() - (int) ((style.getStartDataColor().getBlue() - style.getEndDataColor().getBlue()) * value);
} else if (style.getStartDataColor().getBlue() < style.getEndDataColor().getBlue()) {
Blue = style.getStartDataColor().getBlue() + (int) ((style.getEndDataColor().getBlue() - style.getStartDataColor().getBlue()) * value);
} else {
Blue = style.getStartDataColor().getBlue();
}
if (value <= 0) {
return style.getStartDataColor();
} else if (value >= 1) {
return style.getEndDataColor();
} else {
return new Color(Red, Green, Blue);
}
}
//UserDefined
}
//getHistColor
/** The red values. */
private final static int[] red =
{ 120, 115, 111, 106, 102, 97, 93, 88, 84, 79, 75, 70, 66, 61,
57, 52, 48, 43, 39, 34, 30, 25, 21, 16, 12, 7, 3, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 5,
10, 14, 19, 23, 28, 32, 37, 41, 46, 50, 55, 59, 64, 68, 73, 77,
82, 86, 91, 95, 100, 104, 109, 113, 118, 123, 127, 132, 136, 141, 145, 150,
154, 159, 163, 168, 172, 177, 181, 186, 190, 195, 199, 204, 208, 213, 217, 222,
226, 231, 235, 240, 244, 249, 253, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255 };
/** The green values. */
private final static int[] green =
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 6, 11,
15, 20, 24, 29, 33, 38, 42, 47, 51, 56, 60, 65, 69, 74, 78, 83,
87, 92, 96, 101, 105, 110, 114, 119, 123, 128, 132, 137, 141, 146, 150, 155,
159, 164, 168, 173, 177, 182, 186, 191, 195, 200, 204, 209, 213, 218, 222, 227,
231, 236, 241, 245, 250, 254, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 252, 248, 243, 239, 234, 230, 225, 221, 216,
212, 207, 203, 198, 194, 189, 185, 180, 176, 171, 167, 162, 158, 153, 149, 144,
140, 135, 131, 126, 122, 117, 113, 108, 104, 99, 95, 90, 86, 81, 77, 72,
68, 63, 59, 54, 50, 45, 41, 36, 32, 27, 23, 18, 14, 9, 5, 0 };
/** The blue values. */
private final static int[] blue =
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 251, 247, 242, 238, 233, 229, 224, 220, 215, 211,
206, 202, 197, 193, 188, 184, 179, 175, 170, 166, 161, 157, 152, 148, 143, 139,
134, 130, 125, 121, 116, 112, 107, 103, 98, 94, 89, 85, 80, 76, 71, 67,
62, 58, 53, 49, 44, 40, 35, 31, 26, 22, 17, 13, 8, 4, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
private Color getRainbowColor(double value, float alpha) {
if (value < 0 || value > 1) throw new IllegalArgumentException("Value must be in range [0,1]: "+value);
int bin = (int) Math.floor(value*red.length);
if (bin >= red.length) bin = red.length-1;
int a = (int) (alpha*256);
if (a < 0) a = 0;
if (a > 255) a = 255;
return new Color(red[bin],green[bin],blue[bin],a);
}
}
src/main/java/jas/plot/DataAreaLayout.java 0000644 0001750 0001750 00000033355 11325547132 021172 0 ustar giovanni giovanni package jas.plot;
import java.awt.Component;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Insets;
import java.awt.LayoutManager2;
public final class DataAreaLayout implements LayoutManager2
{
public static final String X_AXIS = "x";
public static final String Y_AXIS_LEFT = "yl";
public static final String Y_AXIS_RIGHT = "yr";
public static final String X_AXIS_LABEL = "xl";
public static final String Y_AXIS_LEFT_LABEL = "yll";
public static final String Y_AXIS_RIGHT_LABEL = "yrl";
public void addLayoutComponent(final Component c, final Object constraints)
{
if (c instanceof Axis)
{
if (X_AXIS.equals(constraints)) {xAxis = (Axis) c; xAxisLength = -1;}
else if (Y_AXIS_LEFT.equals(constraints)) {yAxis_left = (Axis) c; yLeftAxisLength = -1;}
else if (Y_AXIS_RIGHT.equals(constraints)) {
yAxis_right = (Axis) c; yRightAxisLength = -1;
if ( c instanceof ColorMapAxis )
hasColorMap = true;
}
}
else if (c instanceof EditableLabel)
{
if (X_AXIS_LABEL.equals(constraints)) xAxis_label = (EditableLabel) c;
else if (Y_AXIS_LEFT_LABEL.equals(constraints)) yAxis_left_label = (EditableLabel) c;
else if (Y_AXIS_RIGHT_LABEL.equals(constraints)) yAxis_right_label = (EditableLabel) c;
}
}
public void addLayoutComponent(final String s, final Component c)
{
addLayoutComponent(c,s);
}
public void removeLayoutComponent(final Component c)
{
if (c == xAxis) xAxis = null;
else if (c == yAxis_left) yAxis_left = null;
else if (c == yAxis_right) {
yAxis_right = null;
if ( hasColorMap)
hasColorMap = false;
}
else if (c == xAxis_label) xAxis_label = null;
else if (c == yAxis_left_label) yAxis_left_label = null;
else if (c == yAxis_right_label) yAxis_right_label = null;
}
private int getLabelSpaceOnTop()
{
int labelSpaceOnTop = 0;
if (yAxis_left_label != null && ! yAxis_left_label.isRotated() )
labelSpaceOnTop = yAxis_left_label.getPreferredSize().height + pad;
if (yAxis_right_label != null && /* no label without matching axis */ yAxis_right != null && ! yAxis_right_label.isRotated() )
labelSpaceOnTop = Math.max(yAxis_right_label.getPreferredSize().height, labelSpaceOnTop);
return labelSpaceOnTop;
}
public void layoutContainer(final Container parent)
{
if (yAxis_left != null && xAxis != null) // there must be a left axis; right one optional
{
final Dimension parentSize = parent.getSize();
if (parentSize.width <= 0 || parentSize.height <= 0) return; // not sure why this is necessary
final int labelSpaceOnTop = getLabelSpaceOnTop();
final int labelSpaceOnBottom = xAxis_label != null ? xAxis_label.getPreferredSize().height + pad : 0;
final Insets insets = parent.getInsets();
final int width = parentSize.width - insets.right - insets.left - (hasColorMap ? 30 : 0);
final int height = parentSize.height - insets.top - insets.bottom - labelSpaceOnTop - labelSpaceOnBottom;
// we know that the axes always use the same objects for space requirements, so we can obtain
// final references to them now and have them calculate values later as many times as we need
final SpaceRequirements x = xAxis.type.spaceRequirements;
final SpaceRequirements y_left = yAxis_left.type.spaceRequirements;
final SpaceRequirements y_right = yAxis_right != null ? yAxis_right.type.spaceRequirements : nullSpaceRequirements;
// now we have to set the axis lengths
if (lastParentSize != null && xAxisLength > 0) xAxisLength += parentSize.width - lastParentSize.width;
else xAxisLength = parentSize.width * 9 / 10; // a first estimate
if (lastParentSize != null && yLeftAxisLength > 0) yLeftAxisLength += parentSize.height - lastParentSize.height;
else yLeftAxisLength = parentSize.height * 9 / 10; // a first estimate
if (lastParentSize != null && yRightAxisLength > 0 && yAxis_right != null)
yRightAxisLength += parentSize.height - lastParentSize.height;
else yRightAxisLength = parentSize.height * 9 / 10; // a first estimate
int xorigin;
int yorigin;
int distFromRightSide;
int iterationCounter = 0;
final int maxIterations = 8; // If we do more that this many iterations, we will give up and quit
int x_smallest = 0;
int y_left_smallest = 0;
int y_right_smallest = 0;
final int normalMaximumNumberOfIterations = 2; // If we do more than this many iterations, we have an
// unusual situation, so we will start work in plan B
final int criticalNumberOfIterations = 5; // If we do more than this many iterations, plan A has definitely
// failed so we need to start implement the work we started earlier
// Definitions of plans A and B:
// * In plan A, we hope to get an exact fit. This works in one or two iterations in the vast majority of cases.
// We just keep adjusting the axis lengths until we get that perfect fit.
// * Plan B is our last resort when plan A takes too many iterations. We will take the smallest axis lengths
// from all of the attempts and use those for the lengths. This means that an all axes will assume
// smaller lengths than they actually get, so there will be fewer labels than there could be.
while (true)
{
boolean allLengthsAreAdequate = true;
if (iterationCounter < criticalNumberOfIterations)
// This is the normal case, where we have few iterations so far
{
xAxis.assumeAxisLength(xAxisLength);
yAxis_left.assumeAxisLength(yLeftAxisLength);
if (yAxis_right != null) yAxis_right.assumeAxisLength(yRightAxisLength);
}
else
// We've gone too far for plan A, so we'd better start using the minimum values we've
// been tracking
{
if (debug) System.out.println("******* USED BACKUP PLAN FOR LAYOUT");
xAxis.assumeAxisLength(x_smallest);
yAxis_left.assumeAxisLength(y_left_smallest);
if (yAxis_right != null) yAxis_right.assumeAxisLength(y_right_smallest);
}
xorigin = Math.max(x.width, y_left.width) + Axis.padAroundEdge;
yorigin = Math.max(Math.max(x.height , y_left.height), y_right.height) + Axis.padAroundEdge;
distFromRightSide = Math.max(x.flowPastEnd, y_right.width) + Axis.padAroundEdge;
final int minWidth = xorigin + distFromRightSide + xAxisLength + insets.left + insets.right;
if (minWidth != parentSize.width)
{
xAxisLength = Math.max(0,xAxisLength + parentSize.width - minWidth);
allLengthsAreAdequate = false;
}
int minHeight = yorigin + y_left.flowPastEnd + Axis.padAroundEdge +
yLeftAxisLength + insets.top + insets.bottom;
if (minHeight != parentSize.height)
{
yLeftAxisLength = Math.max(0,yLeftAxisLength + parentSize.height - minHeight);
allLengthsAreAdequate = false;
}
if (yAxis_right != null)
{
minHeight = yorigin + y_right.flowPastEnd + Axis.padAroundEdge
+ yRightAxisLength + insets.top + insets.bottom;
if (minHeight != parentSize.height)
{
yRightAxisLength = Math.max (0,yRightAxisLength + parentSize.height - minHeight);
allLengthsAreAdequate = false;
}
}
iterationCounter++;
if (allLengthsAreAdequate)
{
if (debug) System.out.println("layout required "+ iterationCounter +" iteration(s)");
break;
}
if (iterationCounter > normalMaximumNumberOfIterations)
// If this executes, we've had more than normal number of
// iterations, so we start tracking the sizes to come up with
// a size that will work for all sizes
{
if (xAxisLength > 0)
if (x_smallest == 0) x_smallest = xAxisLength;
else if (xAxisLength < x_smallest) x_smallest = xAxisLength;
if (yLeftAxisLength > 0)
if (y_left_smallest == 0) y_left_smallest = yLeftAxisLength;
else if (yLeftAxisLength < y_left_smallest) y_left_smallest = yLeftAxisLength;
if (yAxis_right != null && yRightAxisLength > 0)
if (y_right_smallest == 0) y_right_smallest = yRightAxisLength;
else if (yRightAxisLength < y_right_smallest) y_right_smallest = yRightAxisLength;
}
if (iterationCounter >= maxIterations) throw new LayoutFailed();
}
if (yAxis_left_label != null && yAxis_left_label.isRotated()) xorigin += yAxis_left_label.getPreferredSize().getHeight()+5;
yAxis_left.setLocation(xorigin - y_left.width + insets.left, insets.top + labelSpaceOnTop);
yAxis_left.setSize(y_left.width, height - yorigin + y_left.height);
if (yAxis_left_label != null)
{
if ( yAxis_left_label.isRotated() ) {
yAxis_left_label.setLocation(pad, pad + insets.top + (height - (int)yAxis_left_label.getPreferredSize().getWidth())/2);
yAxis_left_label.setSize((int)yAxis_left_label.getPreferredSize().getWidth(),(int)yAxis_left_label.getPreferredSize().getWidth());
} else {
yAxis_left_label.setLocation(insets.left + pad , insets.top + pad);
yAxis_left_label.setSize(yAxis_left_label.getPreferredSize());
}
}
if ( yAxis_right_label != null && yAxis_right_label.isRotated() )
distFromRightSide += (int) yAxis_right_label.getPreferredSize().getHeight();
xAxis.setLocation(xorigin - x.width + insets.left, height + insets.top - yorigin + labelSpaceOnTop);
xAxis.setSize(width - xorigin + x.width - distFromRightSide + Axis.padAroundEdge + x.flowPastEnd , x.height);
if (xAxis_label != null)
{
final Dimension prefSize = xAxis_label.getPreferredSize();
xAxis_label.setLocation((width - xorigin - distFromRightSide) / 2 + xorigin - prefSize.width / 2 + insets.left,
parentSize.height - insets.bottom - pad - prefSize.height);
xAxis_label.setSize(prefSize);
}
if (yAxis_right != null)
{
yAxis_right.setLocation(width - distFromRightSide - insets.left ,insets.top + labelSpaceOnTop);
yAxis_right.setSize(y_right.width+(hasColorMap?30:0), height - yorigin + y_right.height);
if (yAxis_right_label != null)
{
final Dimension prefSize = yAxis_right_label.getPreferredSize();
if ( yAxis_right_label.isRotated() ) {
yAxis_right_label.setLocation(parentSize.width - insets.right - pad - prefSize.height , pad + insets.top + (height - (int)prefSize.getWidth())/2);
yAxis_right_label.setSize((int)prefSize.getWidth(), (int) prefSize.getWidth());
} else {
yAxis_right_label.setLocation(parentSize.width - insets.right - pad - prefSize.width , insets.top + pad);
yAxis_right_label.setSize(prefSize);
}
}
}
lastParentSize = parentSize;
}
}
public Dimension minimumLayoutSize(final Container parent)
{
return preferredLayoutSize(parent);
}
public Dimension maximumLayoutSize(final Container parent)
{
return preferredLayoutSize(parent);
}
public Dimension preferredLayoutSize(final Container parent)
{
return new Dimension(10,10);
}
/**
* Returns the alignment along the x axis. This specifies how
* the component would like to be aligned relative to other
* components. The value should be a number between 0 and 1
* where 0 represents alignment along the origin, 1 is aligned
* the furthest away from the origin, 0.5 is centered, etc.
*/
public float getLayoutAlignmentX(final Container parent)
{
return 0.5f;
}
/**
* Returns the alignment along the y axis. This specifies how
* the component would like to be aligned relative to other
* components. The value should be a number between 0 and 1
* where 0 represents alignment along the origin, 1 is aligned
* the furthest away from the origin, 0.5 is centered, etc.
*/
public float getLayoutAlignmentY(final Container parent)
{
return 0.5f;
}
/**
* Invalidates the layout, indicating that if the layout manager
* has cached information it should be discarded.
*/
public void invalidateLayout(final Container target)
{
}
private Axis xAxis;
private Axis yAxis_left;
private Axis yAxis_right;
private EditableLabel xAxis_label;
private EditableLabel yAxis_left_label;
private EditableLabel yAxis_right_label;
private static final int pad = 5;
private static final SpaceRequirements nullSpaceRequirements = new SpaceRequirements(); // all fields are zero
private int xAxisLength = -1;
private int yLeftAxisLength = -1;
private int yRightAxisLength = -1;
private boolean hasColorMap = false;
private Dimension lastParentSize;
private static final boolean debug;
static
{
boolean result;
try
{
result = System.getProperty("debugDataAreaLayout") != null;
}
catch (SecurityException x) // in case we are in an applet!
{
result = false;
}
debug = result;
}
}
class LayoutFailed extends RuntimeException
{
}
src/main/java/jas/plot/SetablePlotGraphics.java 0000644 0001750 0001750 00000000212 11325547132 022213 0 ustar giovanni giovanni package jas.plot;
import java.awt.Graphics;
public interface SetablePlotGraphics extends PlotGraphics
{
void setGraphics(Graphics g);
}
src/main/java/jas/plot/PrintHelper.java 0000644 0001750 0001750 00000004204 11325547132 020555 0 ustar giovanni giovanni package jas.plot;
import java.awt.Component;
public abstract class PrintHelper
{
/**
* Print the specified component
*/
public abstract void printTarget(Component target) throws Exception;
/**
* Create an instance of a PrintHelper
*/
public static PrintHelper instance()
{
PrintHelper result;
try
{
Class c = Class.forName("jas.plot.java2.PrintHelper12");
result = (PrintHelper) c.newInstance();
}
catch (Throwable x)
{
result = new jas.plot.java1.PrintHelper11();
}
if (debugPrinting) System.out.println("PrintHelper created a "+result.getClass().getName());
return result;
}
public static final int ORIENTATION_BEST_FIT = 0;
public static final int ORIENTATION_PORTRAITE = 1;
public static final int ORIENTATION_LANDSCAPE = 2;
/**
* Set the print orientation
* @param orientation One of ORIENTATION_BEST_FIT,ORIENTATION_PORTRAITE,ORIENTATION_LANDSCAPE
*/
public abstract void setOrientation(int orientation);
/**
* Controls whether the PrintHelper will scale an image up to make it fill the page
* (PrintHelper will always try to shrink to fit)
*/
public abstract void setScaleUp(boolean scaleUp);
/**
* Method to allow component being painted to find out if it is being printed.
* This is a crude workaround for limitations which make it impossible for a SwingComponent
* to tell whether its paint method is being called to print it or to display it on the screen.
* Obviously this static method only works if PrintHelper is being used to do the printing.
*/
public static boolean isPrinting()
{
return Thread.currentThread() == printingThread;
}
public void setPrintingThread(Thread thread)
{
if (debugPrinting) System.out.println("Printing thread="+thread);
printingThread = thread;
}
public Thread printingThread() {
return printingThread;
}
private static Thread printingThread;
protected static final boolean debugPrinting;
static
{
boolean result;
try
{
result = System.getProperty("debugPrinting") != null;
}
catch (SecurityException x) // in case we are in an applet!
{
result = false;
}
debugPrinting = result;
}
}
src/main/java/jas/plot/LegendEntry.java 0000644 0001750 0001750 00000000200 11325547132 020531 0 ustar giovanni giovanni package jas.plot;
public interface LegendEntry
{
void paintIcon(PlotGraphics g, int size, int height);
String getTitle();
}
src/main/java/jas/plot/MovableObject.java 0000644 0001750 0001750 00000030563 11325547132 021044 0 ustar giovanni giovanni package jas.plot;
import jas.util.ColorMenu;
import java.awt.Color;
import java.awt.Component;
import java.awt.Cursor;
import java.awt.Graphics;
import java.awt.Insets;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseEvent;
import javax.swing.BorderFactory;
import javax.swing.JMenu;
import javax.swing.JMenuItem;
import javax.swing.JPopupMenu;
import javax.swing.JRadioButtonMenuItem;
import javax.swing.border.AbstractBorder;
import javax.swing.border.Border;
import javax.swing.border.CompoundBorder;
import javax.swing.border.LineBorder;
import javax.swing.colorchooser.ColorSelectionModel;
import javax.swing.colorchooser.DefaultColorSelectionModel;
/**
* Base class for any object that can be moved around using handles
*/
public abstract class MovableObject extends PlotComponent implements HasPopupItems, JASPlotMouseListener
{
public MovableObject(String prefix)
{
this.prefix = prefix;
super.setBorder(border);
}
protected String getPrefix()
{
return prefix;
}
public void setMovableObjectBounds(int p1, int p2, int p3, int p4)
{
super.setBounds(p1, p2, p3, p4);
hasBeenMoved = true;
hasBeenResized = true;
}
public void setMovableObjectBounds(Rectangle r)
{
super.setBounds(r);
hasBeenMoved = true;
hasBeenResized = true;
}
public void setBorder(Border newBorder)
{
Border oldBorder = super.getBorder();
if (oldBorder instanceof CompoundBorder) oldBorder = ((CompoundBorder) oldBorder).getOutsideBorder();
super.setBorder(newBorder == null ? oldBorder : new CompoundBorder(oldBorder,newBorder));
}
public int getBorderType()
{
return getBorderType(getInsideBorder());
}
public Border getInsideBorder()
{
Border oldBorder = super.getBorder();
if (oldBorder instanceof CompoundBorder) return ((CompoundBorder) oldBorder).getInsideBorder();
if (oldBorder instanceof HandleBorder) return null;
return oldBorder;
}
public void modifyPopupMenu(JPopupMenu menu, Component source)
{
menu.add(new BorderMenu(prefix));
ColorSelectionModel cm = new DefaultColorSelectionModel()
{
public Color getSelectedColor()
{
if (!isPaintingBackground()) return null;
return getBackground();
}
public void setSelectedColor(Color c)
{
setBackground(c);
}
};
menu.add(new BackgroundColorMenu(prefix,cm));
}
final void showHandles()
{
handlesVisible = true;
paintBorder(getGraphics());
saveCursor = getCursor();
currentCursor = Cursor.DEFAULT_CURSOR;
}
final void hideHandles()
{
handlesVisible = false;
setCursor(saveCursor);
Component p = getParent(); // Parent can be null when window is closing
if (p != null) p.repaint(); // Since we may overlap our siblings
}
public final void mouseEventNotify(final MouseEvent me)
{
if (handlesVisible)
{
if (me.getID() == MouseEvent.MOUSE_ENTERED)
{
saveCursor = getCursor();
}
else if (me.getID() == MouseEvent.MOUSE_EXITED)
{
setCursor(saveCursor);
}
else if (me.getID() == MouseEvent.MOUSE_PRESSED)
{
// What happens when the mouse is pressed depends on where it is
// It either starts some sort of resize or a move
if (currentCursor == Cursor.MOVE_CURSOR)
{
dragOffset = me.getPoint();
}
else
{
}
}
else if (me.getID() == MouseEvent.MOUSE_RELEASED)
{
dragOffset = null;
}
}
}
final void mouseMotionEventNotify(final MouseEvent me)
{
if (!handlesVisible) return;
if (me.getID() == MouseEvent.MOUSE_DRAGGED)
{
if (currentCursor == Cursor.MOVE_CURSOR)
{
Point p = me.getPoint();
Point x = getLocation();
p.translate(x.x,x.y);
if (dragOffset != null) p.translate(-dragOffset.x,-dragOffset.y);
setLocation(p);
hasBeenMoved = true;
}
else
{
final Rectangle b = getBounds();
final Point p = me.getPoint();
if (currentCursor == Cursor.E_RESIZE_CURSOR)
{
b.width = p.x;
}
else if (currentCursor == Cursor.W_RESIZE_CURSOR)
{
b.width -= p.x;
b.x += p.x;
}
else if (currentCursor == Cursor.N_RESIZE_CURSOR)
{
b.height -= p.y;
b.y += p.y;
}
else if (currentCursor == Cursor.S_RESIZE_CURSOR)
{
b.height = p.y;
}
else if (currentCursor == Cursor.NE_RESIZE_CURSOR)
{
// code from N:
b.height -= p.y;
b.y += p.y;
// code from E:
b.width = p.x;
}
else if (currentCursor == Cursor.NW_RESIZE_CURSOR)
{
// code from N:
b.height -= p.y;
b.y += p.y;
// code from W:
b.width -= p.x;
b.x += p.x;
}
else if (currentCursor == Cursor.SE_RESIZE_CURSOR)
{
// code from S:
b.height = p.y;
// code from E:
b.width = p.x;
}
else if (currentCursor == Cursor.SW_RESIZE_CURSOR)
{
// code from S:
b.height = p.y;
// code from W:
b.width -= p.x;
b.x += p.x;
}
else return;
hasBeenResized = true;
setBounds(b);
validate();
}
}
else if (me.getID() == MouseEvent.MOUSE_MOVED)
{
currentCursor = border.getCursor(getBounds(),me.getPoint());
((Component) me.getSource()).setCursor(Cursor.getPredefinedCursor(currentCursor));
}
}
public boolean hasBeenResized() {
return hasBeenResized;
}
public boolean hasBeenMoved() {
return hasBeenMoved;
}
public void restoreDefaultLayout() {
hasBeenResized = false;
hasBeenMoved = false;
}
public boolean hasDefaultLayout() {
return ! hasBeenMoved() && ! hasBeenResized();
}
// Are these methods really needed?
public void resizeMovableObject(int w, int h) {
hasBeenResized = true;
this.setSize(w,h);
}
public void moveMovableObject(int x, int y) {
hasBeenMoved = true;
this.setLocation(x,y);
}
/**
* Clicking on a movable object will by default cause its handles to appear.
*/
private String prefix; // Prefix for popup menu items
private boolean hasBeenResized = false;
private boolean hasBeenMoved = false;
private int currentCursor;
private Point dragOffset;
private Cursor saveCursor;
private boolean handlesVisible;
private static final HandleBorder border = new HandleBorder(Color.blue);
final private static class HandleBorder extends AbstractBorder
{
private Color lineColor;
/**
* Creates a handle border with the specified color and a
* @param color the color for the border
*/
HandleBorder(Color color)
{
lineColor = color;
}
/**
* Paints the border for the specified component with the
* specified position and size.
* @param c the component for which this border is being painted
* @param g the paint graphics
* @param x the x position of the painted border
* @param y the y position of the painted border
* @param width the width of the painted border
* @param height the height of the painted border
*/
public void paintBorder(Component c, Graphics g, int x, int y, int width, int height)
{
if (((MovableObject) c).handlesVisible && !PrintHelper.isPrinting())
{
Color oldColor = g.getColor();
int xx = x+thick2;
int yy = y+thick2;
int ww = width-thickness;
int hh = height-thickness;
Rectangle[] h = getHandles(xx,yy,ww,hh);
g.setColor(lineColor);
g.drawRect(xx, yy, ww,hh);
for (int i=0; iTimeAxis type.
* @see TimeAxis
* @author Jonas Gifford
*/
public interface TimeCoordinateTransformation extends CoordinateTransformation
{
/** Returns a pixel value for a time value. */
double convert(long d);
}
src/main/java/jas/plot/DataArea.java 0000644 0001750 0001750 00000020332 11325547132 017763 0 ustar giovanni giovanni package jas.plot;
import java.awt.CardLayout;
import java.awt.Component;
import java.awt.Graphics;
import java.util.Vector;
import javax.swing.JComponent;
public class DataArea extends MovableObject
{
public DataArea(final Axis x, final Axis y)
{
this();
//xAxis = x;
//yAxis[0] = y;
add(x,DataAreaLayout.X_AXIS);
add(y,DataAreaLayout.Y_AXIS_LEFT);
}
public DataArea()
{
super("Data Area");
normal = new NormalDataArea();
setLayout(cardLayout = new CardLayout());
super.add(normal,"Normal");
// Use "jas.plot.usePG2" property to switch between PG2 settings
// Default is PG2_ALWAYS
String usePG2Property = System.getProperty("jas.plot.usePG2", "true");
if (usePG2Property.equalsIgnoreCase("false") || usePG2Property.equalsIgnoreCase("never") ) usePG2(PG2_NEVER);
else if (usePG2Property.equalsIgnoreCase("printing") ) usePG2(PG2_PRINTING);
else usePG2(PG2_ALWAYS);
}
public void add(final Axis a, final Object constraint)
{
if (a == null) return;
// safe to use == instead of .equals() ?
if (constraint == DataAreaLayout.X_AXIS) { if (xAxis != null) remove(xAxis); xAxis = a; }
else if (constraint == DataAreaLayout.Y_AXIS_LEFT) { if (yAxis[0] != null) remove(yAxis[0]); yAxis[0] = a; }
else if (constraint == DataAreaLayout.Y_AXIS_RIGHT) { if (yAxis[1] != null) remove(yAxis[1]); yAxis[1] = a; }
normal.add(a, constraint);
}
public void add(final EditableLabel a, final Object constraint)
{
if (a == null) return;
// safe to use == instead of .equals() ?
if (constraint == DataAreaLayout.X_AXIS_LABEL) { if (xAxisLabel != null) remove(xAxisLabel); xAxisLabel = a; }
else if (constraint == DataAreaLayout.Y_AXIS_LEFT_LABEL) { if (yAxisLabel[0] != null) remove(yAxisLabel[0]); yAxisLabel[0] = a; }
else if (constraint == DataAreaLayout.Y_AXIS_RIGHT_LABEL) { if (yAxisLabel[1] != null) remove(yAxisLabel[1]); yAxisLabel[1] = a; }
normal.add(a, constraint);
}
public void add(final Overlay o)
{
overlays.addElement(o);
o.containerNotify(normal);
}
public void setSpecialComponent(Component special)
{
if (special == this.special) return;
if (special == null)
{
cardLayout.first(this);
super.remove(this.special);
this.special = null;
}
else
{
super.add(special,"Special");
cardLayout.last(this);
if (this.special != null) super.remove(this.special);
this.special = special;
}
}
public void remove(final Component c)
{
if (c == xAxis) xAxis = null;
else if (c == yAxis[0]) yAxis[0] = null;
else if (c == yAxis[1]) yAxis[1] = null;
else if (c == xAxisLabel) xAxisLabel = null;
else if (c == yAxisLabel[0]) yAxisLabel[0] = null;
else if (c == yAxisLabel[1]) yAxisLabel[1] = null;
normal.remove(c);
}
public Axis getXAxis()
{
return xAxis;
}
public Axis getYAxis()
{
return yAxis[0];
}
public Axis getYAxis(final int index)
{
return yAxis[index];
}
public void remove(final Overlay o)
{
overlays.removeElement(o);
o.containerNotify(null);
}
public EditableLabel getLabel(final Axis a)
{
if (a == xAxis) return xAxisLabel;
if (a == yAxis[0]) return yAxisLabel[0];
if (a == yAxis[1]) return yAxisLabel[1];
return null;
}
public void setLabel(final Axis a, final EditableLabel l)
{
if (a == xAxis ) add(l,DataAreaLayout.X_AXIS_LABEL);
else if (a == yAxis[0]) add(l,DataAreaLayout.Y_AXIS_LEFT_LABEL);
else if (a == yAxis[1]) add(l,DataAreaLayout.Y_AXIS_RIGHT_LABEL);
}
/**
* Set the mode for using JDK 1.2 graphics (call has no effect if running under JDK 1.1)
* @param mode One of PG2_NEVER, PG2_PRINTING, PG2_ALWAYS
*/
public void usePG2(int mode)
{
if (mode != PG2_NEVER && pg2 == null)
{
try
{
Class c = Class.forName("jas.plot.java2.PlotGraphics12");
pg2 = (SetablePlotGraphics) c.newInstance();
}
catch (Throwable x)
{
//x.printStackTrace();
usepg2 = PG2_NEVER;
return;
}
}
if (usepg2 != mode)
{
usepg2 = mode;
repaint();
}
}
private final Vector overlays = new Vector();
/** Never use JDK 1.2 graphics */
public final static int PG2_NEVER = 0;
/** Use JDK 1.2 graphics only when printing */
public final static int PG2_PRINTING = 1;
/** Use JDK 1.2 graphics always */
public final static int PG2_ALWAYS = 2;
private int usepg2 = PG2_NEVER;
private NormalDataArea normal;
private Component special;
private CardLayout cardLayout;
private SetablePlotGraphics pg2;
private SetablePlotGraphics pg1 = new jas.plot.java1.PlotGraphics11();
private Axis xAxis;
private final Axis[] yAxis = new Axis[2];
private EditableLabel xAxisLabel;
private final EditableLabel[] yAxisLabel = new EditableLabel[2];
private class NormalDataArea extends JComponent implements OverlayContainer
{
NormalDataArea()
{
setLayout(new DataAreaLayout());
}
public void print(Graphics g)
{
try
{
printing = true;
super.print(g);
super.invalidate();
}
finally
{
printing = false;
}
}
public void paintChildren(final Graphics g)
{
// Painting the contents of a plot can occasionally throw an exception
// (due to bugs!) which has the undesirable effect of causing painting
// of the entire UI to get confused, so here we will catch any exceptions
// and continue with painting the rest of the UI
boolean pg2now = (usepg2 == PG2_ALWAYS) || (usepg2 == PG2_PRINTING && isPrinting());
SetablePlotGraphics pg = pg2now ? pg2 : pg1;
try
{
//long start = System.currentTimeMillis();
super.paintChildren(g);
pg.setGraphics(g);
xAxis.paint(pg);
if (yAxis[0] != null) yAxis[0].paint(pg);
if (yAxis[1] != null) yAxis[1].paint(pg);
pg.setClip(xAxis.getMinLocation(),xAxis.getMaxLocation(),yAxis[0].getMinLocation(),yAxis[0].getMaxLocation());
for (int i=0,s=overlays.size(); iTimeAxis, etc.) has a type-specific coordinate transformation
* that extends this interface and contains methods specific to the type
* on that axis.
* @see DoubleCoordinateTransformation
* @see TimeCoordinateTransformation
* @see DateCoordinateTransformation
* @see StringCoordinateTransformation
* @author Jonas Gifford
*/
public interface CoordinateTransformation
{
}
src/main/java/jas/plot/FontDialog.java 0000644 0001750 0001750 00000001147 11325547132 020352 0 ustar giovanni giovanni package jas.plot;
import jas.util.FontChooserPanel;
import jas.util.JASDialog;
import java.awt.Font;
import java.awt.Frame;
final class FontDialog extends JASDialog
{
FontDialog(final Frame parent, final Font currentFont)
{
super(parent, "Set font", true, OK_BUTTON | CANCEL_BUTTON);
m_chooser = new FontChooserPanel(currentFont.getName(), currentFont.getStyle(), currentFont.getSize());
setContentPane(m_chooser);
}
Font showDialog()
{
pack();
if (doModal() && m_chooser.inputIsValid())
return m_chooser.getSpecifiedFont();
else
return null;
}
private final FontChooserPanel m_chooser;
}
src/main/java/jas/plot/Axis.java 0000644 0001750 0001750 00000024277 11325547132 017241 0 ustar giovanni giovanni package jas.plot;
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.Point;
import java.awt.event.ActionEvent;
import javax.swing.JCheckBoxMenuItem;
import javax.swing.JMenuItem;
import javax.swing.JPopupMenu;
import javax.swing.SwingUtilities;
/**
* This class represents a plot axis as a GUI component. It depends on a subclass
* of AxisType to implement the type-specific properties necessary for
* a meaningful axis.
* @see AxisType
* @author Jonas Gifford
*/
public class Axis extends PlotComponent implements HasPopupItems
{
/** Represents vertical orientation for both labels and axes. */
public static final int VERTICAL = 1;
/** Represents horizontal orientation for both labels and axes. */
public static final int HORIZONTAL = 2;
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* begin constructors
*/
/**
* This consturctor is primarily for object deserialization. It creates a vertical axis
* object with a numeric (class DoubleAxis) which will be on the left side.
* @see DoubleAxis
*/
public Axis()
{
this(new DoubleAxis(), VERTICAL, true);
}
/**
* Creates a new axis object. If this axis is vertical it will be on the left side of
* the plot.
* @param type the AxisType object that represents the data type for this axis
* @param axisOrientation the orientation of the axis (use constants
* Axis.HORIZONTAL and Axis.VERTICAL)
*/
public Axis(final AxisType type, final int axisOrientation)
{
this(type, axisOrientation, true);
}
/**
* Creates a new axis object, using a numeric axis (class DoubleAxis). If this
* axis is vertical it will be on the left side of the plot.
* @see DoubleAxis
* @param axisOrientation the orientation of the axis (use constants
* Axis.HORIZONTAL and Axis.VERTICAL)
*/
public Axis(final int axisOrientation)
{
this(new DoubleAxis(), axisOrientation, true);
}
/**
* Creates a numerical axis object (uses class DoubleAxis).
* @see DoubleAxis
* @param axisOrientation the orientation of the axis (use constants
* Axis.HORIZONTAL and Axis.VERTICAL)
* @param onLeftSide whether this axis is on the left
*/
public Axis(final int axisOrientation, final boolean onLeftSide)
{
this(new DoubleAxis(), axisOrientation, onLeftSide);
}
/**
* Creates a vertical axis object.
* @param type the AxisType object that represents the data type for this axis
* @param onLeftSide whether this axis is on the left
*/
public Axis(final AxisType type, final boolean onLeftSide)
{
this(type, VERTICAL, onLeftSide);
}
/**
* Creates a new axis object.
* @param type the AxisType object that represents the data type for this axis
* @param axisOrientation the orientation of the axis (use constants
* Axis.HORIZONTAL and Axis.VERTICAL)
* @param onLeftSide whether this axis is on the left
*/
public Axis(final AxisType type, final int axisOrientation, final boolean onLeftSide)
{
this.type = type;
this.axisOrientation = axisOrientation;
this.onLeftSide = onLeftSide;
type.setAxis(this);
}
/*
* end constructors
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
public void modifyPopupMenu(final JPopupMenu menu, final Component source)
{
if (menu.getComponentCount() > 0) menu.addSeparator();
menu.add(new FontMenuItem(this,"Axis"));
final DataArea parent = (DataArea) SwingUtilities.getAncestorOfClass(DataArea.class, this);
final EditableLabel label = parent.getLabel(this);
menu.add(new JCheckBoxMenuItem("Show Axis Label", label != null)
{
final protected void fireActionPerformed(final ActionEvent e)
{
if (isSelected())
{
final EditableLabel newLabel = new EditableLabel("Label","Axis Label");
parent.setLabel(Axis.this, newLabel);
newLabel.edit();
}
else
{
parent.remove(label);
}
}
});
if (label != null)
{
menu.add(new JMenuItem("Edit label text")
{
final protected void fireActionPerformed(final ActionEvent e)
{
label.edit();
}
});
}
}
/** Sets the AxisType for this axis. */
public final void setType(final AxisType type)
{
this.type = type;
type.setAxis(this);
if (isVisible)
{
revalidate();
}
}
public final void setFont(Font font)
{
super.setFont(font);
type.labelsValid = false;
revalidate();
}
/** Returns the AxisType for this axis. */
public final AxisType getType()
{
return type;
}
/**
* Used by superclasses to convert coordinates.
*/
public final int getMinLocation()
{
if (axisOrientation == VERTICAL)
{
return size.height - type.spaceRequirements.height + location.y;
}
else
{
return type.spaceRequirements.width + location.x;
}
}
/**
* Used by superclasses to convert coordinates.
*/
public final int getMaxLocation()
{
if (axisOrientation == VERTICAL)
{
return padAroundEdge + location.y + type.spaceRequirements.flowPastEnd;
}
else
{
return size.width - padAroundEdge + location.x - type.spaceRequirements.flowPastEnd;
}
}
final void paint(final PlotGraphics g)
{
final Point actualOrigin = new Point(onLeftSide ? type.spaceRequirements.width:
size.width - type.spaceRequirements.width, size.height -
type.spaceRequirements.height);
actualOrigin.translate(location.x,location.y);
g.setFont(getFont());
final int tickLength = type.getMajorTickMarkLength();
if (axisOrientation == VERTICAL)
{
g.setColor(getAxisColor());
BasicStroke s = new BasicStroke(getAxisWidth(), BasicStroke.CAP_SQUARE, BasicStroke.JOIN_ROUND, 10, null, 0);
g.setStroke(s);
g.drawLine(actualOrigin.x, actualOrigin.y,
actualOrigin.x, location.y+padAroundEdge + type.spaceRequirements.flowPastEnd); // axis line
g.setColor(getAxisOriginDotColor());
g.drawRect(actualOrigin.x - 1, actualOrigin.y - 1,
actualOrigin.x + 1, actualOrigin.y + 1); // a little box at the origin
type.paintAxis(g, actualOrigin.x, actualOrigin.y, actualOrigin.y - padAroundEdge - type.spaceRequirements.flowPastEnd - location.y,
getTextColor(), getMajorTickMarkColor(), getMinorTickMarkColor());
}
else if (axisOrientation == HORIZONTAL)
{
g.setColor(getAxisColor());
BasicStroke s = new BasicStroke(getAxisWidth(), BasicStroke.CAP_SQUARE, BasicStroke.JOIN_ROUND, 10, null, 0);
g.setStroke(s);
g.drawLine(actualOrigin.x, actualOrigin.y,
location.x + size.width - padAroundEdge - type.spaceRequirements.flowPastEnd, actualOrigin.y); // axis line
type.paintAxis(g, actualOrigin.x, actualOrigin.y, size.width - padAroundEdge - type.spaceRequirements.flowPastEnd - actualOrigin.x + location.x,
getTextColor(), getMajorTickMarkColor(), getMinorTickMarkColor());
}
}
/** This method is public as an implementation side-effect; do not call. */
final public void setBounds(final int x, final int y, final int width, final int height)
{
// Cache component size and location here to speed up other calculations
// NB Assumes all other methods (setSize, setLocation etc are routed via
// this method. It would be safer to do this in set processComponentEvent,
// but there is a delay in calling that method which causes strange effects
// when resizing components.
size.setSize(width,height);
location.setLocation(x,y);
super.setBounds(x,y,width,height);
}
public final int getAxisOrientation()
{
return axisOrientation;
}
protected final void setAxisOrientation(final int i)
{
axisOrientation = i;
}
public final boolean getOnLeftSide()
{
return onLeftSide;
}
public final void setOnLeftSide(final boolean left)
{
onLeftSide = left;
}
final void assumeAxisLength(final int axisLength)
{
if (axisLength != lastAxisLength || !type.labelsValid)
{
type.assumeAxisLength(axisLength);
lastAxisLength = axisLength;
}
}
public Color getAxisColor()
{
if (axisColor != null) return axisColor;
return getForeground();
}
public void setAxisWidth(float newWidth)
{
axisWidth = newWidth;
}
public float getAxisWidth()
{
return axisWidth;
}
public void setAxisColor(Color newColor)
{
axisColor = newColor;
}
public Color getAxisOriginDotColor()
{
if (axisOriginDotColor != null) return axisOriginDotColor;
return getAxisColor();
}
public void setAxisOriginDotColor(Color newColor)
{
axisOriginDotColor = newColor;
}
public Color getMajorTickMarkColor()
{
if (majorTickMarkColor != null) return majorTickMarkColor;
return getAxisColor();
}
public void setMajorTickMarkColor(Color newColor)
{
majorTickMarkColor = newColor;
}
public Color getMinorTickMarkColor()
{
if (minorTickMarkColor != null) return minorTickMarkColor;
return getAxisColor();
}
public void setMinorTickMarkColor(Color newColor)
{
minorTickMarkColor = newColor;
}
public Color getTextColor()
{
if (textColor != null) return textColor;
return getAxisColor();
}
public void setTextColor(Color newColor)
{
textColor = newColor;
}
/** The color of the axis line. */
private Color axisColor = null;
/** The width of the axis line. */
private float axisWidth = 1.0f;
/** The color of the dot at the origin. */
private Color axisOriginDotColor = null;
/** The color of the major tick marks. */
private Color majorTickMarkColor = null;
/** The color of the minor tick marks. */
private Color minorTickMarkColor = null;
/** The color of the axis labels. */
private Color textColor = null;
private int axisOrientation;
AxisType type;
private final Point location = new Point();
private final Dimension size = new Dimension();
private boolean isVisible = false;
boolean onLeftSide;
private static FontMenuItem fontMenuItem = null;
private int lastAxisLength = -1;
// cross-axis constants
static final int padAroundEdge = 3; // how far things must be from the edge of the component
static final int padFromAxis = 7; // how far the text must be from the axis
}
src/main/java/jas/plot/ColorMapAxis.java 0000644 0001750 0001750 00000002664 11325547132 020672 0 ustar giovanni giovanni package jas.plot;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Insets;
import java.awt.RenderingHints;
import java.awt.geom.Line2D;
/**
*
* @author The FreeHEP team @ SLAC.
*
*/
public class ColorMapAxis extends Axis {
private ColorMap colorMap;
public ColorMapAxis(ColorMap colorMap) {
super(Axis.VERTICAL,false);
this.colorMap = colorMap;
}
public void setZminZmax(double zmin, double zmax) {
((DoubleAxis)getType()).setMin(zmin);
((DoubleAxis)getType()).setMax(zmax);
}
public void setLogarithmic(boolean isLog) {
((DoubleAxis)getType()).setLogarithmic(isLog);
}
public void paintComponent(Graphics g) {
Graphics2D g2 = (Graphics2D) g;
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF);
Dimension size = getSize();
Insets insets = getInsets();
double ww = 30 - insets.left - insets.right - 3 ;
double hh = size.getHeight() - insets.top - insets.bottom - 7;
double x1 = insets.left+2;
double x2 = x1 + ww;
double yy = insets.top+3;
Line2D line = new Line2D.Double();
for (int i=0; i
*
* CENTER_TEXT_IN_DIVISION: a tick mark and label will be centered in a divisionTEXT_BESIDE_DIVISION: a tick mark and label will be on either side of a divisionsetLabelPlacementStyle(int) to change the setting.
* setLabels(String[]) from left to right on a horizontal axis and from bottom to top
* on a vertical axis.
* @see #CENTER_TEXT_IN_DIVISION
* @see #TEXT_BESIDE_DIVISION
* @see #setLabelPlacementStyle(int)
* @see #setLabels(String[])
* @author Jonas Gifford
*/
public final class StringAxis extends AxisType implements StringCoordinateTransformation
{
/** Represents a display style where a tick and label are centered in a division. */
public static final int CENTER_TEXT_IN_DIVISION = 1;
/** Represents a display style where a tick and label are on either side of a division. */
public static final int TEXT_BESIDE_DIVISION = 2;
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* begin constructors
*/
/**
* Creates a new string axis type object, with labels and ticks centered in a division.
* @see #CENTER_TEXT_IN_DIVISION
*/
public StringAxis()
{
this(CENTER_TEXT_IN_DIVISION);
}
/**
* Creates a new string axis type object.
* @param labelPlacementStyle how to place labels (supply either CENTER_TEXT_IN_DIVISION or
* TEXT_BESIDE_DIVISION)
* @see #CENTER_TEXT_IN_DIVISION
* @see #TEXT_BESIDE_DIVISION
*/
public StringAxis(final int labelPlacementStyle)
{
this.labelPlacementStyle = labelPlacementStyle;
}
/*
* end constructors
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* begin public interface
*/
/**
* Sets the label placement style. Supply either CENTER_TEXT_IN_DIVISION or
* TEXT_BESIDE_DIVISION.
* @see #CENTER_TEXT_IN_DIVISION
* @see #TEXT_BESIDE_DIVISION
*/
public void setLabelPlacementStyle(final int labelPlacementStyle)
{
this.labelPlacementStyle = labelPlacementStyle;
}
/**
* Returns the label placement style: either CENTER_TEXT_IN_DIVISION or
* TEXT_BESIDE_DIVISION.
* @see #CENTER_TEXT_IN_DIVISION
* @see #TEXT_BESIDE_DIVISION
*/
public int getLabelPlacementStyle()
{
return labelPlacementStyle;
}
/**
* Sets the labels to display.
*/
public void setLabels(String[] labels)
{
if (hash == null)
hash = new Hashtable(labels.length);
else
hash.clear();
this.labels = labels;
for (int i = 0; i < labels.length; i++)
hash.put(labels[i], new Integer(i));
if (axis != null && axis.getAxisOrientation() == Axis.HORIZONTAL && (layers == null || layers.length != labels.length))
layers = new int[labels.length];
labelsValid = false; // we set this flag so that when the Axis object gets told to assume a new length
// it knows that we need to calculate new space requirements (because of the new
// labels)
}
/** Returns the labels used for this axis. */
public String[] getLabels()
{
return labels;
}
/*
* end public interface
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* begin axis type methods
*/
CoordinateTransformation getCoordinateTransformation()
{
return this;
}
void assumeAxisLength(final int lengthOfAxisLine)
{
if ( labels == null || labels.length == 0) return;
labelsValid = true;
Font font = axis.getFont();
final FontMetrics fm = axis.getToolkit().getFontMetrics(font);
final int distanceFromEnd = labelPlacementStyle == CENTER_TEXT_IN_DIVISION ?
lengthOfAxisLine / labels.length / 2 : 0;
if (axis.getAxisOrientation() == Axis.HORIZONTAL)
{
// the overflow is set here...
if (labelPlacementStyle == CENTER_TEXT_IN_DIVISION)
{
spaceRequirements.flowPastEnd = Math.max(fm.stringWidth(labels[labels.length - 1]) / 2 -
lengthOfAxisLine / labels.length / 2, 0);
}
else
spaceRequirements.flowPastEnd = fm.stringWidth(labels[labels.length - 1]) / 2;
// then the width...
spaceRequirements.width = Math.max(0, fm.stringWidth(labels[0]) / 2 - distanceFromEnd);
// now for the height...
// extraRows is the number of rows of text besides the first one
int extraRows = 0;
if (lengthOfAxisLine > 0)
// this test fails only when the plot has been shrunk so far that the x axis has been
// pushed to the right of the y axis but it is important to test for this because
// if lengthOfAxisLine is negative we get an infinite regress where the int array
// gets bigger and bigger until all of the memory is gone
{
int[] lastTakenPixelOnRow = new int[3];
// we wouldn't really expect more than three rows, but we will expand if necessary
final int n = labelPlacementStyle == TEXT_BESIDE_DIVISION ? labels.length - 1 : labels.length;
int xStart = spaceRequirements.width + Axis.padAroundEdge;
if (labelPlacementStyle == CENTER_TEXT_IN_DIVISION)
xStart += lengthOfAxisLine / labels.length / 2;
for (int i = 0; i < labels.length; i++)
{
final int x = xStart + i * lengthOfAxisLine / n;
int row = 0;
final int halfOfStringWidth = fm.stringWidth(labels[i]) / 2;
if (i != 0)
{
while (x - halfOfStringWidth < lastTakenPixelOnRow[row])
{
if (++row >= lastTakenPixelOnRow.length)
{
int[] newArray = new int[lastTakenPixelOnRow.length * 2];
System.arraycopy(lastTakenPixelOnRow, 0, newArray, 0, lastTakenPixelOnRow.length);
lastTakenPixelOnRow = newArray;
}
}
}
if (row > extraRows)
extraRows = row;
lastTakenPixelOnRow[row] = x + halfOfStringWidth + minSpaceBetweenLabels;
layers[i] = row;
}
}
spaceRequirements.height = fm.getMaxAscent() + fm.getMaxDescent() + Axis.padFromAxis
// for each additional row we add the line height
+ extraRows * fm.getHeight();
}
else
{
spaceRequirements.width = longestStringLength(fm,labels) + Axis.padFromAxis;
spaceRequirements.height = Math.max(0, fm.getAscent() / 2 + fm.getMaxDescent() - distanceFromEnd);
if (labelPlacementStyle == CENTER_TEXT_IN_DIVISION)
{
spaceRequirements.flowPastEnd = Math.max(fm.getMaxAscent() - fm.getAscent() / 2 -
lengthOfAxisLine / labels.length / 2, 0);
}
else
spaceRequirements.flowPastEnd = fm.getMaxAscent() - fm.getAscent() / 2;
}
}
void paintAxis(final PlotGraphics g,
final double originX, final double originY, final double length,
final Color textColor, final Color majorTickColor, final Color minorTickColor)
{
if (labels != null)
{
final int n = labelPlacementStyle == TEXT_BESIDE_DIVISION ? labels.length - 1 : labels.length;
final FontMetrics fm = g.getFontMetrics();
if (axis.getAxisOrientation() == Axis.HORIZONTAL)
{
final double xStart = labelPlacementStyle == TEXT_BESIDE_DIVISION ? originX : originX + (length / labels.length) / 2;
final double y = originY + fm.getMaxAscent() + Axis.padFromAxis;
final double lineHeight = fm.getHeight();
for (int i = 0; i < labels.length; i++)
{
final double x = xStart + i * length / n;
g.setColor(majorTickColor);
g.drawLine(x, originY + majorTickLength, x, originY - majorTickLength);
g.setColor(textColor);
g.drawString(labels[i], x - fm.stringWidth(labels[i]) / 2, y + layers[i] * lineHeight);
}
}
else
{
final double x = axis.onLeftSide ? originX - Axis.padFromAxis : originX + Axis.padFromAxis;
final double yStart = (labelPlacementStyle == TEXT_BESIDE_DIVISION ? originY : originY - (length / labels.length) / 2);
final double height = fm.getAscent() / 2;
for (int i = 0; i < labels.length; i++)
{
final double y = yStart - i * length / n;
g.setColor(textColor);
g.drawString(labels[i], axis.onLeftSide ? x - fm.stringWidth(labels[i]) : x, y + height);
g.setColor(majorTickColor);
g.drawLine(originX + majorTickLength, y, originX - majorTickLength, y);
}
}
}
}
int getMajorTickMarkLength()
{
return majorTickLength;
}
/*
* end axis type methods
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* begin private methods
*/
private int longestStringLength(FontMetrics fm, final String[] labels)
{
int longestLength = 0;
for (int i = 0; i < labels.length; i++)
{
int length = fm.stringWidth(labels[i]);
if (length > longestLength)
longestLength = length;
}
return longestLength;
}
private double indexToLocation(int index)
{
final double minL = axis.getMinLocation();
final double maxL = axis.getMaxLocation();
if (labelPlacementStyle == CENTER_TEXT_IN_DIVISION)
return minL + (maxL - minL) * index / labels.length + ((maxL - minL) / labels.length) / 2;
else
return minL + (maxL - minL) * index / labels.length;
}
/*
* end private methods
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* begin coordinate transformation methods
*/
public double convert(String s)
{
try
{
return indexToLocation(((Integer) hash.get(s)).intValue());
}
catch (Exception e)
{
return -1;
}
}
public double binWidth()
{
return (double) (axis.getMaxLocation() - axis.getMinLocation()) / labels.length;
}
/*
* end coordinate transformation methods
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* begin externalization methods
*/
public void writeExternal(final ObjectOutput out) throws IOException
{
out.writeInt(labelPlacementStyle);
}
public void readExternal(final ObjectInput in) throws IOException
{
labelPlacementStyle = in.readInt();
}
/*
* end externalization methods
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
private int labelPlacementStyle;
private Hashtable hash;
private final int majorTickLength = 5;
private final int minorTickLength = 3;
private final int minSpaceBetweenLabels = 3;
private String[] labels;
private int[] layers; // each element in this array holds the layer for the label in the corresponding
// element of the above array
}
src/main/java/jas/plot/Legend.java 0000644 0001750 0001750 00000015152 11325547132 017523 0 ustar giovanni giovanni package jas.plot;
import jas.plot.java2.PlotGraphics12;
import java.awt.Color;
import java.awt.Component;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Insets;
import java.awt.LayoutManager2;
import java.util.Enumeration;
import java.util.Vector;
import javax.swing.BorderFactory;
import javax.swing.JLabel;
import javax.swing.JPopupMenu;
/**
* Represents a plot legend
*/
public class Legend extends MovableObject
{
private SetablePlotGraphics pg = new PlotGraphics12();
/**
* Create an empty legend
*/
public Legend()
{
super("Legend");
setLayout(new LegendLayout());
setBorder(BorderFactory.createLineBorder(Color.black));
}
/**
* Adds a legend entry to a legend
*/
public void add(final LegendEntry e)
{
super.add(new LegendComponent(e));
EditableLabel label = new EditableLabel(e.getTitle(),"Legend Entry",JLabel.LEFT)
{
protected void fireActionPerformed()
{
super.fireActionPerformed();
if (e instanceof MutableLegendEntry) ((MutableLegendEntry) e).setTitle(getText());
}
};
label.setShowFontMenuItem(false);
super.add(label);
}
/**
* Removes a legend entry from a legend
*/
public void remove(LegendEntry e)
{
int n = getComponentCount();
for (int i=0; iDoubleAxis
* type.
* @see DoubleAxis
*/
public interface DoubleCoordinateTransformation extends CoordinateTransformation, Transformation
{
/** Returns a pixel value for a given double value. */
double convert(double d);
/** Returns a double value for a given pixel. */
double unConvert(double i);
/** Returns the minimum value on the axis. */
double getPlotMin();
/** Returns the maximum value on the axis. */
double getPlotMax();
/** Returns the point where this axis intersects its partner */
//double getIntersection();
}
src/main/java/jas/plot/SpaceRequirements.java 0000644 0001750 0001750 00000000137 11325547132 021761 0 ustar giovanni giovanni package jas.plot;
final class SpaceRequirements
{
int width;
int height;
int flowPastEnd;
}
src/main/java/jas/plot/AxisLabel.java 0000644 0001750 0001750 00000000351 11325547132 020164 0 ustar giovanni giovanni package jas.plot;
// This class is used by subclasses of AxisType when storing information about
// the labels on the axis. It is not meant to be public.
// @author Jonas Gifford
class AxisLabel
{
String text;
double position;
}
src/main/java/jas/plot/DoubleAxis.java 0000644 0001750 0001750 00000127102 11325547132 020363 0 ustar giovanni giovanni package jas.plot;
import java.awt.Color;
import java.awt.Font;
import java.awt.FontMetrics;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
/**
* Implements a simple numeric axis, with either linear or logarithmic scale. Users
* may set a flag that determines whether the axis may round to close values for simplicity
* of labels or whether the axis should keep to the given range. If, for example, the minimum
* is set to 4.3 and the maximum is set to 95.9, this class may be configured to round the
* extrema so that the labels are 0, 10, 20, ..., 100. Use setUseSuggestedRange(boolean)
* to set whether a pretty range is automatically used.
* @see #setUseSuggestedRange(boolean)
* @author Jonas Gifford
*/
public final class DoubleAxis extends AxisType implements DoubleCoordinateTransformation
{
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* begin constructors
*/
/** Creates linear axis. */
public DoubleAxis()
{
this(false);
}
/**
* Creates a new numeric axis.
* @param logarithmic whether the axis uses logarithmic (as opposed to liear) scale
*/
public DoubleAxis(final boolean logarithmic)
{
this.logarithmic = logarithmic;
}
/*
* end constructors
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* begin public interface
*/
public void setLogarithmic(final boolean logarithmic)
{
if (this.logarithmic != logarithmic)
{
labelsValid = false; // old labels are useless now, so on next layout new ones will be created
this.logarithmic = logarithmic;
if (axis != null) axis.revalidate();
}
}
public boolean isLogarithmic()
{
return logarithmic;
}
public void setUseSuggestedRange(final boolean useSuggestedRange)
{
if (this.useSuggestedRange != useSuggestedRange)
{
labelsValid = false; // old labels are useless now, so on next layout new ones will be created
this.useSuggestedRange = useSuggestedRange;
if (axis != null) axis.revalidate();
}
}
public boolean getUseSuggestedRange()
{
return useSuggestedRange;
}
public void setMin(final double data_min)
{
if (this.data_min != data_min)
{
labelsValid = false; // old labels are useless now, so on next layout new ones will be created
this.data_min = data_min;
this.plot_min = data_min;
if (axis != null) axis.revalidate();
}
}
public void setMax(final double data_max)
{
if (this.data_max != data_max)
{
labelsValid = false; // old labels are useless now, so on next layout new ones will be created
this.data_max = data_max;
this.plot_max = data_max;
if (axis != null) axis.revalidate();
}
}
/** Returns the minimum of the axis range. */
public double getPlotMin()
{
return plot_min;
}
/** Returns the maximum of the axis range. */
public double getPlotMax()
{
return plot_max;
}
/**
* Returns the minimum of the data on the axis, as given
* to the method setMin().
* @see #setMin(double)
*/
public double getDataMin()
{
return data_min;
}
/**
* Returns the maximum of the data on the axis, as given
* to the method setMax().
* @see #setMax(double)
*/
public double getDataMax()
{
return data_max;
}
/*
* end public interface
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* begin private methods
*/
private int stringWidth(final FontMetrics fm, final String s)
{
if (s.startsWith("e"))
return fm.stringWidth(s) + fm.stringWidth("10") - fm.charWidth('e');
else
return fm.stringWidth(s);
}
private int round(final double d, final boolean down)
/*
* Determines an integer value from a double by rounding intelligently.
* In the logarithmic case, when determining the order of magnitude
* of the lowest tick, the "down" parameter is false because
* we want to round up from the minimum point in the axis (so that
* the tick shows un on the range of the axis) if we are not very close
* to an integer value. However, when we are determining the order
* of magnitude of the highest tick, we want to round down if we are
* not very close to an integer so that the tick appears within the
* range of the axis. Similarly in the case for the linear axis, we round
* up to get the smallest tick value and we round down to get the largest
* tick value. We do exactly the opposite if we are using the suggested
* range. In that case, we round down to get the minimum and up to get
* the maximum.
*/
{
final double minProximity = 0.0001;
/*
* A parameter's proximity to the nearest integer must be this
* fraction of its size in order to be considered that value.
*/
final double round = Math.round(d); // the closest integer value
if (d == round || Math.abs(d - round) < (d != 0.0 ? minProximity * Math.abs(d) : 0.000001))
{
// we assume here that d is close enough to be an integer, so we round and return
return (int) round;
}
else
{
// d is not close enough to be an integer, so we return the
// floor if we were supposed to round down and ceil
// otherwise
return down ? (int) Math.floor(d) : (int) Math.ceil(d);
}
}
private boolean areEqual(double d1, double d2)
{
// returns whether they are close enough to be considered equal
return d1 == d2 || Math.abs(d2 - d1) < Math.abs(d1 != 0.0 ? 0.0001 * d1 : 0.000001);
}
private int charsReq(int pow)
/*
* Returns the number of characters required (not using scientific
* notation) to represent a decade of the given order of magnitude.
*/
{
if (pow < 0)
/*
* If the power is less than 0, we need one space for the
* leading zero, one for the decimal, and then -pow spaces
* for each of the following characters. For example, if
* pow = -2 then the result would be 4, because there are
* four characters in the string "0.01".
*/
return -pow + 2;
else
/*
* If the power is 0 or greater, we need one character for
* the character '1' and one '0' for each order of magnitude.
*/
return pow + 1;
}
private void createNewLabels(final int maxNumberOfDivisions)
{
labelsValid = true;
// log_max is the logarithm of the max value of the data
double log_max = data_max == 0d ? 0d : Math.log(Math.abs(data_max)) / log10;
// int_log_max is the floored integer equivalent of log_max
final int int_log_max = (int) Math.floor(log_max);
// by default, scale_power is 0
// This number represents the amount by which we scale all labels. For example,
// if our range is from 2,000,000,000 to 5,000,000,000 we want scale_power to be
// 9 so that we get 2.0, 2.5, 3.0, ... or something like that on the labels.
scale_power = 0;
if (int_log_max >= maxCharsPerLabel)
// we have an order of magnitude that can't be displayed in standard form, so we need to set
// a value for scale_power
scale_power = int_log_max;
else if (int_log_max <= -maxCharsPerLabel)
// we have an order of magnitude that can't be displayed in standard form, so we need to set
// a value for scale_power
scale_power = int_log_max;
final DoubleNumberFormatter format = new DoubleNumberFormatter(scale_power);
// the formatter uses scale_power when creating labels
if (logarithmic)
{
// log_min is the logarithm of the min value of the data
double log_min = data_min == 0d ? 0d : Math.log(Math.abs(data_min)) / log10;
int min_int = round(log_min, useSuggestedRange);
// min_int is the order of magnitude of the smallest major tick
// If min is a multiple of 10, min_int will be the order of
// magnitude of data_min. Otherwise, it will be the next highest
// order of magnitude. However, if we are using the
// suggested range, we want the next lowest, not the next highest.
int max_int = round(log_max, !useSuggestedRange);
// max_int is the order of magnitude of the largest major tick.
// If we are using the suggested range, we want the next highest,
// not the next lowest
final int nDecades = max_int - min_int + 1;
// nDecades is the number of major ticks we have on the plot
if (nDecades < (useSuggestedRange ? 3 : 2))
// if we can't get at least two decade marks in the range we put
// some ugly (but correct) labels on the axis spaced approximately evenly
// we require at least 3 if the suggested range is used because it
// rounds such that there are at least two by default and we want at least
// one more
{
tryForNewLabelsOnExpansion = true;
// when we resize, we may want new labels
minorTickPositions = null; // no minor ticks
final int pow = (int) Math.floor(Math.log(data_max - data_min) / log10) - (maxNumberOfDivisions > 40 ? 2 : 1);
// we will divide numbers by this many factors of 10, round using
// Math.floor(), and multiply again by this many factors of ten, thus
// getting a series of numbers truncated to a fixed point
if (scale_power > 0 || pow < 0)
format.setFractionDigits(scale_power - pow);
else
// we don't need any fraction digits in out result
format.setFractionDigits(0);
final double mag = Math.pow(10.0, pow);
// mag is the scaling factor (this is just to keep from having to recalculate each time)
nDivisions = Math.max(maxNumberOfDivisions, 2);
if (useSuggestedRange)
{
plot_min = Math.floor(data_min / mag) * mag;
// we set a value for the plot_min which is rounded down from our data_min at the precision specified by mag
plot_max = Math.ceil(data_max / mag) * mag;
// we set a value for the plot_max which is rounded up from our data_max at the precision specified by mag
// We want log_min and log_max to reflect extrema on the axis range, not for the data. We have to update
// these values to reflect a new range
log_min = Math.log(plot_min) / log10;
log_max = Math.log(plot_max) / log10;
// create a new label array
labels = new AxisLabel[nDivisions];
}
else
{
// because we're not using the suggested range, plot_min and plot_max are the same as data_min and data_max
// (note that log_min and log_max are already correct)
plot_min = data_min;
plot_max = data_max;
// lastLabel is a potential label value that we will include if it fits
final double lastLabel = Math.ceil(Math.pow(10.0, log_max) / mag) * mag;
if (lastLabel < data_max || areEqual(lastLabel, data_max))
// if the last label is safely within the data range, we create an array
// that will include that label
labels = new AxisLabel[nDivisions];
else
// we create an array that will not include that last label
labels = new AxisLabel[nDivisions - 1];
}
for (int i = 0; i < labels.length; i++)
{
double labelValue = Math.ceil(Math.pow(10.0, i * (log_max - log_min) / (nDivisions - 1) + log_min) / mag) * mag;
// we multiply the number by mag, floor, then divide by mag
labels[i] = new AxisLabel();
labels[i].text = format.format(labelValue);
labels[i].position = (Math.log(labelValue) / log10 - log_min) / (log_max - log_min);
}
}
else
{
scale_power = 0; // reset any settings because we don't scale logs
int nLabels = nDecades; // we will initially have exactly one label per decade
// (we may decrease this if skip, defined below, increases)
int skip = 1;
// skip is the number of orders of magnitude between tick marks
if (useSuggestedRange)
{
// max_int and min_int are the powers of ten for the axis range, so once cast to double, they
// will do just fine as log_min and log_max, which are supposed to be the logs of the axis boundaries
log_min = min_int;
log_max = max_int;
// the plot range is different from the data range:
plot_min = Math.pow(10.0, min_int);
plot_max = Math.pow(10.0, max_int);
}
else
{
// the plot range is equal to the data range
plot_min = data_min;
plot_max = data_max;
}
if (nDecades > maxNumberOfDivisions && maxNumberOfDivisions > 1)
// we have a problem: we have more decades than we have room for ticks
// time to set a good value for skip
{
// if the axis is extended, we may want new labels (i.e., to reflect a smaller skip) so...
tryForNewLabelsOnExpansion = true;
while (skip + 1 < nDecades && nDecades / skip >= maxNumberOfDivisions - 1)
// we just increement skip until we find something that works
skip++;
if (skip != 1)
{
// we now have fewer labels
nLabels = nDecades / skip;
if (useSuggestedRange)
// we have to round things to make the labels land exactly on the ends
{
// mod represents how much the axis min currently goes past the currently highest multiple of skip
final int mod = (max_int - min_int) % skip;
if (mod != 0)
// we need to move the max up so that it is a multiple of skip
{
max_int += skip - mod;
// now plot_max and log_max must be increased to reflect rounding up the max
plot_max = Math.pow(10.0, max_int);
log_max = max_int;
}
// by using the suggested range, we guarantee that there will be a label exactly on either end
// this involved having (nDecades + 1) labels, so...
nLabels++;
}
// For various reasons, we might not have enough labels, so...
if (min_int + nLabels * skip <= max_int)
// if we don't have enough, we add another
nLabels++;
}
}
else
// We have no skip, and therefore no way of inserting new labels between the ones we have, so there is
// no point in calculating new labels if we resize. Therefore, ...
tryForNewLabelsOnExpansion = false;
nDivisions = nLabels;
labels = new AxisLabel[nLabels];
if (charsReq(min_int) > maxCharsPerLabel || charsReq(max_int) > maxCharsPerLabel)
// if we can't fit the full label in, we use scientific notation
{
int power = min_int;
for (int i = 0; i < nLabels; i++)
{
labels[i] = new AxisLabel();
// the label text for 10^6 is "e6"
// we therefore concatenate the power as a string to the string "e"
labels[i].text = "e".concat(String.valueOf(power));
labels[i].position = (power - log_min) / (log_max - log_min);
power += skip;
}
}
else
// we are going to display the whole labels
{
if (min_int >= 0)
// all our numbers are greater than or equal to 1, so all
// we have to do is add zeros to one string buffer
{
// empty the buffer
b.setLength(0);
b.append('1');
for (int j = 0; j < min_int; j++)
b.append('0');
// we now have a buffer initialized for the first label
for (int i = 0; i < nLabels; i++)
{
labels[i] = new AxisLabel();
labels[i].text = b.toString();
labels[i].position = (i * skip + min_int - log_min) / (log_max - log_min);
// now, we set it up for the next label
for (int j = 0; j < skip; j++)
b.append('0');
}
}
else if (max_int < 0)
// all of our labels are less than or equal to 0.1, so we can just insert '0' characters into a single buffer
{
// empty the buffer
b.setLength(0);
// initialize the buffer
b.append("0.1");
for (int i = max_int; i < -1; i++)
b.insert(2, '0'); // for each order less than -1 we insert a '0' after the '.'
for (int i = nLabels - 1; i >= 0; i--)
{
labels[i] = new AxisLabel();
labels[i].text = b.toString();
labels[i].position = (i * skip + min_int - log_min) / (log_max - log_min);
// set up for the next label
for (int j = 0; j < skip; j++)
b.insert(2, '0'); // insert another '0' for each skip
}
}
else
// this isn't so simple because we can't just use one string
// buffer for all of the labels
{
int power = min_int;
// this is the order of magnitude of the current label
for (int i = 0; i < nLabels; i++)
{
b.setLength(0);
if (power < 0)
// we have to create a decimal number
{
b.append("0.");
for (int j = -1; j > power; j--)
b.append('0');
// for every order of magnitude less than -1 we
// add a zero
b.append('1');
}
else
// our number is 1 or greater
{
b.append('1');
for (int j = 0; j < power; j++)
b.append('0');
// for every order of magnitude we add a zero
}
labels[i] = new AxisLabel();
labels[i].text = b.toString();
labels[i].position = (power - log_min) / (log_max - log_min);
// increment power for the next label
power += skip;
}
}
}
// create minor ticks
if (skip == 1)
// our task is to create 8 minor ticks between each decade mark
{
double minorTickBase = areEqual(min_int, log_min) ? plot_min : Math.pow(10.0, min_int - 1);
// tickMarkBase is the multiple of ten that the minor ticks themselves are multiples of.
// Between two decades marks, the eight minor ticks are at:
// 2 * tickMarkBase, 3 * tickMarkBase, 4 * tickMarkBase, 5 * tickMarkBase,
// 6 * tickMarkBase, 7 * tickMarkBase, 8 * tickMarkBase, 9 * tickMarkBase
// and tickMarkBase is the value of the smaller of the surrounding decade marks.
// Therefore, between the marks 100 and 1000, we use the eight multiples above times
// the smaller decade (100) to get the following minor tick values:
// 200, 300, 400, 500, 600, 700, 800, 900
// We calculate the initial value of minorTickBase by taking 10 to the power of (min_int - 1)
// if the min_int is not equal to the log_min (i.e., if the axis minimum is not a multiple of 10)
// and plot_min is the axis minimum is a multiple of 10. When we go to the next decade to put the
// marks there, we will just multiply minorTickBase by 10 to get the next value.
final double initialIndex = plot_min / minorTickBase;
final double initialIndex_ceil = Math.ceil(initialIndex);
int index = initialIndex_ceil > initialIndex ? (int) initialIndex_ceil : (int) initialIndex_ceil + 1;
// The code above merely calculates the initial value for index. index is the multiple of minorTick
// base for a given minor tick. It rolls within the inclusive range 2:9.
int nMinorTicks = (max_int - min_int) * 8;
// so far we have 8 minor ticks for each decade interval
if (! useSuggestedRange)
// we may have extras because there is space after the last decade and befer the first
// where maybe we will need minor ticks
{
// increase nMinorTicks by the number that are needed below the first decade mark
nMinorTicks += (int) ((Math.pow(10.0, min_int) - data_min) / Math.pow(10.0, min_int - 1));
// increase nMinorTicks by the number that are needed after the last decade mark
nMinorTicks += (int) ((data_max - Math.pow(10.0, max_int)) / Math.pow(10.0, max_int));
}
minorTickPositions = new double[nMinorTicks];
for (int i = 0; i < nMinorTicks; i++)
{
if (index > 9)
// we have come to the end of one decade interval, so...
{
// we restart index at 2 and...
index = 2;
// increase minorTickBase for the new decade
minorTickBase *= 10.0;
}
// we assign the position of this minor tick
minorTickPositions[i] = (Math.log(index * minorTickBase) / log10 - log_min) / (log_max - log_min);
// we increment index for the next tick
index++;
}
}
else
// We have a skip other than 1, so we will try to put minor ticks on decade evenly spaced
// between the labels (major ticks).
{
minorTickPositions = null; // initially null; we'll see if we can get a nice pattern
for (int nMinorDivisions = Math.min(6 /* max */, skip); nMinorDivisions > 1; nMinorDivisions--)
{
if (skip % nMinorDivisions != 0) // this number won't work, so we...
continue;
// By this point we know we have a number that will work. We assign an array to
// minorTickPositions (which was previously null) and we break from the loop.
// minorSkip is the number of decades between minor ticks
final int minorSkip = skip / nMinorDivisions;
// nMinorTicks is the number of minor ticks
int nMinorTicks = (nMinorDivisions - 1) * (max_int - min_int) / skip;
// tickPower is the power of ten for the current tick
// we have set it here to the value for the first tick
int tickPower = min_int + minorSkip;
minorTickPositions = new double[nMinorTicks];
for (int i = 0; i < nMinorTicks; i++)
{
if ((tickPower - min_int) % skip == 0)
// we have actually landed on a major tick, so we skip over to the next minorTick value
tickPower += minorSkip;
minorTickPositions[i] = (tickPower - log_min) / (log_max - log_min);
tickPower += minorSkip;
}
break;
}
}
}
}
else
{
/*
* Our strategy here is based on the observation that plotting the range
* 0.2 to 40 is very similar to the task of plotting the ranges 2 to 400,
* or 0.02 to 4. We scale the min and max by an order of ten such that when
* converted to integers (by a process not quite like trucation) the difference
* between those two integers is a number greater than or equal to 10 and less
* than (but not equal to) 100. In other words, there will be a difference of
* exactly two digits, which is a sensible precision to see in variation between
* axis labels. For example, the ranges listed above would all yield the integer
* pair 1 to 40 (because the difference between those integers has two digits).
* Given a pair of integers, the function proceeds to calculate appropriate labels.
* If we are using the suggested range, we just round the min down to the next nice
* label and we round the max up to the next nice label (unless the max and min are
* already on nice labels).
*/
tryForNewLabelsOnExpansion = true;
minorTickPositions = null; // no minor ticks
final double difference = data_max - data_min;
final double pow = Math.floor(Math.log(difference) / log10) - 1.0;
// pow is the power of 10 used to get integers of the appropriate range
int fractDigits = 0;
if (scale_power > 0)
fractDigits = scale_power - (int) pow;
else if (pow < -0.5)
// we use -0.5 instead of 0.0 in case a Math.floor() returns something that should be 0.0
// but is really just barely under 0.0
fractDigits = scale_power - (int) pow;
final double conversion = Math.pow(10.0, pow);
// this is the actual conversion factor we used, stored once to keep from
// having to recalculate it
int intMin = round(data_min / conversion, useSuggestedRange);
int intMax = round(data_max / conversion, !useSuggestedRange);
// we now have intMin and intMax: the integer pair with a two-digit difference
if (useSuggestedRange)
{
plot_min = intMin * conversion;
plot_max = intMax * conversion;
}
else
{
plot_min = data_min;
plot_max = data_max;
}
final int naturalNumberOfDivisions = intMax - intMin;
// this number has precisely two digits
int nDivisions;
final float idealMinFraction = 0.5f;
// we will allow as few as this fraction of the maximum number of labels if it is convenient
int nUnits = 1;
// this number can represent two things:
// a) if naturalNumberOfDivisions < maxNumberOfDivisions
// it represents the number of divisions (units) between the natural divisions
// b) if naturalNumberOfDivisions > maxNumberOfDivisions
// it represents the number of units between divisions (the number to skip between divisions)
// 1 is the default value, but we will see if a different value might be better
if (naturalNumberOfDivisions < maxNumberOfDivisions)
// we might like to put in some new divisions
{
final float proximity = (float) naturalNumberOfDivisions / (float) maxNumberOfDivisions;
// this number measures how close the natural number is to the maximum
boolean niceDivisionFound = false;
if (proximity < idealMinFraction)
// we want to do something because the number we have is below the range we want
{
final int[] divisions = {2, 4, 5, 10, 20};
// These are the numbers of subdivisions we might want to place between natural divisions.
// The array only goes up to 20 because we would need a plot with at least 200 labels before
// needing to go any higher.
for (int i = 0; i < divisions.length; i++)
{
final int candidate = divisions[i];
if (proximity * candidate <= 1.0)
// this might work, because the number is small enough that we could fit
// this many divisions on the axis
{
niceDivisionFound = true;
nUnits = candidate;
// the next iteration might be even better, so we...
continue;
}
// if we didn't execute continue, it was because we can't fit this many
// divisions on the axis, and so there's no point in trying the next
// iteration either because it's even bigger, so we break out of the loop
break;
}
}
if (niceDivisionFound)
{
if (useSuggestedRange)
{
nDivisions = naturalNumberOfDivisions * nUnits;
}
else
{
nDivisions = naturalNumberOfDivisions * nUnits + (int) ((plot_max / conversion - intMax) * nUnits);
/*
* The first term in the expression isn't tough: If nUnits is 2 then we need twice as many
* divisions on the axis. The second term isn't so obvious. Suppose our axis goes from 0
* to 12.7 and we decide to set nUnits to 2. We therefore get labels 0.0, 0.5, 1.0, ... , 12.0
* but we won't get 12.5 on there. There will instead be empty space where the 12.5 should go.
* The last term accounts for this, by taking the difference between the top label and the
* axis max (in this case 12.7 - 12.0 = 0.7), multiplying bn nUnits (to get 1.4 in this case)
* and truncating (to get 1 in this case). The result (1 in this case) is the number of labels
* extra we need.
*/
}
if (pow < 0.5 || scale_power > 0)
// we use 0.5 instead of 1.0 in case a Math.floor() returns something
// that should be 1.0 but is really just barely under 1.0
fractDigits++;
// we've gone down to one lover decimal level so we have to tell the formatter
if ((nUnits == 4 || nUnits == 20) && (pow < 1.5 || scale_power > 0)) // we've actually gone down two decimal levels, so...
// we use 1.5 instead of 2.0 in case a Math.floor() returns something
// that should be 2.0 but is really just barely under 2.0
fractDigits++; // we add another
}
else
// we give up and keep the natural number, even though it's smaller that what we'd like
{
nDivisions = Math.max(naturalNumberOfDivisions, minNumberOfDivisions);
}
}
else if (naturalNumberOfDivisions > maxNumberOfDivisions)
// the natural number is larger than what we'd like, so we have to skip over some
// (typically this is the more common problem)
{
nDivisions = 1;
// we supply this initialization to make the compiler happy, but in the algorithm
// requires that this initial value change
final int[] skips = {2, 5, 10, 20, 25, 50};
// These are the numbers of natural divisions we're going to try skipping.
for (int i = 0; i < skips.length; i++)
{
final int nDivisionsThisTry = naturalNumberOfDivisions / skips[i];
if (nDivisionsThisTry > maxNumberOfDivisions)
{
// this many skips isn't big enough, so we'll try the next one
continue;
}
// we now assign to nUnits the number of natural divisions to skip over
nUnits = skips[i];
nDivisions = nDivisionsThisTry;
if (useSuggestedRange)
{
// changed is a flag that indicates if the number of divisions has changed
boolean changed = false;
if (intMin % nUnits != 0)
// intMin is not a multiple of nUnits, so we...
{
// decrease it so that it is a multiple,
intMin -= intMin % nUnits;
// adjust plot_min accordingly, and
plot_min = intMin * conversion;
// set the flag that the range has changed
changed = true;
}
if (intMax % nUnits != 0)
// intMax is not a multiple of nUnits, so we...
{
// increase it so that it is a multiple,
intMax += nUnits - intMax % nUnits;
// adjust plot_max accordingly, and
plot_max = intMax * conversion;
// set the flag that the range has changed
changed = true;
}
if (changed)
// we need to recalculate the number of divisions
{
nDivisions = (intMax - intMin) / nUnits;
}
}
if (nUnits >= 10 && nUnits != 25 && fractDigits > 0)
// we're skipping at least an order of 10, and we're not in quarters, so...
fractDigits--; // we can get rid of one fraction digit
/*
* We may calculate a new value for the intMin. Consider, for example,
* the range 3 to 17. If we decide that our skip will be 2, we will get
* labels like 3, 5, 7, 9, etc. This will look dumb because we would much rather
* have the first label a nice multiple of our skip (i.e., we would rather
* have 2, 4, 6, 8, etc., or for multiples of 5 we would rather have 20,
* 25, 30, 35, etc. over 18, 23, 28, 33, etc.) Therefore, if the intMin is not
* a nice multiple of that skip then we increase the intMin, and we may have
* to decrement nDivisions because of a lost label.
*/
if (intMin % nUnits != 0)
// only true if we are not using the suggested range
{
// increase is the amount we will increase intMin by to make it a nice multiple of nUnits
final int increase = intMin > 0 ? nUnits - intMin % nUnits : -intMin % nUnits;
if (increase > intMax - (intMax - intMin) / nUnits * nUnits - intMin)
// we have put the last label over the limit, so...
nDivisions--; // we drop the last label
intMin += increase;
}
// We are happy with what we've got because it gives us an acceptable
// number of divisions. We don't want to go any higher because that
// will just make for fewer divisions, so we...
break;
}
}
else // hey! they're exactly equal
nDivisions = Math.max(naturalNumberOfDivisions, minNumberOfDivisions);
double minLabelValue = intMin * conversion;
final double inc = naturalNumberOfDivisions < maxNumberOfDivisions ? conversion / nUnits : conversion * nUnits;
if (naturalNumberOfDivisions < maxNumberOfDivisions && minLabelValue - inc >= plot_min)
// this happens if we are dividing up divisions, and we get divisions below intMin * conversion
{
int nLost = (int) ((minLabelValue - inc) / inc);
minLabelValue -= nLost * inc;
nDivisions += nLost;
}
if (nDivisions < 0) nDivisions = 0;
if (nDivisions > maxNumberOfDivisions) nDivisions = maxNumberOfDivisions;
labels = new AxisLabel[nDivisions + 1];
this.nDivisions = nDivisions;
format.setFractionDigits(fractDigits);
for (int j = 0; j < labels.length; j++)
{
final double labelValue = minLabelValue + j * inc;
// this method of finding labelValue is more expensive than the method in the
// previous version (i.e., the last version checked in to source safe) but this method
// avoids some miniscule rounding problems we had in the previous version
labels[j] = new AxisLabel();
labels[j].text = format.format(labelValue);
labels[j].position = (labelValue - plot_min) / (plot_max - plot_min);
}
}
}
private int calculateMaxNDivisions(final FontMetrics fm, final int axisLength)
{
int result;
if (axis.getAxisOrientation() == Axis.HORIZONTAL)
result = axisLength / (fm.charWidth('5') * maxCharsPerLabel + minSpaceBetweenLabels);
// assume '5' has typical width
else
result = axisLength / (fm.getHeight() + minSpaceBetweenLabels);
return Math.max(minNumberOfDivisions, result);
}
private int getPowerOffset(final FontMetrics fm)
// returns how far the term indicating power is below the regular labels (horizontal axis only)
{
// kind of an arbitrary return value (we just want some number that relates to font size)
return fm.getAscent() / 2;
}
/*
* end private methods
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* begin AxisType methods
*/
void assumeAxisLength(final int axisLength)
{
Font font = axis.getFont();
final FontMetrics fm = axis.getToolkit().getFontMetrics(font);
final int maxNumberOfDivisions = calculateMaxNDivisions(fm, axisLength);
if (!labelsValid || labels == null || nDivisions < 2 || nDivisions > maxNumberOfDivisions ||
tryForNewLabelsOnExpansion && nDivisions < maxNumberOfDivisions / 2)
{
createNewLabels(maxNumberOfDivisions);
}
// we are going to indicate that the minor ticks should be hidden if there are minor ticks and
// the number of divisions is high enough that the ticks would be crammed too close together
hideMinorTicks = minorTickPositions == null || nDivisions > maxNumberOfDivisions / 3;
final int lastLabelLocation = (int) ((1.0 - labels[labels.length - 1].position) * axisLength);
if (axis.getAxisOrientation() == Axis.VERTICAL)
{
spaceRequirements.width = longestStringLength(fm,labels) + Axis.padFromAxis;
spaceRequirements.flowPastEnd = fm.getMaxAscent() - fm.getAscent() / 2 - lastLabelLocation;
if (logarithmic && labels[0].text.startsWith("e"))
{
spaceRequirements.width += fm.stringWidth("10") - fm.charWidth('e');
spaceRequirements.flowPastEnd += fm.getHeight() / 2;
}
if (scale_power != 0)
{
spaceRequirements.width = Math.max(fm.stringWidth("x10") + fm.stringWidth(String.valueOf(scale_power)),
spaceRequirements.width);
spaceRequirements.flowPastEnd += minSpaceBetweenLabels;
if (spaceRequirements.flowPastEnd < 0) spaceRequirements.flowPastEnd = 0;
spaceRequirements.flowPastEnd += fm.getAscent();
}
else if (spaceRequirements.flowPastEnd < 0)
spaceRequirements.flowPastEnd = 0;
final int lineHeight = isLogarithmic() && labels[0].text.startsWith("e") ?
fm.getHeight() / 2 + fm.getAscent() : fm.getAscent();
spaceRequirements.height = Math.max(lineHeight / 2 - (int) (labels[0].position * axisLength), 0);
}
else
{
spaceRequirements.width = Math.max(stringWidth(fm, labels[0].text) / 2 - (int) (labels[0].position * axisLength), 0);
spaceRequirements.flowPastEnd = stringWidth(fm, labels[labels.length - 1].text) / 2 - lastLabelLocation;
final int lineHeight = isLogarithmic() && labels[0].text.startsWith("e") ?
fm.getHeight() / 2 + fm.getMaxAscent() + fm.getDescent() : fm.getMaxAscent() + fm.getDescent();
spaceRequirements.height = lineHeight + Axis.padFromAxis;
if (scale_power != 0)
{
spaceRequirements.height = Math.max(fm.getHeight() / 2 + fm.getAscent() + getPowerOffset(fm),
spaceRequirements.height);
spaceRequirements.flowPastEnd += minSpaceBetweenLabels;
if (spaceRequirements.flowPastEnd < 0) spaceRequirements.flowPastEnd = 0;
spaceRequirements.flowPastEnd += fm.stringWidth("x10") + fm.stringWidth(String.valueOf(scale_power));
}
else if (spaceRequirements.flowPastEnd < 0)
spaceRequirements.flowPastEnd = 0;
}
}
/**
* Returns an instance of DoubleCoordinateTransformation.
* @see DoubleCoordinateTransformation
*/
public CoordinateTransformation getCoordinateTransformation()
{
return this;
}
void paintAxis(final PlotGraphics g, final double originX, final double originY,
final double length, final Color textColor,
final Color majorTickColor, final Color minorTickColor)
{
final boolean isHorizontal = axis.getAxisOrientation() == Axis.HORIZONTAL;
final boolean onLeft = (!isHorizontal) && axis.onLeftSide;
final double minL = isHorizontal ? originX : originY;
final double maxL = isHorizontal ? originX + length : originY - length;
final FontMetrics fm = g.getFontMetrics();
final int lineHeight = fm.getHeight();
final int ascent = fm.getAscent();
final int maxAscent = fm.getMaxAscent();
double lastLabel = 0;
if (labels == null) return;
if (logarithmic)
{
final boolean isInExp = labels[0].text.startsWith("e");
for (int i = 0; i < labels.length; i++)
{
String text = labels[i].text;
String pow = null;
double textLength;
if (isInExp)
{
pow = text.substring(1);
text = "10";
textLength = fm.stringWidth(text) + fm.stringWidth(pow);
}
else
{
textLength = fm.stringWidth(text);
}
double pos = minL + (int) (labels[i].position * (maxL - minL));
if (isHorizontal)
{
g.setColor(majorTickColor);
g.drawLine(pos, originY + majorTickLength, pos, originY - majorTickLength);
double y = originY + maxAscent + Axis.padFromAxis;
pos -= textLength / 2;
g.setColor(textColor);
if (isInExp)
{
g.drawString(pow, pos + fm.stringWidth(text), y);
y += lineHeight / 2;
}
g.drawString(text, pos, y);
}
else
{
g.setColor(majorTickColor);
g.drawLine(originX - majorTickLength, pos, originX + majorTickLength, pos);
final double x = onLeft ? originX - textLength - Axis.padFromAxis : originX + Axis.padFromAxis;
pos += ascent / 2;
g.setColor(textColor);
if (isInExp)
{
// the "10" is centered in the tick mark
// the exponent is higher by lineHeight / 2
g.drawString(pow, x + fm.stringWidth(text), pos - lineHeight / 2);
}
g.drawString(text, x, pos);
}
}
}
else
{
for (int i = 0; i < labels.length; i++)
{
final String text = labels[i].text;
final double pos = minL + labels[i].position * (maxL - minL);
if (isHorizontal)
{
g.setColor(majorTickColor);
g.drawLine(pos, originY + majorTickLength, pos, originY - majorTickLength);
final double y = originY + maxAscent + Axis.padFromAxis;
g.setColor(textColor);
g.drawString(text, pos - fm.stringWidth(text) / 2, y);
}
else
{
g.setColor(majorTickColor);
g.drawLine(originX - majorTickLength, pos, originX + majorTickLength, pos);
final double x = onLeft ? originX - fm.stringWidth(text) - Axis.padFromAxis : originX + Axis.padFromAxis;
g.setColor(textColor);
g.drawString(text, x, pos + ascent/2);
}
}
lastLabel = minL + labels[labels.length-1].position*(maxL-minL);
}
if (scale_power != 0)
{
g.setColor(textColor);
final String s = String.valueOf(scale_power);
if (isHorizontal)
{
final double y = originY + ascent + getPowerOffset(fm) + 2;
final double x = axis.getSize().width - Axis.padAroundEdge - fm.stringWidth(s) + spaceRequirements.flowPastEnd;
g.drawString("x10", x - fm.stringWidth("x10"), y + lineHeight / 2);
g.drawString(s, x, y + lineHeight / 5);
// g.drawString(s, x, y);
}
else
{
// final double y = ascent + Axis.padAroundEdge;
// final double y1 = originY - length - lineHeight;
final double y = lineHeight/2;
final double x = onLeft ? originX - fm.stringWidth(s) : originX;
g.drawString("x10", onLeft ? x - fm.stringWidth("x10") : x, y + lineHeight / 2);
g.drawString(s, onLeft ? x : x + fm.stringWidth("x10"), y + lineHeight / 5);
// g.drawString(s, onLeft ? x : x + fm.stringWidth("x10"), y);
}
}
if (!hideMinorTicks && minorTickPositions != null && minorTickPositions.length != 0)
{
g.setColor(minorTickColor);
if (isHorizontal)
{
for (int i = 0; i < minorTickPositions.length; i++)
{
final double x = minL + (int) (minorTickPositions[i] * (maxL - minL));
g.drawLine(x, originY + minorTickLength, x, originY - minorTickLength);
}
}
else
{
for (int i = 0; i < minorTickPositions.length; i++)
{
final double y = minL + (int) (minorTickPositions[i] * (maxL - minL));
g.drawLine(originX - minorTickLength, y, originX + minorTickLength,y);
}
}
}
}
int getMajorTickMarkLength()
{
return majorTickLength;
}
/*
* end AxisType methods
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* begin coordinate transformation methods
*/
// Convert between axis coordinate (double) and drawing coordinates (pixels);
public double convert(double d)
{
final int minL = axis.getMinLocation();
final int maxL = axis.getMaxLocation();
if (logarithmic)
{
final double min = Math.log(plot_min) / log10;
final double max = Math.log(plot_max) / log10;
if(d > 0)
d = Math.log(d) / log10;
else
d = min;
final double f = (d - min) / (max - min);
return minL + f*(maxL - minL);
}
else
{
final double f = (d - plot_min) / (plot_max - plot_min);
return minL + f*(maxL - minL);
}
}
public double unConvert(double d)
{
final int minL = axis.getMinLocation();
final int maxL = axis.getMaxLocation();
final double f = (d - minL) / (maxL - minL);
if (logarithmic)
{
final double min = Math.log(plot_min) / log10;
final double max = Math.log(plot_max) / log10;
return plot_min + f*(max - min);
}
else
{
return plot_min + f*(plot_max - plot_min);
}
}
public double getIntersection()
{
return plot_min;
}
/*
* end coordinate transformation methods
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* begin externalization methods
*/
public void writeExternal(final ObjectOutput out) throws IOException
{
out.writeBoolean(logarithmic);
out.writeBoolean(useSuggestedRange);
}
public void readExternal(final ObjectInput in) throws IOException
{
logarithmic = in.readBoolean();
useSuggestedRange = in.readBoolean();
}
/*
* end externalization methods
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* begin private member fields
*/
/* CONSTANTS */
private final StringBuffer b = new StringBuffer();
private final double log10 = Math.log(10.0);
private final int majorTickLength = 5;
private final int minorTickLength = 3;
private final int maxCharsPerLabel = 5;
private final int minSpaceBetweenLabels = 3;
private final int minNumberOfDivisions = 1;
/* VARIABLES */
private int nDivisions = 0;
private double data_min = 0d, data_max = 1d; // actual min/max for the data set
private double plot_min = 0d, plot_max = 1d; // min/max on the axis itself
private AxisLabel[] labels;
private double[] minorTickPositions;
private boolean logarithmic;
private int scale_power;
private boolean useSuggestedRange = false;
private boolean tryForNewLabelsOnExpansion; // This will only be false if we have a logarithmic axis where all the decades are showing.
// Otherwise, such an axis will recalculate new labels each time it is expanded.
private boolean hideMinorTicks = false;
/*
* end private member fields
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
}
src/main/java/jas/plot/TimeAxis.java 0000644 0001750 0001750 00000037711 11325547132 020055 0 ustar giovanni giovanni package jas.plot;
import java.awt.Color;
import java.awt.Font;
import java.awt.FontMetrics;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
/**
* An axis type for representing times.
* OMIT as the length of a time unit to have that unit not
* considered as a candidate for axis units.
*/
public static final long OMIT = 0L;
private long[] unitLengths =
{
1L, // milliseconds
1000L, // seconds
1000L * 60L, // minutes
1000L * 60L * 60L, // hours
1000L * 60L * 60L * 24L, // days
1000L * 60L * 60L * 24L * 7L, // weeks
OMIT, // months
1000L * 60L * 60L * 24L * 365L // years
};
/**
* Allows units to be viewed as valued different from the default. For example,
* a year by default is 1000L * 60L * 60L * 24L * 365L milliseconds,
* but a call such as this may be desirable:
* setUnitLength(TimeAxis.YEARS, (long) (1000 * 60 * 60 * 24 * 365.24));
*/
public void setUnitLength(final int unit, final long length)
{
if (length < 0L || length != OMIT &&
(unit != MILLISECONDS && length <= unitLengths[unit - 1] ||
unit != YEARS && length >= unitLengths[unit + 1]))
{
throw new IllegalArgumentException();
}
if (length == OMIT && unitIndex == unit)
labelsValid = false; // these labels are no good, so on the next validation we'll get a new set
unitLengths[unit] = length;
}
/**
* Returns the number of milliseconds for this unit, or OMIT.
* @see #OMIT
*/
public long getUnitLength(int unit)
{
return unitLengths[unit];
}
/*
* end code for handling unit size
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* begin interface to unit description
*/
private final String[] unitNames =
{
"milliseconds",
"seconds",
"minutes",
"hours",
"days",
"weeks",
"months",
"years"
};
/** Returns a string representation of the units showing on the axis. */
public String getUnits()
{
return unitNames[unitIndex];
}
/*
* end interface to unit description
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/**
* Sets whether this object should round the minimum down and the maximum
* up to make labels land exactly on the min and max of the axis range.
*/
public void setUseSuggestedRange(final boolean useSuggestedRange)
{
if (this.useSuggestedRange != useSuggestedRange)
labelsValid = false; // these labels are no good, so on the next validation we'll get a new set
this.useSuggestedRange = useSuggestedRange;
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* begin interface to range
*/
/** Sets the minimum value for the axis data. */
public void setMin(final long min)
{
if (dataMin != min)
labelsValid = false; // these labels are no good, so on the next validation we'll get a new set
dataMin = min;
}
/** Sets the maximum value for the axis data. */
public void setMax(final long max)
{
if (dataMax != max)
labelsValid = false; // these labels are no good, so on the next validation we'll get a new set
dataMax = max;
}
/**
* Returns the minimum value on the axis range. This value may be
* smaller than the data minimum if the axis has been told to use the
* suggested range.
* @see #setUseSuggestedRange(boolean)
* @see #setMin(long)
* @see #getDataMin()
*/
public long getAxisMin()
{
return axisMin;
}
/**
* Returns the maximum value on the axis range. This value may be
* larger than the data maximum if the axis has been told to use the
* suggested range.
* @see #setUseSuggestedRange(boolean)
* @see #setMax(long)
* @see #getDataMax()
*/
public long getAxisMax()
{
return axisMax;
}
/**
* Returns the minimum value on the data range, as set by the method
* setMin(long). This value may be
* larger than the axis minimum if the axis has been told to use the
* suggested range.
* @see #setMin(long)
* @see #setUseSuggestedRange(boolean)
* @see #getAxisMin()
*/
public long getDataMin()
{
return dataMin;
}
/**
* Returns the maximum value on the axis range, as set by the method
* setMax(long). This value may be
* smaller than the axis maximum if the axis has been told to use the
* suggested range.
* @see #setMax(long)
* @see #setUseSuggestedRange(boolean)
* @see #getAxisMax()
*/
public long getDataMax()
{
return dataMax;
}
/*
* end interface to range
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* begin AxisType methods
*/
/**
* Returns an instance of TimeCoordinateTransformation.
* @see TimeCoordinateTransformation
*/
CoordinateTransformation getCoordinateTransformation()
{
return this;
}
void paintAxis(final PlotGraphics g, final double originX, final double originY, final double axisLength,
final Color textColor, final Color majorTickColor, final Color minorTickColor)
{
final FontMetrics fm = g.getFontMetrics();
if (axis.getAxisOrientation() == Axis.HORIZONTAL)
{
final double y = originY + fm.getMaxAscent() + Axis.padFromAxis;
for (int i = 0; i < labels.length; i++)
{
final String text = labels[i].text;
final double x = originX + labels[i].position * axisLength;
g.setColor(textColor);
g.drawString(text, x - fm.stringWidth(text) / 2, y);
g.setColor(majorTickColor);
g.drawLine(x, originY + majorTickLength, x, originY - majorTickLength);
}
}
else
{
final double x = axis.onLeftSide ? originX - Axis.padFromAxis : originX + Axis.padFromAxis;
final double height = fm.getAscent() / 2;
for (int i = 0; i < labels.length; i++)
{
final String text = labels[i].text;
final double y = originY - labels[i].position * axisLength;
g.setColor(textColor);
g.drawString(text, axis.onLeftSide ? x - fm.stringWidth(text) : x, y + height);
g.setColor(majorTickColor);
g.drawLine(originX - majorTickLength, y, originX + majorTickLength, y);
}
}
}
// The method below uses several calculations with the same idea:
// Math.max(JMenuItem subclass implements a convenient
* reflection-based menu item. When this item is first
* created, the class of the object specified by the source
* argument to the constructor is searched for methods that match the
* string given for the constructor's name argument.
* The class will be searched for two methods:
*
*
* @see HasPopupItems
* @see HasPopupItems#getPopupItems()
*/
final class PlotPopupItem extends JMenuItem
{
PlotPopupItem(String name, Object source)
{
super(name);
setEnabled(false);
if (name.endsWith("..."))
name = name.substring(0, name.length() - 3);
for (int i = name.indexOf(" "); i >= 0; i = name.indexOf(' '))
name = name.substring(0, i).concat(name.substring(i + 1));
try
{
action = source.getClass().getMethod("on"+ name, no_arg_class);
// if no exceptions...
enabler = source.getClass().getMethod("enable"+ name, no_arg_class);
// if no exceptions...
if (enabler.getReturnType() != boolean.class)
enabler = null; // we ignore the method because its return is useless
}
catch (Exception e)
{
if (! (e instanceof NoSuchMethodException))
JOptionPane.showMessageDialog(this, e.toString(), "", JOptionPane.ERROR_MESSAGE);
}
}
void callEnable()
{
if (enabler != null)
{
try
{
Boolean b = (Boolean) enabler.invoke(source, no_arg_object);
setEnabled(b.booleanValue());
}
catch (Exception e)
{
setEnabled(false);
}
}
else
setEnabled(action != null);
}
protected void fireActionPerformed(java.awt.event.ActionEvent event)
{
// let's not bother with super.fireActionPerformed(event)
if (action != null)
{
try
{
action.invoke(source, no_arg_object);
}
catch (Exception e)
{
/* BUG */
}
}
}
private Object source;
private Method action = null;
private Method enabler = null;
static private final Class[] no_arg_class = new Class[0];
static private final Object[] no_arg_object = new Object[0];
}
src/main/java/jas/plot/FontMenuItem.java 0000644 0001750 0001750 00000001407 11325547132 020675 0 ustar giovanni giovanni package jas.plot;
import java.awt.Font;
import java.awt.Frame;
import java.awt.event.ActionEvent;
import javax.swing.JComponent;
import javax.swing.JMenuItem;
import javax.swing.SwingUtilities;
final class FontMenuItem extends JMenuItem
{
FontMenuItem(JComponent c, final String type)
{
super(type.concat(" Font..."));
component = c;
}
FontMenuItem(JComponent c)
{
super("Font...");
component = c;
}
protected void fireActionPerformed(final ActionEvent e)
{
final Frame frame = (Frame) SwingUtilities.getAncestorOfClass(Frame.class, component);
final Font font = new FontDialog(frame, component.getGraphics().getFont()).showDialog();
if (font != null)
{
component.setFont(font);
component.revalidate();
}
}
private JComponent component;
}
src/main/java/jas/plot/AxisType.java 0000644 0001750 0001750 00000004631 11325547132 020073 0 ustar giovanni giovanni package jas.plot;
import java.awt.Color;
import java.awt.FontMetrics;
/**
* Subclasses encapsulate details for a particular axis type.
* @see DoubleAxis
* @see DateAxis
* @see StringAxis
* @see TimeAxis
* @author Jonas Gifford
*/
public abstract class AxisType implements java.io.Externalizable
{
/**
* This method is called by the Axis object that receives this object, so
* you never need to call this yourself.
* @param the axis this type will be used on
*/
final void setAxis(Axis axis)
{
this.axis = axis;
}
/**
* Given a length for the axis, calculate and return the space required
* for the axis component. Calculate new labels if necessary. Set fields
* in the object on<title>: will be called if the menu itel
* is selected. If this method is not found, the menu item
* will appear on the menu but will not enable.enable<title>: will be called before the
* menu is shown and the item will enable according to the return
* value of this method. If this method is not found (or if its
* return type is not boolean.class) the menu item
* will always be enabled.sizeRequirements. You should invoke this method
* on the Axis object instead of on this class directly.
* @see #sizeRequirements
* @see Axis
* @see Axis#assumeAxisLength(int)
*/
abstract void assumeAxisLength(int length);
/**
* Return a subclass of CoordinateTransformation specific to the
* type of this axis.
*/
abstract CoordinateTransformation getCoordinateTransformation();
/**
* Paint the axis labels, ticks, etc.
* @param g the Graphics object to paint with
* @param origin the actual location of the origin (from top left)
* @param axisLength the length of the axis to mark up
* @param textColor the text color
* @param majorTickMarkColor the color of the major ticks
* @param minorTickMarkColor the color of the minor ticks
*/
abstract void paintAxis(PlotGraphics g, double originX, double originY, double axisLength, Color textColor,
Color majorTickMarkColor, Color minorTickMarkColor);
/**
* The length is defined as the distance drawn above the axis and the distance
* below the axis, not the total length of the line.
* The layout manager needs this value to calculate space requirements.
*/
abstract int getMajorTickMarkLength();
final int longestStringLength(FontMetrics fm, final AxisLabel[] labels)
{
int longestLength = 0;
for (int i = 0; i < labels.length; i++)
{
int length = fm.stringWidth(labels[i].text);
if (length > longestLength)
longestLength = length;
}
return longestLength;
}
final public Axis getAxis()
{
return axis;
}
/** the axis object this type will be used on */
protected Axis axis;
boolean labelsValid;
final SpaceRequirements spaceRequirements = new SpaceRequirements();
}
src/main/java/jas/plot/Title.java 0000644 0001750 0001750 00000001455 11325547132 017407 0 ustar giovanni giovanni package jas.plot;
import java.awt.BorderLayout;
import java.awt.Font;
import javax.swing.JMenuItem;
import javax.swing.border.Border;
public final class Title extends MovableObject
{
public Title(final String title)
{
super("Title");
setLayout(new BorderLayout());
label = new EditableLabel(title,"Title");
setFont(new Font("SansSerif",Font.BOLD,14));
add(label,BorderLayout.CENTER);
}
public Title()
{
this("");
}
public EditableLabel getLabel()
{
return label;
}
public String getText()
{
return label.getText();
}
public void setText(final String text)
{
label.setText(text);
}
public void edit()
{
label.edit();
}
public void setBorder(final Border b)
{
super.setBorder(b);
revalidate();
}
private JMenuItem hideMenuItem = null;
private EditableLabel label;
}
src/main/java/jas/plot/HasPopupItems.java 0000644 0001750 0001750 00000001367 11325547132 021071 0 ustar giovanni giovanni package jas.plot;
/**
* A component that implements this interface
* may add menu items to a popup menu that is parented to itself or to one
* of its child components. When a component receives a
* mouse event which is a popup trigger, its parent
* PlotPanel builds a popup menu by asking
* all of its parent components if they implement this
* interface, and asks those that do to modify the menu. The
* class PlotPopupItem is designed to
* provide a convenient reflection-based menu item.
* @see PlotPanel
* @see PlotPopupItem
* @author Jonas Gifford
*/
public interface HasPopupItems
{
/** Modify the given menu object. */
public void modifyPopupMenu(javax.swing.JPopupMenu menu, java.awt.Component source);
}
src/main/resources/ 0000755 0001750 0001750 00000000000 11325547132 015014 5 ustar giovanni giovanni src/main/resources/jas/ 0000755 0001750 0001750 00000000000 11325547132 015571 5 ustar giovanni giovanni src/main/resources/jas/hist/ 0000755 0001750 0001750 00000000000 11325547132 016540 5 ustar giovanni giovanni src/main/resources/jas/hist/function.gif 0000644 0001750 0001750 00000001473 11325547132 021061 0 ustar giovanni giovanni GIF87a 3 f 3 33 f3 3 3 3 f 3f ff f f f 3 f ̙ 3 f 3 f 33 3f 3 3 3 3 33333f33333333 f33f3ff3f3f3f3 333f33̙33 333f3333 333f3333 f3 ff f f f f 3f33ff3f3f3f3f ff3fffffffffff f3ffff̙ff f3ffffff f3ffffff 3 f 333f3333 f3ffffff 3f̙ ̙3̙f̙̙̙̙ 3f 3 f ̙ 333f3̙333 f3fff̙fff 3f̙̙ 3f̙ 3f̙ 3 f 333f3333 f3ffffff 3f̙ 3f 3f ! , HZ6YA #6, ; src/main/resources/jas/hist/tick.gif 0000644 0001750 0001750 00000002135 11325547132 020162 0 ustar giovanni giovanni GIF89a% # 3 f 3 33 f3 3 3 3 f 3f ff f f f 3 f ̙ 3 f 3 f 33 3f 3 3 3 3 33333f33333333 f33f3ff3f3f3f3 333f33̙33 333f3333 333f3333 f3 ff f f f f 3f33ff3f3f3f3f ff3fffffffffff f3ffff̙ff f3ffffff f3ffffff 3 f 333f3333 f3ffffff 3f̙ ̙3̙f̙̙̙̙ 3f 3 f ̙ 333f3̙333 f3fff̙fff 3f̙̙ 3f̙ 3f̙ 3 f 333f3333 f3ffffff 3f̙ 3f 3f ! , % # HA*\
JdAĉ 6h1bƉ8V#E#K4eʕCHfA
3E6PieNl^S$D'MӧPШX.P5b֯=t`@RبQgpHaQV ƽ"ssEzV
:Z`S+(dԊ$ QX
52E xMr Oa7utd@Vr@mEr2øds1Wyýq3:7xU7-ל#ah9MȀ `5h 5Q@ ; src/main/resources/jas/hist/plotML.dtd 0000644 0001750 0001750 00000037537 11325547132 020463 0 ustar giovanni giovanni
src/main/resources/jas/hist/chi2.gif 0000644 0001750 0001750 00000001624 11325547132 020057 0 ustar giovanni giovanni GIF89a" 3 f 3 33 f3 3 3 3 f 3f ff f f f 3 f ̙ 3 f 3 f 33 3f 3 3 3 3 33333f33333333 f33f3ff3f3f3f3 333f33̙33 333f3333 333f3333 f3 ff f f f f 3f33ff3f3f3f3f ff3fffffffffff f3ffff̙ff f3ffffff f3ffffff 3 f 333f3333 f3ffffff 3f̙ ̙3̙f̙̙̙̙ 3f 3 f ̙ 333f3̙333 f3fff̙fff 3f̙̙ 3f̙ 3f̙ 3 f 333f3333 f3ffffff 3f̙ 3f 3f ! , " q H
*\p`BJlċ+bh#Ĉ5v$H G><9cń,i̒/qT0eM> p(QFiQN"U)ÖD{~LR$ת`. ; src/main/resources/jas/hist/cross.gif 0000644 0001750 0001750 00000001761 11325547132 020365 0 ustar giovanni giovanni GIF89a ̙fff33̙̙ffff333 3 T WwXwPYwtXw C : \ J a v a \ C l a s s l i b \ j a s \ h i s t \ c r o s s . g i f ?@
x >9fࣼ zewF H
Qw
0 X f f w f f ࣼ ! , H Y*\Ȱ!C @E0X`\ ) L60 @@eK ||0`&MXZ ` >~< ˝GX3&ŒP+&XA&RʵhVduȧ1ukQ ̢
F
Ћ[yʶ+=+N^Rjń[`P0]t {bU 4Zc˞M{a@ ; src/main/resources/jas/hist/running.gif 0000644 0001750 0001750 00000002053 11325547132 020707 0 ustar giovanni giovanni GIF89a# 3 fff3333 33 CC @ D wȰwT T WwXwPYwtXw C : \ J a v a \ C l a s s l i b \ j a s \ h i s t \ r u n n i n g . g i f ?@
x >9fࣼ JwH J L w, d X f f w f f ࣼ ! , # 7DEPÇ
AC^(#R I*cw%E29͇ q'O
!$Q&%
%̞: %GFjU
aUBʳԪ uʴ;VaϘ::%/BS&p1+ۄA.5*X'll H'sL@d=/:Ō'*ӧL-@ -F $؍$By6Q'tN\>[~|rn0y ; src/main/resources/jas/swingstudio/ 0000755 0001750 0001750 00000000000 11325547132 020150 5 ustar giovanni giovanni src/main/resources/jas/swingstudio/menus_devel.xml 0000644 0001750 0001750 00000031501 11325547132 023200 0 ustar giovanni giovanni