* 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; } } jas-plotter-2.2.10/src/main/java/jas/util/PropertyDialog.java 0000644 0002656 0002032 00000004733 10631357137 023341 0 ustar andreas admin 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; } jas-plotter-2.2.10/src/main/java/jas/util/Debug.java 0000644 0002656 0002032 00000004700 10631357137 021415 0 ustar andreas admin 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; } jas-plotter-2.2.10/src/main/java/jas/util/NestedRuntimeException.java 0000644 0002656 0002032 00000002654 10631354456 025043 0 ustar andreas admin 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); } } } jas-plotter-2.2.10/src/main/java/jas/util/ErrorBox.java 0000644 0002656 0002032 00000013505 10631357137 022134 0 ustar andreas admin package jas.util; import java.awt.BorderLayout; import java.awt.Dimension; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.awt.event.MouseAdapter; import java.awt.event.MouseEvent; import java.io.PrintWriter; import javax.swing.JFrame; import javax.swing.JLabel; import javax.swing.JMenuItem; import javax.swing.JOptionPane; import javax.swing.JPanel; import javax.swing.JPopupMenu; import javax.swing.JScrollPane; import javax.swing.JTextArea; import javax.swing.UIManager; /** * This class is used to show the user that an error has occurred. * If the error is in the form of a Throwable (normally an * Exception, but possibly an Error) then that object can be passed * to the error box so that the user can be notified of the exact * error. Invoke
doModal() on the object to show the error.
* @see java.lang.Throwable
* @see java.lang.Exception
* @see java.lang.Error
* @author Tony Johnson
* @author Jonas Gifford
*/
public class ErrorBox extends JASDialog
{
/**
* Opens an ErrorBox with no help button and no displayed Throwable.
* @param parent the parent JFrame
* @param message a String to display as a message
*/
public ErrorBox(JFrame parent, String message)
{
this(parent, message, null, null);
}
/**
* Opens an ErrorBox that has a Help button that opens the specified topic. Help books
* are accessible throught static constants in the Application class.
* @see Application
* @param parent the parent JFrame
* @param message a String to display as a message
* @param helpTopic the help topic (as specified in the .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;
} jas-plotter-2.2.10/src/main/java/jas/util/HasNextPages.java 0000644 0002656 0002032 00000002437 10631354456 022727 0 ustar andreas admin 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();
}
jas-plotter-2.2.10/src/main/java/jas/util/JTextFieldBinding.java 0000644 0002656 0002032 00000005574 10631357137 023676 0 ustar andreas admin package jas.util;
import java.lang.reflect.Constructor;
import javax.swing.JOptionPane;
import javax.swing.JTextField;
import javax.swing.event.DocumentEvent;
import javax.swing.event.DocumentListener;
public class JTextFieldBinding extends FieldBinding implements DocumentListener
{
protected JTextFieldBinding(JTextField field, byte flags)
{
this(field);
m_flags = flags;
}
protected JTextFieldBinding(JTextField field)
{
m_field = field;
field.getDocument().addDocumentListener(this);
}
void set(Object value)
{
String x = setValue(value);
if (!m_oldVal.equals(x))
{
m_field.setText(x);
m_oldVal = x;
}
}
protected String setValue(Object value)
{
String x;
if (value == null) x = "";
else if (value instanceof String) x = (String) value;
else x = value.toString();
return x;
}
protected Object getValue(String value, Class type) throws UnsupportedType
{
if (type.isPrimitive())
{
if (type == Double.TYPE ) return new Double(value);
if (type == Integer.TYPE) return new Integer(value);
throw new UnsupportedType(m_field,type);
}
else
{
Class[] strarg = { value.getClass() };
try
{
Constructor c = type.getConstructor(strarg);
Object[] args = { value };
return c.newInstance(args);
}
catch (Exception xx)
{
throw new UnsupportedType(m_field,type);
}
}
}
Object get(Class type) throws UnsupportedType
{
return getValue(m_field.getText(),type);
}
public void changedUpdate(DocumentEvent e) { update(); }
public void insertUpdate(DocumentEvent e) { update(); }
public void removeUpdate(DocumentEvent e) { update(); }
private void update()
{
String x = m_field.getText();
if (!x.equals(m_oldVal)) setChanged();
notifyObservers();
}
protected void reset()
{
super.reset();
m_oldVal = m_field.getText();
}
boolean hasValidInput()
{
final String value = m_field.getText();
if ((m_flags & MUST_BE_NUMBER) != 0)
{
try
{
double d = (m_flags & MUST_BE_INTEGER_FLAG) != 0 ? (double) Integer.parseInt(value) : Double.valueOf(value).doubleValue();
if ((m_flags & MUST_BE_POSITIVE) != 0 && d <= 0.0)
{
JOptionPane.showMessageDialog(m_field,
value.concat(" is invalid input; value must be positive."),
"Error", JOptionPane.ERROR_MESSAGE);
return false;
}
}
catch (NumberFormatException e)
{
JOptionPane.showMessageDialog(m_field,
value +" is invalid input; value must be a"+
((m_flags & MUST_BE_INTEGER) != 0 ? "n integer." : " number."),
"Error", JOptionPane.ERROR_MESSAGE);
return false;
}
}
return true;
}
private String m_oldVal = "";
private JTextField m_field;
private byte m_flags = 0;
public static final byte MUST_BE_NUMBER = 1;
private static final byte MUST_BE_INTEGER_FLAG = 2;
public static final byte MUST_BE_INTEGER = MUST_BE_INTEGER_FLAG | MUST_BE_NUMBER;
public static final byte MUST_BE_POSITIVE = 4;
}
jas-plotter-2.2.10/src/main/java/jas/util/JASDialog.java 0000644 0002656 0002032 00000032222 10631357137 022124 0 ustar andreas admin package jas.util;
import java.awt.AWTEvent;
import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.Container;
import java.awt.Dialog;
import java.awt.Frame;
import java.awt.Window;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.WindowEvent;
import javax.swing.BorderFactory;
import javax.swing.JButton;
import javax.swing.JDialog;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;
import javax.swing.event.DocumentEvent;
import javax.swing.event.DocumentListener;
/**
* JASDialog extends the built in java dialog to provide a number of extra features
* 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(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;
}
jas-plotter-2.2.10/src/main/java/jas/util/IndentPrintWriter.java 0000644 0002656 0002032 00000003170 10631357137 024022 0 ustar andreas admin package jas.util;
import java.io.PrintWriter;
import java.io.Writer;
/**
* A PrintWriter that keeps track of an indentation level
* and indents the output appropriately.
*
* Warning: Only print and println methods taking strings have been overriden,
* print, println methods taking other arguments may not be indented properly.
*/
public class IndentPrintWriter extends PrintWriter
{
public IndentPrintWriter(Writer w)
{
super(w);
}
public void println(String s)
{
if (!indented) doIndent();
super.println(s);
indented = false;
}
public void print(String s)
{
if (!indented) doIndent();
super.print(s);
}
public void println()
{
super.println();
indented = false;
}
private void doIndent()
{
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);
}
}
}
jas-plotter-2.2.10/src/main/java/jas/util/BooleanCommandTarget.java 0000644 0002656 0002032 00000000604 10631354456 024414 0 ustar andreas admin 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);
}
jas-plotter-2.2.10/src/main/java/jas/util/SciFormatPanel.java 0000644 0002656 0002032 00000006460 10631357137 023243 0 ustar andreas admin package jas.util;
import java.awt.FlowLayout;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.ButtonGroup;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JRadioButton;
/**Creates a jpanel that allows users to set the parameters used by ScientificFormat
* objects for number formatting. The panel allows the setting of significant digits,
* max width of number and formatting styles.
* * @author Paul Spence
* @version 03/20/2000
*/
public class SciFormatPanel extends JPanel implements ActionListener
{
public SciFormatPanel(ScientificFormat s)
{
f=s;
createPanel();
}
private ScientificFormat f;
private JLabel WidthLabel;
private JLabel SigLabel;
private JPanel DisplayStyle;
private JRadioButton PureSci;
private JRadioButton StandardSci;
private SpinBox widthdigits;
private SpinBox sigdigits;
private void createPanel()
{
JPanel DisplayOptions = new JPanel(new FlowLayout(FlowLayout.CENTER));
SigLabel = new JLabel("Significant Digits");
WidthLabel = new JLabel("Maximum Digits");
sigdigits = new SpinBox(f.getSigDigits(),1,15);
widthdigits = new SpinBox(f.getMaxWidth(),1,100);
sigdigits.setValue(f.getSigDigits());
widthdigits.setValue(f.getMaxWidth());
sigdigits.addActionListener(new MySpinBoxListener());
widthdigits.addActionListener(new MySpinBoxListener());
if(f.getScientificNotationStyle()){
widthdigits.setEnabled(false);
WidthLabel.setEnabled(false);
}
DisplayOptions.add(SigLabel);
DisplayOptions.add(sigdigits);
DisplayOptions.add(WidthLabel);
DisplayOptions.add(widthdigits);
JPanel Style = new JPanel(new FlowLayout(FlowLayout.CENTER));
PureSci = new JRadioButton("Use Pure Scientific Notation", f.getScientificNotationStyle());
PureSci.setActionCommand("PureSci");
PureSci.addActionListener(this);
StandardSci = new JRadioButton("Use Standard Scientific Notation", !(f.getScientificNotationStyle()));
StandardSci.setActionCommand("StandSci");
StandardSci.addActionListener(this);
Style.add(PureSci);
Style.add(StandardSci);
final ButtonGroup group = new ButtonGroup();
group.add(PureSci);
group.add(StandardSci);
DisplayStyle = new JPanel();
DisplayStyle.setLayout(new GridLayout(2,1));
DisplayStyle.add(DisplayOptions);
DisplayStyle.add(Style);
}
/**Sets the ScientificFormat objects parameters according to the SciFormatPanels values.
* To be called when 'ok' or 'apply' buttons int the panels' parent container is
* selected.
*/
public void updateSciFormat(){
f.setMaxWidth(widthdigits.getValue());
f.setSigDigits(sigdigits.getValue());
f.setScientificNotationStyle(PureSci.isSelected());
}
/**Get the DisplayStyle panel */
public JPanel getPanel(){
return DisplayStyle;
}
public void actionPerformed(ActionEvent e) {
if (e.getActionCommand() == "StandSci") {
WidthLabel.setEnabled(true);
widthdigits.setEnabled(true);
}else if (e.getActionCommand() == "PureSci") {
WidthLabel.setEnabled(false);
widthdigits.setEnabled(false);
}
}
class MySpinBoxListener implements ActionListener{
public void actionPerformed(ActionEvent evt){
if( (widthdigits.getValue() < sigdigits.getValue()) ){
widthdigits.setValue(sigdigits.getValue());
}
}
}
}
jas-plotter-2.2.10/src/main/java/jas/util/JASCheckboxMenuItem.java 0000644 0002656 0002032 00000004022 10631357137 024114 0 ustar andreas admin 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;
}
jas-plotter-2.2.10/src/main/java/jas/util/ColorListener.java 0000644 0002656 0002032 00000000130 10631354456 023145 0 ustar andreas admin package jas.util;
public interface ColorListener
{
void colorChanged(ColorEvent c);
}
jas-plotter-2.2.10/src/main/java/jas/util/SplashScreen.java 0000644 0002656 0002032 00000004130 10631357137 022756 0 ustar andreas admin 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();
}
}
}
jas-plotter-2.2.10/src/main/java/jas/util/DateChooser.java 0000644 0002656 0002032 00000027456 10631357137 022604 0 ustar andreas admin 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;
}
jas-plotter-2.2.10/src/main/java/jas/util/NestedException.java 0000644 0002656 0002032 00000003272 10631354456 023474 0 ustar andreas admin 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);
}
}
}
jas-plotter-2.2.10/src/main/java/jas/util/xml/ 0000755 0002656 0002032 00000000000 14746176465 020341 5 ustar andreas admin jas-plotter-2.2.10/src/main/java/jas/util/xml/parserwrappers/ 0000755 0002656 0002032 00000000000 14746176450 023413 5 ustar andreas admin jas-plotter-2.2.10/src/main/java/jas/util/xml/parserwrappers/XMLErrorHandler.java 0000644 0002656 0002032 00000002112 10631357137 027212 0 ustar andreas admin /*
* XMLErrorHandler.java
*
* Created on March 31, 2002, 12:08 AM
*/
package jas.util.xml.parserwrappers;
import org.xml.sax.ErrorHandler;
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;
/**
*
* @author tonyj
*/
class XMLErrorHandler implements ErrorHandler
{
private int level = 0;
private String fileName;
XMLErrorHandler(String fileName)
{
this.fileName = fileName;
}
int getLevel()
{
return level;
}
public void warning(SAXParseException exception)
{
//System.err.println(fileName+": Warning at line "+exception.getLineNumber()+": "+exception);
if (level < 1) level = 1;
}
public void error(SAXParseException exception)
{
System.err.println(fileName+": Error at line "+exception.getLineNumber()+": "+exception);
if (level < 2) level = 2;
}
public void fatalError(SAXParseException exception) throws SAXException
{
System.err.println(fileName+": Fatal error at line "+exception.getLineNumber()+": "+exception);
if (level < 3) level = 3;
throw exception;
}
}
jas-plotter-2.2.10/src/main/java/jas/util/xml/parserwrappers/JAXPDOMParser.java 0000644 0002656 0002032 00000005075 10631357137 026534 0 ustar andreas admin /*
* JAXPDomParser.java
*
* Created on March 30, 2002, 11:51 PM
*/
package jas.util.xml.parserwrappers;
import jas.util.xml.JASDOMParser;
import java.io.IOException;
import java.io.Reader;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.w3c.dom.Document;
import org.xml.sax.EntityResolver;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
/**
*
* @author tonyj
*/
public class JAXPDOMParser extends JASDOMParser
{
/**
* Create a DOM document by reading an XML file
* @param in A reader set up to read an XML file
* @param fileName The name of the file being read (used in error messages)
* @return Document The resulting DOM
* @exception XMLException thrown if there is an error reading the XML
*/
public Document parse(Reader in, String fileName) throws JASXMLException
{
return parse(in,fileName,null);
}
/**
* Create a DOM document by reading an XML file with an explicit entity resolver.
* An entity resolver is typically used to specify where to find the DTD for the XML
* document.
* @param in A reader set up to read an XML file
* @param fileName The name of the file being read (used in error messages)
* @param resolver An entity resolver to use when reading the XML file
* @return Document The resulting DOM
* @exception XMLException thrown if there is an error reading the XML
*/
public Document parse(Reader in, String fileName, EntityResolver resolver) throws JASXMLException
{
try
{
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
factory.setValidating(true);
DocumentBuilder parser = factory.newDocumentBuilder();
XMLErrorHandler errorHandler = new XMLErrorHandler(fileName);
parser.setErrorHandler(errorHandler);
if (resolver != null) parser.setEntityResolver(resolver);
InputSource is = new InputSource(in);
is.setSystemId("file:/");
Document doc = parser.parse(is);
if (errorHandler.getLevel() > 1) throw new SAXException("Error during XML file parsing");
return doc;
}
catch (SAXException x)
{
throw new JASDOMParser.JASXMLException("Syntax error parsing XML file",x);
}
catch (IOException x)
{
throw new JASDOMParser.JASXMLException("IO error parsing XML file",x);
}
catch (ParserConfigurationException x)
{
throw new JASDOMParser.JASXMLException("Can not create XML parser",x);
}
}
}
jas-plotter-2.2.10/src/main/java/jas/util/xml/ClassPathEntityResolver.java 0000644 0002656 0002032 00000001536 10631357137 025774 0 ustar andreas admin package jas.util.xml;
import org.xml.sax.EntityResolver;
import org.xml.sax.InputSource;
/**
* An implementation of an EntityResolver which can be used to locate
* DTD files located on the current java class path
*/
public class ClassPathEntityResolver implements EntityResolver
{
/**
* Constructor
* @param DTDName The DTDName to resolve
* @oaram root A Class in the same package as the DTD
*/
public ClassPathEntityResolver(String DTDName, Class root)
{
this.name = DTDName;
this.root = root;
}
/**
* Implementation of resolveEntity method
*/
public InputSource resolveEntity(String publicId, String systemId)
{
if (systemId.endsWith(name))
{
return new InputSource(root.getResourceAsStream(name));
}
else
{
// use the default behaviour
return null;
}
}
private String name;
private Class root;
}
jas-plotter-2.2.10/src/main/java/jas/util/xml/XMLWriter.java 0000644 0002656 0002032 00000030750 10631357137 023030 0 ustar andreas admin package jas.util.xml;
import jas.util.IndentPrintWriter;
import java.io.IOException;
import java.io.Writer;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Stack;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
/**
* A class that makes it easy to write XML documents.
*
* @author Tony Johnson
* @author Mark Donszelmann
* @version $Id: XMLWriter.java 11553 2007-06-05 22:06:23Z duns $
*/
public class XMLWriter
{
public XMLWriter(Writer w, String indentString)
{
writer = new IndentPrintWriter(w);
writer.setIndentString(indentString);
}
public XMLWriter(Writer w)
{
this(w, " "); // By popular demand of Babar
}
/**
* closes the writer
*/
public void close() throws IOException
{
closeDoc();
writer.close();
}
/**
* Opens the document with an xml header
*/
public void openDoc()
{
openDoc("1.0", "", false);
}
/**
* Opens the document with an xml header
*/
public void openDoc(String version, String encoding, boolean standalone)
{
String indentString = writer.getIndentString();
writer.setIndentString(indentString);
closed = false;
if (!XMLCharacterProperties.validVersionNum(version)) throw new RuntimeException("Invalid version number: "+version);
writer.print("");
writer.setIndentString(indentString);
}
/**
* Writes a reference to a DTD
*/
public void referToDTD(String name, String pid, String ref) {
if (dtdName != null) {
throw new RuntimeException("ReferToDTD cannot be called twice");
}
dtdName = name;
writer.println("");
}
/**
* Writes a reference to a DTD
*/
public void referToDTD(String name, String system)
{
if (dtdName != null) {
throw new RuntimeException("ReferToDTD cannot be called twice");
}
dtdName = name;
writer.println("");
}
/**
* Closes the document, and checks if you closed all the tags
*/
public void closeDoc()
{
if (!closed) {
if (!openTags.isEmpty()) {
StringBuffer sb = new StringBuffer("Not all tags were closed before closing XML document:\n");
while (!openTags.isEmpty()) {
sb.append(" \n");
}
throw new RuntimeException(sb.toString());
}
closed = true;
}
}
/**
* Print a comment
*/
public void printComment(String comment)
{
if (comment.indexOf("--") >= 0) throw new RuntimeException("'--' sequence not allowed in comment");
writer.print("");
}
/**
* Prints character data, while escaping < and >
*/
public void print(String text)
{
writer.print(normalizeText(text));
}
/**
* Prints character data, while escaping < and >
*/
public void println(String text)
{
print(text);
writer.println();
}
public void println()
{
writer.println();
}
public void print(double d)
{
print(String.valueOf(d));
}
/**
* Prints a new XML tag and increases the identation level
*/
public void openTag(String namespace, String name)
{
openTag(namespace+":"+name);
}
/**
* Prints a new XML tag and increases the identation level
*/
public void openTag(String name)
{
checkNameValid(name);
if (openTags.isEmpty() && dtdName != null && !dtdName.equals(name)) {
throw new RuntimeException("First tag: '"+name+"' not equal to DTD id: '"+dtdName+"'");
}
writer.print("<"+name);
printAttributes(name.length());
writer.println(">");
writer.indent();
openTags.push(name);
}
/**
* Closes the current XML tag and decreases the indentation level
*/
public void closeTag()
{
if (openTags.isEmpty()) {
writer.close();
throw new RuntimeException("No open tags");
}
Object name = openTags.pop();
writer.outdent();
writer.print("");
}
/**
* Prints an empty XML tag.
*/
public void printTag(String namespace, String name)
{
printTag(namespace+":"+name);
}
/**
* Prints an empty XML tag.
*/
public void printTag(String name)
{
checkNameValid(name);
writer.print("<"+name);
printAttributes(name.length());
writer.println("/>");
}
/**
* Sets an attribute which will be included in the next tag
* printed by openTag or printTag
*/
public void setAttribute(String name, String value)
{
if ((name != null) && (value != null)) {
attributes.put(name,value);
}
}
public void setAttribute(String namespace, String name, String value)
{
if ((namespace != null) && (name != null)) {
attributes.put(namespace+":"+name, value);
}
}
public void setAttribute(String name, double value) { setAttribute(name, String.valueOf(value)); }
public void setAttribute(String name, float value) { setAttribute(name, String.valueOf(value)); }
public void setAttribute(String name, int value) { setAttribute(name, String.valueOf(value)); }
public void setAttribute(String name, long value) { setAttribute(name, String.valueOf(value)); }
public void setAttribute(String name, short value) { setAttribute(name, String.valueOf(value)); }
public void setAttribute(String name, boolean value) { setAttribute(name, String.valueOf(value)); }
public void setAttribute(String name, byte value) { setAttribute(name, String.valueOf(value)); }
public void setAttribute(String name, char value) { setAttribute(name, String.valueOf(value)); }
public void setAttribute(String ns, String name, double value) { setAttribute(ns+":"+name, String.valueOf(value)); }
public void setAttribute(String ns, String name, int value) { setAttribute(ns+":"+name, String.valueOf(value)); }
public void setAttribute(String ns, String name, boolean value) { setAttribute(ns+":"+name, String.valueOf(value)); }
protected void printAttributes(int tagLength)
{
int width = tagLength + 1;
boolean extraIndent = false;
Enumeration e = attributes.keys();
while (e.hasMoreElements())
{
String key = e.nextElement().toString();
checkNameValid(key);
String value = normalize(attributes.get(key).toString());
int length = key.length() + value.length() + 3;
if (width > 0 && width + length + 2*writer.getIndent() > 60)
{
width = 0;
writer.println();
if (!extraIndent)
{
writer.indent();
extraIndent = true;
}
}
else
{
width += length;
writer.print(' ');
}
writer.print(key);
writer.print("=\"");
writer.print(value);
writer.print("\"");
}
attributes.clear();
if (extraIndent) writer.outdent();
}
/**
* Prints a DOM node, recursively.
* No support for a document node
*/
public void print(Node node)
{
if ( node == null ) return;
int type = node.getNodeType();
switch ( type ) {
// print document
case Node.DOCUMENT_NODE:
throw new RuntimeException("No support for printing nodes of type Document");
// print element with attributes
case Node.ELEMENT_NODE:
NamedNodeMap attributes = node.getAttributes();
for ( int i = 0; i < attributes.getLength(); i++ ) {
Node attr = attributes.item(i);
setAttribute(attr.getNodeName(), attr.getNodeValue());
}
NodeList children = node.getChildNodes();
if ( children == null ) {
printTag(node.getNodeName());
} else {
openTag(node.getNodeName());
int len = children.getLength();
for ( int i = 0; i < len; i++ ) {
print(children.item(i));
}
closeTag();
}
break;
// handle entity reference nodes
case Node.ENTITY_REFERENCE_NODE:
writer.print('&');
writer.print(node.getNodeName());
writer.print(';');
break;
// print cdata sections
case Node.CDATA_SECTION_NODE:
writer.print("");
break;
// print text
case Node.TEXT_NODE:
print(node.getNodeValue());
break;
// print processing instruction
case Node.PROCESSING_INSTRUCTION_NODE:
writer.print(" 0 ) {
writer.print(' ');
writer.print(data);
}
writer.print("?>");
break;
}
} // print(Node)
/** Normalizes the given string for an Attribute value*/
public static String normalize(String s)
{
StringBuffer str = new StringBuffer();
int len = (s != null) ? s.length() : 0;
for (int i = 0; i < len; i++) {
char ch = s.charAt(i);
switch (ch) {
case '<': {
str.append("<");
break;
}
case '>': {
str.append(">");
break;
}
case '&': {
str.append("&");
break;
}
case '"': {
str.append(""");
break;
}
case '\r':
case '\n': {
str.append("&#");
str.append(Integer.toString(ch));
str.append(';');
break;
}
default: {
if (ch > 0x00FF) {
String hex = "0000"+Integer.toHexString(ch);
str.append("&#x");
str.append(hex.substring(hex.length()-4));
str.append(';');
} else {
str.append(ch);
}
}
}
}
return str.toString();
} // normalize(String):String
/** Normalizes the given string for Text */
public static String normalizeText(String s)
{
StringBuffer str = new StringBuffer();
int len = (s != null) ? s.length() : 0;
for (int i = 0; i < len; i++) {
char ch = s.charAt(i);
switch (ch) {
case '<': {
str.append("<");
break;
}
case '>': {
str.append(">");
break;
}
case '&': {
str.append("&");
break;
}
default: {
if (ch > 0x00FF) {
String hex = "0000"+Integer.toHexString(ch);
str.append("&#x");
str.append(hex.substring(hex.length()-4));
str.append(';');
} else {
str.append(ch);
}
}
}
}
return str.toString();
}
protected void checkNameValid(String s)
{
if (!XMLCharacterProperties.validName(s)) throw new RuntimeException("Invalid name: "+s);
}
protected boolean closed = true;
private String dtdName = null;
private Hashtable attributes = new Hashtable();
private Stack openTags = new Stack();
protected IndentPrintWriter writer;
}
jas-plotter-2.2.10/src/main/java/jas/util/xml/HasXMLRepresentation.java 0000644 0002656 0002032 00000000311 10631354456 025201 0 ustar andreas admin package jas.util.xml;
/**
* An interface to be implemented by Objects which can
* provide their own XML representation
*/
public interface HasXMLRepresentation
{
void writeAsXML(XMLWriter pw);
}
jas-plotter-2.2.10/src/main/java/jas/util/xml/JASDOMParser.java 0000644 0002656 0002032 00000004146 10631357137 023325 0 ustar andreas admin package jas.util.xml;
import jas.util.NestedException;
import jas.util.NestedRuntimeException;
import java.io.Reader;
import org.w3c.dom.Document;
import org.xml.sax.EntityResolver;
/**
* Ideally wouldnt need this interface, except that the DOM specification
* only specifies how to extract information from a DOM, not how to create
* a DOM from an XML file. The JASDOMParser interface is meant to make up
* for that deficiency.
*/
public abstract class JASDOMParser
{
/**
* Create a DOM document by reading an XML file
* @param in A reader set up to read an XML file
* @param fileName The name of the file being read (used in error messages)
* @return Document The resulting DOM
* @exception XMLException thrown if there is an error reading the XML
*/
public abstract Document parse(Reader in, String fileName) throws JASXMLException;
/**
* Create a DOM document by reading an XML file with an explicit entity resolver.
* An entity resolver is typically used to specify where to find the DTD for the XML
* document.
* @param in A reader set up to read an XML file
* @param fileName The name of the file being read (used in error messages)
* @param resolver An entity resolver to use when reading the XML file
* @return Document The resulting DOM
* @exception XMLException thrown if there is an error reading the XML
*/
public abstract Document parse(Reader in, String fileName, EntityResolver resolver) throws JASXMLException;
/**
* An exception that gets thrown if there is an error reading an XML file.
*/
public static class JASXMLException extends NestedException
{
public JASXMLException(String message)
{
super(message,null);
}
public JASXMLException(String message, Throwable detail)
{
super(message,detail);
}
}
/**
* Creates a default instance of a JASDOMParser
* @return A JASDOMParser
*/
public static JASDOMParser instance()
{
try
{
return (JASDOMParser) Class.forName("jas.util.xml.parserwrappers.JAXPDOMParser").newInstance();
}
catch (Throwable x)
{
throw new NestedRuntimeException("Unable to create default JASDomParser",x);
}
}
}
jas-plotter-2.2.10/src/main/java/jas/util/xml/XMLNodeTraverser.java 0000644 0002656 0002032 00000005756 10631357137 024347 0 ustar andreas admin package jas.util.xml;
import jas.util.ColorConverter;
import java.awt.Color;
import org.w3c.dom.Attr;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.Text;
/**
* Utility class for traversing XML DOM trees
*/
public abstract class XMLNodeTraverser
{
public void traverse(Node node) throws BadXMLException
{
if (node instanceof Element)
{
handleElementAttributes((Element) node);
}
for (Node n = node.getFirstChild(); n != null; n = n.getNextSibling())
{
handleSubNode(n,n.getNodeName());
}
}
protected void handleSubNode(Node node, String name) throws BadXMLException
{
int type = node.getNodeType();
switch (type)
{
case Node.ELEMENT_NODE:
handleElement((Element) node,name);
break;
case Node.TEXT_NODE:
handleTextNode((Text) node,name);
break;
default:
handleOtherNode(node,name);
}
}
protected void handleElementAttributes(Element node) throws BadXMLException
{
NamedNodeMap nnm = node.getAttributes();
for (int i=0; igetBackground() 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);
}
}
jas-plotter-2.2.10/src/main/java/jas/util/ColorChooser.java 0000644 0002656 0002032 00000005521 10631354456 022773 0 ustar andreas admin package jas.util;
import java.awt.Color;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.util.Enumeration;
import java.util.Vector;
import javax.swing.Icon;
import javax.swing.JButton;
import javax.swing.JColorChooser;
import javax.swing.JOptionPane;
import javax.swing.colorchooser.AbstractColorChooserPanel;
/**
* A button which allows the user to select a color.
*/
public class ColorChooser extends JButton
{
public ColorChooser()
{
this(Color.black);
}
public ColorChooser(Color c)
{
m_color = c;
setIcon(new ColorChooserIcon());
}
public ColorChooser(final String key)
{
this();
m_prop = Application.getApplication().getUserProperties();
m_key = key;
setColor(m_prop.getColor(key, Color.black));
}
public void setColor(Color c)
{
m_color = c;
repaint(); // Should not be necessary? (swing 0.6.1)
Enumeration e = m_listeners.elements();
while (e.hasMoreElements())
{
ColorListener l = (ColorListener) e.nextElement();
l.colorChanged(new ColorEvent(this,c));
}
}
public Color getColor()
{
return m_color;
}
public void addColorListener(ColorListener l)
{
m_listeners.addElement(l);
}
public void removeColorListener(ColorListener l)
{
m_listeners.removeElement(l);
}
protected void fireActionPerformed(ActionEvent e)
{
JColorChooser chooser = new JColorChooser(m_color);
chooser.addChooserPanel(new ARGBColorChooserPanel());
if (m_color.getAlpha() != 255)
{
AbstractColorChooserPanel[] panels = chooser.getChooserPanels();
int l = panels.length;
AbstractColorChooserPanel[] newpanels = new AbstractColorChooserPanel[l];
for (int i=1; iToolbarLayout.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.
*
* The value of the alignment argument must be one of
* 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 + "]";
}
}
jas-plotter-2.2.10/src/main/java/jas/util/JASEditableComboBox.java 0000644 0002656 0002032 00000024124 10631357137 024071 0 ustar andreas admin 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:
*
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.
* 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 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;
} jas-plotter-2.2.10/src/main/java/jas/util/HasNestedException.java 0000644 0002656 0002032 00000000243 10631354456 024123 0 ustar andreas admin package jas.util;
public interface HasNestedException
{
public Throwable getNestedException();
public String getSimpleMessage();
public String getMessage();
}
jas-plotter-2.2.10/src/main/java/jas/util/ChoiceFieldBinding.java 0000644 0002656 0002032 00000001741 10631357137 024022 0 ustar andreas admin 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;
}
jas-plotter-2.2.10/src/main/java/jas/util/ARGBColorChooserPanel.java 0000644 0002656 0002032 00000016577 10631354456 024424 0 ustar andreas admin package jas.util;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.FlowLayout;
import java.awt.GridBagLayout;
import java.awt.GridBagConstraints;
import javax.swing.Icon;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JSlider;
import javax.swing.JSpinner;
import javax.swing.SpinnerNumberModel;
import javax.swing.colorchooser.AbstractColorChooserPanel;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
/**
*
* @author tonyj
*/
public class ARGBColorChooserPanel extends AbstractColorChooserPanel implements ChangeListener
{
protected JSlider redSlider;
protected JSlider greenSlider;
protected JSlider blueSlider;
protected JSlider alphaSlider;
protected JSpinner redSpinner;
protected JSpinner blueSpinner;
protected JSpinner greenSpinner;
protected JSpinner alphaSpinner;
private final int minValue = 0;
private final int maxValue = 255;
private boolean isAdjusting = false;
public ARGBColorChooserPanel()
{
super();
}
private void setColor(Color color)
{
int red = color.getRed();
int blue = color.getBlue();
int green = color.getGreen();
int alpha = color.getAlpha();
if (redSlider.getValue() != red)
{
redSlider.setValue(red);
}
if (greenSlider.getValue() != green)
{
greenSlider.setValue(green);
}
if (blueSlider.getValue() != blue)
{
blueSlider.setValue(blue);
}
if (alphaSlider.getValue() != alpha)
{
alphaSlider.setValue(alpha);
}
if (((Integer)redSpinner.getValue()).intValue() != red)
{
redSpinner.setValue(new Integer(red));
}
if (((Integer)greenSpinner.getValue()).intValue() != green)
{
greenSpinner.setValue(new Integer(green));
}
if (((Integer)blueSpinner.getValue()).intValue() != blue)
{
blueSpinner.setValue(new Integer(blue));
}
if (((Integer)alphaSpinner.getValue()).intValue() != alpha)
{
alphaSpinner.setValue(new Integer(alpha));
}
}
public String getDisplayName()
{
return "ARGB";
}
public Icon getSmallDisplayIcon()
{
return null;
}
public Icon getLargeDisplayIcon()
{
return null;
}
protected void buildChooser()
{
setLayout(new BorderLayout());
Color color = getColorFromModel();
JPanel panel = new JPanel();
GridBagLayout layout = new GridBagLayout();
GridBagConstraints con = new GridBagConstraints();
panel.setLayout(layout);
add(panel, BorderLayout.CENTER);
JLabel l = new JLabel("Red");
con.gridwidth = 1;
layout.setConstraints(l, con);
panel.add(l);
redSlider = new JSlider(JSlider.HORIZONTAL, 0, 255, color.getRed());
redSlider.setMajorTickSpacing(85);
redSlider.setMinorTickSpacing(17);
redSlider.setPaintTicks(true);
redSlider.setPaintLabels(true);
layout.setConstraints(redSlider, con);
l.setLabelFor(redSlider);
panel.add(redSlider);
redSpinner = new JSpinner(
new SpinnerNumberModel(color.getRed(), minValue, maxValue, 1));
JPanel redSpinnerHolder = new JPanel(new FlowLayout());
redSpinner.addChangeListener(this);
redSpinnerHolder.add(redSpinner);
con.gridwidth = GridBagConstraints.REMAINDER;
layout.setConstraints(redSpinnerHolder, con);
panel.add(redSpinnerHolder);
l = new JLabel("Green");
con.gridwidth = 1;
layout.setConstraints(l, con);
panel.add(l);
greenSlider = new JSlider(JSlider.HORIZONTAL, 0, 255, color.getGreen());
greenSlider.setMajorTickSpacing(85);
greenSlider.setMinorTickSpacing(17);
greenSlider.setPaintTicks(true);
greenSlider.setPaintLabels(true);
layout.setConstraints(greenSlider, con);
panel.add(greenSlider);
greenSpinner = new JSpinner(
new SpinnerNumberModel(color.getGreen(), minValue, maxValue, 1));
l.setLabelFor(greenSlider);
JPanel greenSpinnerHolder = new JPanel(new FlowLayout());
greenSpinnerHolder.add(greenSpinner);
greenSpinner.addChangeListener(this);
con.gridwidth = GridBagConstraints.REMAINDER;
layout.setConstraints(greenSpinnerHolder, con);
panel.add(greenSpinnerHolder);
l = new JLabel("Blue");
con.gridwidth = 1;
layout.setConstraints(l, con);
panel.add(l);
blueSlider = new JSlider(JSlider.HORIZONTAL, 0, 255, color.getBlue());
blueSlider.setMajorTickSpacing(85);
blueSlider.setMinorTickSpacing(17);
blueSlider.setPaintTicks(true);
blueSlider.setPaintLabels(true);
layout.setConstraints(blueSlider, con);
panel.add(blueSlider);
blueSpinner = new JSpinner(
new SpinnerNumberModel(color.getBlue(), minValue, maxValue, 1));
l.setLabelFor(blueSlider);
JPanel blueSpinnerHolder = new JPanel(new FlowLayout());
blueSpinnerHolder.add(blueSpinner);
blueSpinner.addChangeListener(this);
con.gridwidth = GridBagConstraints.REMAINDER;
layout.setConstraints(blueSpinnerHolder, con);
panel.add(blueSpinnerHolder);
l = new JLabel("Alpha");
con.gridwidth = 1;
layout.setConstraints(l, con);
panel.add(l);
alphaSlider = new JSlider(JSlider.HORIZONTAL, 0, 255, color.getAlpha());
alphaSlider.setMajorTickSpacing(85);
alphaSlider.setMinorTickSpacing(17);
alphaSlider.setPaintTicks(true);
alphaSlider.setPaintLabels(true);
layout.setConstraints(alphaSlider, con);
panel.add(alphaSlider);
alphaSpinner = new JSpinner(
new SpinnerNumberModel(color.getAlpha(), minValue, maxValue, 1));
l.setLabelFor(alphaSlider);
JPanel alphaSpinnerHolder = new JPanel(new FlowLayout());
alphaSpinnerHolder.add(alphaSpinner);
alphaSpinner.addChangeListener(this);
con.gridwidth = GridBagConstraints.REMAINDER;
layout.setConstraints(alphaSpinnerHolder, con);
panel.add(alphaSpinnerHolder);
redSlider.addChangeListener(this);
greenSlider.addChangeListener(this);
blueSlider.addChangeListener(this);
alphaSlider.addChangeListener(this);
}
public void updateChooser()
{
if (!isAdjusting)
{
isAdjusting = true;
setColor(getColorFromModel());
isAdjusting = false;
}
}
public void stateChanged(ChangeEvent e)
{
if (e.getSource() instanceof JSlider && !isAdjusting)
{
int red = redSlider.getValue();
int green = greenSlider.getValue();
int blue = blueSlider.getValue() ;
int alpha = alphaSlider.getValue() ;
Color color = new Color(red, green, blue, alpha);
getColorSelectionModel().setSelectedColor(color);
}
else if (e.getSource() instanceof JSpinner && !isAdjusting)
{
int red = ((Integer)redSpinner.getValue()).intValue();
int green = ((Integer)greenSpinner.getValue()).intValue();
int blue = ((Integer)blueSpinner.getValue()).intValue();
int alpha = ((Integer)alphaSpinner.getValue()).intValue();
Color color = new Color(red, green, blue, alpha);
getColorSelectionModel().setSelectedColor(color);
}
}
} jas-plotter-2.2.10/src/main/java/jas/util/JCheckBoxFieldBinding.java 0000644 0002656 0002032 00000001777 10631357137 024441 0 ustar andreas admin 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;
}
jas-plotter-2.2.10/src/main/java/jas/util/CommandSource.java 0000644 0002656 0002032 00000001715 10631354456 023132 0 ustar andreas admin 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();
}
jas-plotter-2.2.10/src/main/java/jas/util/UnsupportedType.java 0000644 0002656 0002032 00000000272 10631357137 023561 0 ustar andreas admin package jas.util;
import java.awt.Component;
class UnsupportedType extends Exception
{
UnsupportedType(Component c,Class t)
{
super("Cannot bind type "+t+" to "+c.getClass());
}
}
jas-plotter-2.2.10/src/main/java/jas/util/ObjectFactoryException.java 0000644 0002656 0002032 00000000225 10631354456 025003 0 ustar andreas admin package jas.util;
public class ObjectFactoryException extends NestedException
{
ObjectFactoryException(String s,Throwable t)
{
super(s,t);
}
}
jas-plotter-2.2.10/src/main/java/jas/util/border/ 0000755 0002656 0002032 00000000000 14746176445 021014 5 ustar andreas admin jas-plotter-2.2.10/src/main/java/jas/util/border/ShadowBorder.java 0000644 0002656 0002032 00000004704 10631357137 024233 0 ustar andreas admin 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();
}
jas-plotter-2.2.10/src/main/java/jas/util/CheckboxFieldBinding.java 0000644 0002656 0002032 00000001755 10631357137 024363 0 ustar andreas admin package jas.util;
import java.awt.Checkbox;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
class CheckboxFieldBinding extends FieldBinding implements ItemListener
{
CheckboxFieldBinding(Checkbox 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.setState(x);
m_oldVal = x;
}
}
Object get(Class type) throws UnsupportedType
{
if (type != Boolean.TYPE) throw new UnsupportedType(m_field,type);
boolean x = m_field.getState();
return new Boolean(x);
}
public void itemStateChanged(ItemEvent e)
{
boolean x = m_field.getState();
if (x != m_oldVal) setChanged();
notifyObservers();
}
protected void reset()
{
super.reset();
m_oldVal = m_field.getState();
}
private boolean m_oldVal = false;
private Checkbox m_field;
}
jas-plotter-2.2.10/src/main/java/jas/util/FileReaderWithProgressBar.java 0000644 0002656 0002032 00000006524 10631357137 025405 0 ustar andreas admin 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;
}
jas-plotter-2.2.10/src/main/java/jas/util/DocumentOutputStream.java 0000644 0002656 0002032 00000005145 10631357137 024546 0 ustar andreas admin 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 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;
}
jas-plotter-2.2.10/src/main/java/jas/util/HelpInterface.java 0000644 0002656 0002032 00000001611 10631357137 023076 0 ustar andreas admin 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);
}
jas-plotter-2.2.10/src/main/java/jas/util/JASIcon.java 0000644 0002656 0002032 00000013615 10631357137 021622 0 ustar andreas admin 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!");
}
}
}
jas-plotter-2.2.10/src/main/java/jas/util/DoubleWithError.java 0000644 0002656 0002032 00000001251 10631354456 023446 0 ustar andreas admin package jas.util;
/**
* A class that encapsulates a value and its error.
* Primarily for use with ScientificFormat
* @see jas.util.ScientificFormat
*/
public class DoubleWithError
{
public DoubleWithError(double value, double error)
{
this.value = value;
this.error = error;
}
public void setError(double error)
{
this.error = error;
}
public double getError()
{
return error;
}
public void setValue(double value)
{
this.value = value;
}
public double getValue()
{
return value;
}
public String toString()
{
return String.valueOf(value)+plusorminus+error;
}
public final static String plusorminus = "\u00b1";
private double value, error;
}
jas-plotter-2.2.10/src/main/java/jas/util/Application.java 0000644 0002656 0002032 00000023115 10631357137 022633 0 ustar andreas admin package jas.util;
import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.Dialog;
import java.awt.Window;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.Enumeration;
import java.util.StringTokenizer;
import java.util.Vector;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.KeyStroke;
/**
* This class is meant to provide access from all packages to
* certain general-purpose items of the application, such as
* the UserProperties objects that the application
* uses, and the JFrame that the application is in. It allows
* classes from all packages to show help topics. However,
* getting the actual topics themselves is the responsibility
* of a class which subclasses Application.
* @see UserProperties
* @see javax.swing.JFrame
* @author Jonas Gifford
* @author Peter Armstrong
*/
abstract public class Application extends javax.swing.JPanel
{
/**
* Creates an instance of the Application. This constructor may
* only be called once in an application.
*/
public Application()
{
super(new BorderLayout());
if (app != null) throw new RuntimeException("Cannot make two applications.");
app = this;
//Add the options that the Application needs.
gopt.addOption("debug", 'd', false, "Takes a : separated list of debug modes to set");
gopt.addOption("help", 'h', true, "Print this message");
//Register the help and F1 keys to show the help contents.
ActionListener helpListener = new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
showHelpContents();
}
};
registerKeyboardAction( helpListener,
KeyStroke.getKeyStroke(KeyEvent.VK_HELP, 0),
JComponent.WHEN_IN_FOCUSED_WINDOW
);
registerKeyboardAction( helpListener,
KeyStroke.getKeyStroke(KeyEvent.VK_F1, 0),
JComponent.WHEN_IN_FOCUSED_WINDOW
);
}
/**
* Called to parse the command line arguments (after setting appropriate
* options)
* @param argv The command line arguments
* @return The number of parameters found
* @see #getGetOptions
*/
protected int parseArgs(String[] argv)
{
//Now parse the command line arguments and act accordingly
try
{
gopt.parseArgs(argv);
}
catch (GetOptions.BadArguments x)
{
doHelp();
System.out.println("The command line options you specified had the following problem:\n" + x.getMessage());
System.exit(0);
}
if (gopt.hasOption("help"))
{
doHelp();
System.exit(0);
}
setDebugFlags();
return gopt.numParams();
}
/**
* Called to show user the syntax of the command, as a result of a syntax error
* in the command line arguments, or in response to the --help option
* Override to provide specialized instructions for your application
*/
protected void doHelp()
{
gopt.dumpOptions();
}
private void initializeHelpSystem() throws Exception
{
// Implemented this way so the appplication still runs even if the jar file
// with the help system is not in the Class Path
if (debugHelp) System.err.println("Initializing help system...");
try
{
hi = (HelpInterface)(Class.forName("jas.util.HelpInterfaceImpl")).newInstance();
if (debugHelp) System.err.println("Help system initialized successfully");
}
catch (Exception x)
{
if (debugHelp) System.err.println("Failed: "+x.getMessage());
throw x;
}
}
/**
* Add a Help location to the Vector of locations to look in for the helpset.
* At the time of writing, this was a one-element Vector, but we're being flexible :-)
*/
public void addHelpLocation(Class base,String s)
{
addHelpLocation(base.getResource(s));
}
public void addHelpLocation(URL url)
{
if (debugHelp) System.err.println("addHelpLocation: "+url);
if (url != null) theHelpLocations.addElement(url);
}
public void addHelpLocation(String s)
{
try
{
if (debugHelp) System.err.println("addHelpLocation: "+s);
theHelpLocations.addElement(new URL(s));
}
catch (MalformedURLException x)
{
System.err.println("Bad URL for addHelpLocation - ignored: "+s);
x.printStackTrace();
}
}
/**
* Get an Enumeration of all the locations to look in for the helpset.
*/
Enumeration getHelpLocations()
{
return theHelpLocations.elements();
}
private void setDebugFlags()
{
//Now we can ask gopt about the command-line parameters in order to set our flags.
if (gopt.hasOption("debug"))
{
StringTokenizer st = new StringTokenizer(gopt.getOption("debug"), ":");
while (st.hasMoreTokens())
{
setDebugFlag(st.nextToken());
}
}
}
/**
* Called once for each debug flag set in the command options.
* By default sets a system property of the form debugFlag where flag
* is the flag specified (with its initial letter uppercased).
* Override for application specific behaviour.
*/
protected void setDebugFlag(String flag)
{
String name = "debug" +flag.substring(0,1).toUpperCase()+flag.substring(1);
System.getProperties().put(name,"true");
System.out.println("Set debug flag "+name);
if (flag.equals("help")) debugHelp = true;
}
/**
* Returns the application.
*/
static final public Application getApplication()
{
return app;
}
/**
* Returns the UserProperties object.
*/
final public UserProperties getUserProperties()
{
return m_prop;
}
/**
* Returns the parent JFrame.
* @see javax.swing.JFrame
*/
final public JFrame getFrame()
{
if (m_parent == null)
{
Component parent = this;
while (parent != null && !(parent instanceof JFrame)) parent = parent.getParent();
m_parent = (JFrame) parent;
}
return m_parent;
}
/**
* Shows the table of contents for the help system.
*/
public final void showHelpContents()
{
showHelpTopic("top");
}
/**
* Shows the index for the help system.
*/
public final void showHelpIndex()
{
showHelpTopic("top", "Index");
}
/**
* Opens a search window for the help system.
*/
public final void showHelpSearch()
{
showHelpTopic("top", "Search");
}
/**
* Parents an error box to the application's frame and displays a Throwable
* object's stack trace.
* @see ErrorBox
* @param s an error message
* @param t the Exception or Error that caused the error
*/
public final void error(final String s, final Throwable t)
{
if (getFrame() != null) new ErrorBox(getFrame(), s, t).doModal();
else System.err.println("Error: "+s+" "+t);
}
/**
* Parents an error box to the application's frame.
* @see ErrorBox
* @param s an error message
*/
public final void error(final String s)
{
if (getFrame() != null) new ErrorBox(getFrame(), s).doModal();
else System.err.println("Error: "+s);
}
/**
* Parents an error box to the application's frame, displays a Throwable
* object's stace trace, and contains a button that opens a given help page.
* @see ErrorBox
* @param s an error message
* @param t the Exception or Error that caused the error
* @param helpTopic the topic you want to link to
*/
public final void error(final String s, final Throwable t, final String helpTopic)
{
if (getFrame() != null) new ErrorBox(getFrame(), s, t, helpTopic).doModal();
else System.err.println("Error: "+s+" "+t);
}
/**
* Parents an error box to the application's frame, and contains a button
* that opens a given help page.
* @see ErrorBox
* @param s an error message
* @param helpTopic the topic you want to link to
*/
public final void error(final String s, final String helpTopic)
{
if (getFrame() != null) new ErrorBox(getFrame(), s, helpTopic).doModal();
else System.err.println("Error: "+s);
}
public final void showHelpTopic(String helpTopicTarget)
{
showHelpTopic(helpTopicTarget,getFrame());
}
/**
* 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
*/
public final void showHelpTopic(String helpTopicTarget, Window owner)
{
try
{
if (hi == null) initializeHelpSystem();
hi.showHelpTopic(helpTopicTarget,owner);
}
catch (Throwable eek)
{
whine(eek);
}
}
/**
* 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
*/
private final void showHelpTopic(String helpTopicTarget, String navigatorView)
{
try
{
if (hi == null) initializeHelpSystem();
hi.showHelpTopic(helpTopicTarget, navigatorView, getFrame());
}
catch (Throwable eek)
{
whine(eek);
}
}
private final void whine(Throwable eek)
{
app.error("Could not initialize help system!",eek);
}
/**
* Get the GetOptions object that will be used to parse the command line arguments
*/
public GetOptions getGetOptions()
{
return gopt;
}
public CommandTargetManager getCommandManager()
{
return m_commandTargetManager;
}
/**
* Workaround for modal dialog/help interface interaction
*/
void modalDialogOpening(Dialog dlg)
{
if (hi != null) hi.modalDialogOpening(dlg);
}
void modalDialogClosing(Dialog dlg)
{
if (hi != null) hi.modalDialogClosing(dlg);
}
private CommandTargetManager m_commandTargetManager = new CommandTargetManager();
private Vector theHelpLocations = new Vector();
private static Application app = null;
private boolean debugHelp = false;
private JFrame m_parent;
private final UserProperties m_prop = new UserProperties();
private GetOptions gopt = new GetOptions();
private HelpInterface hi = null;
}
jas-plotter-2.2.10/src/main/java/jas/util/PropertyPage.java 0000644 0002656 0002032 00000005147 10631357137 023016 0 ustar andreas admin 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;
}
jas-plotter-2.2.10/src/main/java/jas/util/UserProperties.java 0000644 0002656 0002032 00000024476 10631357137 023376 0 ustar andreas admin 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;
}
jas-plotter-2.2.10/src/main/java/jas/util/ArbitraryNameGenerator.java 0000644 0002656 0002032 00000001735 10631354456 025004 0 ustar andreas admin 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, ...
*
* 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++;
}
}
}
}
jas-plotter-2.2.10/src/main/java/jas/util/HasHelpPage.java 0000644 0002656 0002032 00000001051 10631354456 022505 0 ustar andreas admin package jas.util;
/**
* A JASWizardPage that implements this interface can link the user to
* a help topic. When a HasHelpPage page is showing, the "Help" button
* will enable.
* @see JASWizardPage
* @author Jonas Gifford
* @author Peter Armstrong
*/
public interface HasHelpPage
{
/**
* Returns the help topic to open if the user clicks on the "Help" button. This
* string must be one of the XML targets. (This is a cheesy adaptation of
* what Jonas built for the Oracle Help system.)
*/
public abstract String getHelpTopic();
}
jas-plotter-2.2.10/src/main/java/jas/util/JASWizardPage.java 0000644 0002656 0002032 00000017266 10631357137 022775 0 ustar andreas admin package jas.util;
import java.awt.Container;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import javax.swing.JPanel;
/**
* Extend this class to create a page for the JASWizard. Implement the
* interface HasNextPages if you want there to be pages following this
* page, and implement the Finishable interface if you want this to be
* the final page. You may implement one or both, but implementing
* neither would be silly because then neither the "Next" nor "Finish"
* button will enable and your page will be a "dead end". Implement
* HasHelpPage if you want your page to link to a help topic. Override
* the methods getNextEnabled() and getFinishEnabled()
* to control how the "Next" and "Finish" buttons enable.
*
* This class is a KeyListener and has implemented the interface
* with non-final methods. If you do not override these
* methods, 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;
}
jas-plotter-2.2.10/src/main/java/jas/util/encoder/ 0000755 0002656 0002032 00000000000 14746176454 021156 5 ustar andreas admin jas-plotter-2.2.10/src/main/java/jas/util/encoder/ImageEncoder.java 0000644 0002656 0002032 00000016147 10631357137 024340 0 ustar andreas admin // ImageEncoder - abstract class for writing out an image
//
// Copyright (C) 1996 by Jef Poskanzer // 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.
// Fetch the entire Acme package.
//
// @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();
}
}
jas-plotter-2.2.10/src/main/java/jas/util/encoder/GifEncoder.java 0000644 0002656 0002032 00000042564 10631357137 024025 0 ustar andreas admin // 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
// 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" );
}
}
jas-plotter-2.2.10/src/main/java/jas/util/JASTextField.java 0000644 0002656 0002032 00000003626 10631354456 022624 0 ustar andreas admin 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
* The routine returns a two dimensional array where the first dimension
* has the following meaning:
* Use the method Labels are displayed in the order as they appear in the array given to the method
*
// Fetch the entire Acme package.
//
// Fetch the entire Acme package.
// 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();
}
}
jas-plotter-2.2.10/src/main/java/jas/util/GetOptions.java 0000644 0002656 0002032 00000031255 10631357137 022467 0 ustar andreas admin /*
* @(#)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 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;
} jas-plotter-2.2.10/src/main/java/jas/util/ReservedWordBin.java 0000644 0002656 0002032 00000003600 10631354456 023432 0 ustar andreas admin package jas.util;
import java.util.Hashtable;
public class ReservedWordBin
{
private void buildHash()
{
m_hash = new Hashtable(50, 1.0f); // 50 reserved words
// this is an arbitrary object (it won't let me pass it null)
m_hash.put("true", this); m_hash.put("false", this);
m_hash.put("null", this); m_hash.put("abstract", this);
m_hash.put("boolean", this); m_hash.put("break", this);
m_hash.put("byte", this); m_hash.put("case", this);
m_hash.put("catch", this); m_hash.put("char", this);
m_hash.put("class", this); m_hash.put("const", this);
m_hash.put("continue", this); m_hash.put("default", this);
m_hash.put("do", this); m_hash.put("double", this);
m_hash.put("else", this); m_hash.put("extends", this);
m_hash.put("final", this); m_hash.put("finally", this);
m_hash.put("float", this); m_hash.put("for", this);
m_hash.put("goto", this); m_hash.put("if", this);
m_hash.put("implements", this); m_hash.put("import", this);
m_hash.put("instanceof", this); m_hash.put("int", this);
m_hash.put("interface", this); m_hash.put("long", this);
m_hash.put("native", this); m_hash.put("new", this);
m_hash.put("package", this); m_hash.put("private", this);
m_hash.put("protected", this); m_hash.put("public", this);
m_hash.put("return", this); m_hash.put("short", this);
m_hash.put("static", this); m_hash.put("super", this);
m_hash.put("switch", this); m_hash.put("synchronized", this);
m_hash.put("this", this); m_hash.put("throw", this);
m_hash.put("throws", this); m_hash.put("transient", this);
m_hash.put("try", this); m_hash.put("void", this);
m_hash.put("volatile", this); m_hash.put("while", this);
}
public boolean isReservedWord(String s)
{
if (m_hash == null) buildHash();
return m_hash.containsKey(s);
}
public void dispose() // promotes garbage collection
{
m_hash.clear();
m_hash = null;
}
private Hashtable m_hash;
}
jas-plotter-2.2.10/src/main/java/jas/util/ObjectFactory.java 0000644 0002656 0002032 00000013254 10631357137 023131 0 ustar andreas admin package jas.util;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Modifier;
/**
* The object factory is just a convenience class for creating
* objects from thier Class pointer. It hides some of the messiness
* of the java.lang.relect.* classes.
*/
public class ObjectFactory
{
/**
* Create an ObjectFactory capable of creating objects of a specific class.
*
* @param c The class of objects to be created.
*/
public ObjectFactory(Class c)
{
m_c = c;
}
/**
* Creates an object from the specified arguments
*/
public Object create() throws ObjectFactoryException
{
Object[] arg = new Object[0];
return create(arg);
}
/**
* Creates an object from the specified arguments
*/
public Object create(Object a1) throws ObjectFactoryException
{
Object[] arg = new Object[1];
arg[0] = a1;
return create(arg);
}
/**
* Creates an object from the specified arguments
*/
public Object create(Object a1,Object a2) throws ObjectFactoryException
{
Object[] arg = new Object[2];
arg[0] = a1;
arg[1] = a2;
return create(arg);
}
/**
* Creates an object from the specified arguments
*/
public Object create(Object a1,Object a2,Object a3) throws ObjectFactoryException
{
Object[] arg = new Object[3];
arg[0] = a1;
arg[1] = a2;
arg[2] = a3;
return create(arg);
}
/**
* Checks that the class is declared public.
*/
public boolean checkAccess()
{
return Modifier.isPublic(m_c.getModifiers());
}
/**
* Checks that the class inherits from baseClass
*/
public boolean inheritsFrom(Class baseClass)
{
return baseClass.isAssignableFrom(m_c);
}
/**
* Creates an object from the specified arguments
*/
public Object create(Object a1,Object a2,Object a3,Object a4) throws ObjectFactoryException
{
Object[] arg = new Object[4];
arg[0] = a1;
arg[1] = a2;
arg[2] = a3;
arg[3] = a4;
return create(arg);
}
/**
* Creates an object from the specified arguments
*/
public Object create(Object[] args) throws ObjectFactoryException
{
Class[] argc = argClass(args);
try
{
Constructor x = findConstructor(argc);
return x.newInstance(args);
}
catch (NoSuchMethodException e)
{
throw new ObjectFactoryException("Error creating object of class "+m_c,e);
}
catch (IllegalAccessException e)
{
throw new ObjectFactoryException("Error creating object of class "+m_c,e);
}
catch (InstantiationException e)
{
throw new ObjectFactoryException("Error creating object of class "+m_c,e);
}
catch (InvocationTargetException e)
{
throw new ObjectFactoryException(
"Invocation Target Exception for class"+m_c,e.getTargetException());
}
}
/**
* Determines if object can be constrcted from the specified types of arguments
*/
public boolean canBeCreatedFrom()
{
Class[] argc = new Class[0];
return canBeCreatedFrom(argc);
}
/**
* Determines if object can be constrcted from the specified types of arguments
*/
public boolean canBeCreatedFrom(Class c1)
{
Class[] argc = new Class[1];
argc[0] = c1;
return canBeCreatedFrom(argc);
}
/**
* Determines if object can be constrcted from the specified types of arguments
*/
public boolean canBeCreatedFrom(Class c1, Class c2)
{
Class[] argc = new Class[2];
argc[0] = c1;
argc[1] = c2;
return canBeCreatedFrom(argc);
}
/**
* Determines if object can be constrcted from the specified types of arguments
*/
public boolean canBeCreatedFrom(Class c1, Class c2, Class c3)
{
Class[] argc = new Class[3];
argc[0] = c1;
argc[1] = c2;
argc[2] = c3;
return canBeCreatedFrom(argc);
}
/**
* Determines if object can be constrcted from the specified types of arguments
*/
public boolean canBeCreatedFrom(Class c1, Class c2, Class c3, Class c4)
{
Class[] argc = new Class[4];
argc[0] = c1;
argc[1] = c2;
argc[2] = c3;
argc[3] = c4;
return canBeCreatedFrom(argc);
}
/**
* Determines if object can be constrcted from the specified types of arguments
*/
public boolean canBeCreatedFrom(Class[] argc)
{
try
{
findConstructor(argc);
return true;
}
catch (NoSuchMethodException e)
{
return false;
}
}
/**
* Construct a list of argument classes from a list of arguments
*/
private Class[] argClass(Object[] args)
{
Class[] result = new Class[args.length];
for (int i=0; i
*
*
* If the method returns null, then the getStatistic() method from
* the subclass will be called instead. This simplifies the use of
* simple floating point statistics (no need to create a Double
* object for each one).
* @param name The name of the statistic to return
* @returns The statistic, or null indicating getStatistic(name) should be used.
* @see jas.util.ScientificFormat
* @see jas.util.DoubleWithError
*/
Object getExtendedStatistic(String name);
}
jas-plotter-2.2.10/src/main/java/jas/hist/FunctionRegistry.java 0000644 0002656 0002032 00000017130 10631357137 023700 0 ustar andreas admin package jas.hist;
import jas.util.JASDialog;
import jas.util.JASIcon;
import jas.util.JASState;
import jas.util.NestedRuntimeException;
import jas.util.ObjectFactory;
import jas.util.ObjectFactoryException;
import java.awt.Component;
import java.awt.Frame;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import java.util.Enumeration;
import java.util.Vector;
import javax.swing.DefaultListCellRenderer;
import javax.swing.Icon;
import javax.swing.JList;
/**
*
* A class which maintains a list of functions which can be overlayed
*
* on a plot.
*
*/
public class FunctionRegistry
{
private FunctionRegistry()
{
}
/**
* Get the (unique) instance of FunctionRegistry
*/
static public FunctionRegistry instance()
{
return theFunctionRegistry;
}
/**
* Register a function given its class and name
* @param c The class of the function
* @param name The name of the function
*/
public void registerFunction(Class c, String name)
{
registerFunction(createFunctionFactory(c,name));
}
/**
* Create a default function factory from a class and a name
* @param c The class of the function
* @param name The name of the function
* @return The function factory
*/
public FunctionFactory createFunctionFactory(Class c, String name)
{
try
{
return new DefaultFunctionFactory(c,name);
}
catch (FunctionFactoryError e)
{
// convert the error to a runtime error
throw new NestedRuntimeException(e);
}
}
/**
* Add a function by specifing a FunctionFactory
*/
public void registerFunction(FunctionFactory f)
{
m_functions.addElement(f);
}
/**
* Remove a function factory from the list
*/
public void removeFunctionFactory(FunctionFactory f)
{
m_functions.removeElement(f);
}
/**
* Clear the list
*/
public void removeAllFunctions()
{
m_functions.removeAllElements();
}
/**
* Get an enumeration of all the FunctionFactories in the registry
*/
public Enumeration elements()
{
return m_functions.elements();
}
/**
* Get the size of the registry
*/
public int size()
{
return m_functions.size();
}
public FunctionFactory find(String name)
{
Enumeration e = m_functions.elements();
while (e.hasMoreElements())
{
FunctionFactory ff = (FunctionFactory) e.nextElement();
if (ff.getFunctionName().equals(name)) return ff;
}
return null;
}
/**
* Replace the contents of the list
* @param e An enumeration of function factories
*/
public void setContents(Vector v)
{
m_functions = v;
}
FunctionFactory chooseFunction(Frame f)
{
// These lines need to be excised in applet version
ChooseFunctionDialog dlg = new ChooseFunctionDialog(f);
if (dlg.doModal())
{
return dlg.getSelectedFunction();
}
return null;
}
private Vector m_functions = new Vector();
private static FunctionRegistry theFunctionRegistry = new FunctionRegistry();
private class ChooseFunctionDialog extends JASDialog implements ItemListener, ActionListener
{
ChooseFunctionDialog(Frame f)
{
super(f,"Choose Function...");
m_list = new javax.swing.JList(m_functions);
m_list.setCellRenderer(new FunctionListCellRenderer());
getContentPane().add("Center",m_list);
pack();
}
public void itemStateChanged(ItemEvent evt)
{
callEnable();
}
public void actionPerformed(ActionEvent evt)
{
onOK();
}
public void enableOK(JASState state)
{
//state.setEnabled(m_list.getSelectedValue()!=null);
}
public void onOK()
{
m_selection = (FunctionFactory) m_list.getSelectedValue();
super.onOK();
}
public FunctionFactory getSelectedFunction()
{
return m_selection;
}
}
private FunctionFactory m_selection;
private javax.swing.JList m_list;
}
class DefaultFunctionFactory extends ObjectFactory implements FunctionFactory
{
DefaultFunctionFactory(Class c, String name) throws FunctionFactoryError
{
super(c);
this.name = name;
// Class must be a subclass of Basic1DFunction
if (!inheritsFrom(Basic1DFunction.class))
throw new FunctionFactoryError("Function "+name+" does not inherit from Basic1DFunction");
// Class must be declared public
if (!checkAccess())
throw new FunctionFactoryError("Function "+name+" is not declared public");
// The function needs to have a suitable constructor
if (!canBeCreatedFrom(Double.TYPE,Double.TYPE,Double.TYPE,Double.TYPE))
throw new FunctionFactoryError("Function "+name+" does not have a suitable constructor");
}
public Basic1DFunction createFunction(JASHist h) throws FunctionFactoryError
{
try
{
JASHistAxis xAxis = h.getXAxis();
JASHistAxis yAxis = h.getYAxis(); // which Y axis?
return (Basic1DFunction) create(new Double(xAxis.getMin()),
new Double(xAxis.getMax()),
new Double(yAxis.getMin()),
new Double(yAxis.getMax()));
}
catch (ObjectFactoryException e)
{
throw new FunctionFactoryError("Unexpected failure to create function");
}
}
public String getFunctionName()
{
return name;
}
public Icon getFunctionIcon()
{
return icon;
}
private String name;
private Icon icon = JASIcon.create(this,"function.gif");
}
class FunctionListCellRenderer extends DefaultListCellRenderer
{
public Component getListCellRendererComponent(JList list,
Object value, // value to display
int index, // cell index
boolean isSelected, // is the cell selected
boolean cellHasFocus) // the list and the cell have the focus
{
super.getListCellRendererComponent(list,value,index,isSelected,cellHasFocus);
if (value instanceof FunctionFactory)
{
FunctionFactory ff = (FunctionFactory) value;
setText(ff.getFunctionName());
setIcon(ff.getFunctionIcon());
}
return this;
}
}
jas-plotter-2.2.10/src/main/java/jas/hist/ManagedAxis.java 0000644 0002656 0002032 00000027472 10631357137 022555 0 ustar andreas admin package jas.hist;
import jas.plot.Axis;
import jas.plot.AxisType;
import jas.plot.DateAxis;
import jas.plot.DoubleAxis;
import jas.plot.EditableLabel;
import jas.plot.StringAxis;
import java.awt.Component;
import java.awt.event.ActionEvent;
import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.Date;
import javax.swing.JCheckBoxMenuItem;
import javax.swing.JLabel;
import javax.swing.JMenuItem;
import javax.swing.JPopupMenu;
// This has to be public so that the properties dialog can use reflection on it???
// (otherwise get IllegalAccessException)
public final class ManagedAxis extends Axis implements JASHistAxis, Externalizable
{
ManagedAxis(int orientation)
{
super(orientation);
this.dataManager = null;
this.binned = false;
}
ManagedAxis(DataManager dm, int orientation, boolean binned)
{
super(orientation);
this.dataManager = dm;
this.binned = binned;
}
// for deserialization/deserialization only do not call
public ManagedAxis()
{
}
void setDataManager(DataManager dm, boolean binned)
{
this.dataManager = dm;
this.binned = binned;
}
void setDataManager(DataManager dm, boolean binned, AxisType t)
{
this.dataManager = dm;
this.binned = binned;
setType(t);
}
public void writeExternal(ObjectOutput out) throws IOException
{
out.writeInt(bins);
out.writeBoolean(rangeAutomatic);
if (!rangeAutomatic)
{
out.writeDouble(getMin());
out.writeDouble(getMax());
}
out.writeBoolean(allowSuppressedZero);
out.writeBoolean(fixed);
out.writeBoolean(binned);
out.writeInt(position);
final AxisType type = getType();
out.writeInt(getAxisOrientation());
out.writeBoolean(getOnLeftSide());
out.writeObject(type);
out.writeObject(dataManager);
// THINGS THAT SHOULD BE INCLUDED LATER (here and in readObject):
// - axis colors (i.e., minorTickMarkColor, axisLineColor, textColor, etc.)
// (no point in doing this one now because they are always black)
// - whether is visible
// (no point in doing this now because can't change whether is visible)
}
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
{
bins = in.readInt();
rangeAutomatic = in.readBoolean();
if (!rangeAutomatic)
{
setMin(in.readDouble());
setMax(in.readDouble());
}
else
attentionNeeded();
allowSuppressedZero = in.readBoolean();
fixed = in.readBoolean();
binned = in.readBoolean();
position = in.readInt();
setAxisOrientation(in.readInt());
setOnLeftSide(in.readBoolean());
setType((AxisType) in.readObject());
dataManager = (DataManager) in.readObject();
}
public boolean isVertical()
{
return getAxisOrientation() == Axis.VERTICAL;
}
public boolean isLogarithmic()
{
AxisType type = getType();
if (type instanceof DoubleAxis)
{
return ((DoubleAxis) type).isLogarithmic();
}
return false;
}
public void setLogarithmic(boolean value)
{
AxisType type = getType();
if (type instanceof DoubleAxis)
{
((DoubleAxis) type).setLogarithmic(value);
attentionNeeded();
}
}
public boolean isShowing()
{
// TODO: Not supported yet by Axis
return true;
}
public void setShowing(boolean value)
{
// TODO: Not supported yet by Axis
}
/**
* @return the EditableLabel itself, not just the text
* @see #getLabel()
*/
public EditableLabel getLabelObject()
{
if (dataManager == null) return null;
EditableLabel label = dataManager.getLabel(this);
if (label == null) return null;
return label;
}
/**
* @return the label text
* @see #getLabelObject()
*/
public String getLabel()
{
EditableLabel label = dataManager.getLabel(this);
return label==null ? "" : label.getText();
}
/**
* sets the label to be the EditableLabel passed in
* @param p_newLabel the new label
*/
public void setLabelObject(EditableLabel p_newLabel)
{
dataManager.setLabel(this, p_newLabel);
}
/**
* sets the label text, creating the label if needed
* @param s the new text of the label
*/
public void setLabel(String s)
{
EditableLabel label = dataManager.getLabel(this);
if (label == null)
{
label = new EditableLabel(s,"Axis Label",JLabel.LEFT);
dataManager.setLabel(this, label);
}
else label.setText(s);
revalidate(); // Attract the attention of the layout manager!
}
public double getMin()
{
// getParent().validate();
AxisType type = getType();
if (type instanceof DoubleAxis)
{
return ((DoubleAxis) type).getPlotMin();
}
else if (type instanceof DateAxis)
{
return ((DateAxis) type).getAxisMin()/1000.;
}
throw new RuntimeException("getMin undefined for this axis type");
}
public void setMin(double d)
{
AxisType type = getType();
if (type instanceof DoubleAxis)
{
rangeAutomatic = false;
((DoubleAxis) type).setMin(d);
attentionNeeded();
}
else if (type instanceof DateAxis)
{
rangeAutomatic = false;
((DateAxis) type).setMin((long) (d*1000));
attentionNeeded();
}
else throw new RuntimeException("setMin undefined for this axis type");
}
public double getMax()
{
AxisType type = getType();
if (type instanceof DoubleAxis)
{
return ((DoubleAxis) type).getPlotMax();
}
else if (type instanceof DateAxis)
{
return ((DateAxis) type).getAxisMax()/1000.;
}
throw new RuntimeException("getMax undefined for this axis type");
}
public void setMax(double d)
{
AxisType type = getType();
if (type instanceof DoubleAxis)
{
rangeAutomatic = false;
((DoubleAxis) type).setMax(d);
attentionNeeded();
}
else if (type instanceof DateAxis)
{
rangeAutomatic = false;
((DateAxis) type).setMax((long) (d*1000));
invalidate();
attentionNeeded();
}
else throw new RuntimeException("setMax undefined for this axis type");
}
public void setRange(double min, double max)
{
setMin(min);
setMax(max);
}
public Object getMinObject()
{
if (getAxisType() == DATE) return new Date((long) (getMin()*1000));
else return new Double(getMin());
}
public Object getMaxObject()
{
if (getAxisType() == DATE) return new Date((long) (getMax()*1000));
else return new Double(getMax());
}
public void setMinObject(Object value)
{
try
{
double min;
if (getAxisType() == DATE) min = ((Date) value).getTime()/1000;
else min = ((Double) value).doubleValue();
setMin(min);
// attentionNeeded();
// invalidate();
}
catch (ClassCastException x)
{
throw new IllegalArgumentException("Argument to setMinObject is of wrong type");
}
}
public void setMaxObject(Object value)
{
try
{
double max;
if (getAxisType() == DATE) max = ((Date) value).getTime()/1000;
else max = ((Double) value).doubleValue();
setMax(max);
// attentionNeeded();
// invalidate();
}
catch (ClassCastException x)
{
throw new IllegalArgumentException("Argument to setMaxObject is of wrong type");
}
}
public boolean getRangeAutomatic()
{
return rangeAutomatic;
}
public void setRangeAutomatic(boolean b)
{
rangeAutomatic = b;
attentionNeeded();
}
public boolean getAllowSuppressedZero()
{
return allowSuppressedZero;
}
public void setAllowSuppressedZero(boolean b)
{
allowSuppressedZero = b;
attentionNeeded();
}
public boolean isBinned()
{
return binned;
}
public void setBinned(boolean value)
{
binned = value;
}
public boolean isFixed()
{
return fixed;
}
public void setFixed(boolean value)
{
fixed = value;
}
public int getBins()
{
return bins;
}
public void setBins(int value)
{
bins = value;
attentionNeeded();
}
public double getBinWidth()
{
if (!binned) return 0;
double range = getMax() - getMin();
return range/bins;
}
public void setBinWidth(double value)
{
double range = getMax() - getMin();
bins = (int) Math.max(1,range/value);
attentionNeeded();
}
public boolean getShowOverflows()
{
return showOverflows;
}
public void setShowOverflows(boolean value)
{
showOverflows = value;
attentionNeeded();
}
public int getLabelPosition()
{
return 0;
}
public void setLabelPosition(int pos)
{
//final int positions[] =
//{
// JCLegend.EAST, JCLegend.WEST, JCLegend.NORTHEAST,
// JCLegend.SOUTHEAST, JCLegend.NORTHWEST, JCLegend.SOUTHEAST
//};
//JCAxisTitle t = yAxis.getTitle();
//if (t != null) t.setPlacement(positions[pos]);
}
public int getPosition()
{
return position;
}
public void setPosition(int value)
{
//if (!isVertical()) throw new IllegalArgumentException("Cannot set position of X axis");
//if (value == LEFT ) axis.setPlacement(JCAxis.MIN);
//else if (value == RIGHT) axis.setPlacement(JCAxis.MAX);
//else throw new IllegalArgumentException("Illegal argument to setPosition");
position = value;
}
public int getAxisType()
{
AxisType type = getType();
if (type instanceof DateAxis) return DATE;
if (type instanceof StringAxis) return STRING;
return DOUBLE;
}
public void setAxisType(int value)
{
if (value != getAxisType())
{
if (value == DATE)
{
setType(new DateAxis());
}
else if (value == STRING)
{
setType(new StringAxis());
}
else
{
setType(new DoubleAxis());
}
}
}
/**
* attention needed is called by ManagedAxis when it wants to attract the
* attention of the DataManager, e.g. after the user updates some property.
*/
private void attentionNeeded()
{
boolean requestedAttention = needsAttention;
needsAttention = true;
if (!requestedAttention && dataManager != null) dataManager.invalidate();
}
/**
* set attention needed can be called by the DataManager to remind itself
* it needs to work on the axis
*/
void setAttentionNeeded()
{
needsAttention = true;
}
/**
* called by the DataManager when it has updated itself to take into account
* changes to the axis. Resets the needsAttention flag.
*/
void payingAttention()
{
needsAttention = false;
}
/**
* return true if attnetion is needed
*/
boolean needsAttention()
{
return needsAttention;
}
public void modifyPopupMenu(final JPopupMenu menu, final Component source)
{
if (dataManager != null && !(dataManager instanceof DefaultDataManager))
{
super.modifyPopupMenu(menu,source);
if (getAxisType() != JASHistAxis.STRING)
// BUG: should have a better way of testing whether these items are appropriate
{
if (getAxisType() != JASHistAxis.DATE)
// BUG: should have a better way of testing whether this item is appropriate
{
menu.add(new JCheckBoxMenuItem("Logarithmic", isLogarithmic())
{
final protected void fireActionPerformed(final ActionEvent e)
{
setLogarithmic(isSelected());
}
});
}
menu.add(new JCheckBoxMenuItem("Range Automatic", getRangeAutomatic())
{
final protected void fireActionPerformed(final ActionEvent e)
{
setRangeAutomatic(isSelected());
}
});
if (getAxisType() != JASHistAxis.DATE)
// BUG: should have a better way of testing whether this item is appropriate
{
final JCheckBoxMenuItem suppZero = new JCheckBoxMenuItem("Suppressed Zeros", getAllowSuppressedZero())
{
final protected void fireActionPerformed(final ActionEvent e)
{
setAllowSuppressedZero(isSelected());
}
};
menu.add(suppZero);
suppZero.setEnabled(getRangeAutomatic());
}
}
menu.add(new JMenuItem("Axis Properties...")
{
final protected void fireActionPerformed(final ActionEvent e)
{
dataManager.getPlot().showProperties(
getAxisOrientation() == Axis.VERTICAL ?
(getOnLeftSide() ? JASHistPropertyDialog.Y_AXIS_LEFT :
JASHistPropertyDialog.Y_AXIS_RIGHT) :
JASHistPropertyDialog.X_AXIS);
}
});
}
}
private int bins;
private boolean rangeAutomatic = true;
private boolean allowSuppressedZero = true;
private boolean showOverflows = false;
private boolean needsAttention = true;
private boolean fixed = false;
private boolean binned;
private int position;
private DataManager dataManager;
}
jas-plotter-2.2.10/src/main/java/jas/hist/FitterFactory.java 0000644 0002656 0002032 00000000147 10631354456 023150 0 ustar andreas admin package jas.hist;
public interface FitterFactory
{
Fitter createFitter();
String getFitterName();
}
jas-plotter-2.2.10/src/main/java/jas/hist/CustomOverlay.java 0000644 0002656 0002032 00000000206 10631357137 023172 0 ustar andreas admin package jas.hist;
import jas.plot.Overlay;
public interface CustomOverlay extends Overlay
{
void setDataSource(DataSource source);
} jas-plotter-2.2.10/src/main/java/jas/hist/Rebinnable2DHistogramData.java 0000644 0002656 0002032 00000001111 10631354456 025252 0 ustar andreas admin package jas.hist;
public interface Rebinnable2DHistogramData
extends DataSource
{
public double[][][] rebin(int xbins, double xmin, double xmax,
int ybins, double ymin, double ymax,
boolean wantErrors, boolean hurry, boolean overflow);
public double getXMin();
public double getXMax();
public double getYMin();
public double getYMax();
public int getXBins();
public int getYBins();
public boolean isRebinnable();
public int getXAxisType();
public int getYAxisType();
public String[] getXAxisLabels();
public String[] getYAxisLabels();
}
jas-plotter-2.2.10/src/main/java/jas/hist/JASHist2DHistogramStyle.java 0000644 0002656 0002032 00000014462 10631357137 024721 0 ustar andreas admin 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; inull 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
{
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)
{
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);
}
}
jas-plotter-2.2.10/src/main/java/jas/hist/StatsWindow.java 0000644 0002656 0002032 00000031052 10631357137 022647 0 ustar andreas admin package jas.hist;
import jas.util.JASDialog;
import jas.util.JASState;
import jas.util.SciFormatPanel;
import jas.util.ScientificFormat;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Component;
import java.awt.Container;
import java.awt.Rectangle;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.text.Format;
import javax.swing.BorderFactory;
import javax.swing.Box;
import javax.swing.BoxLayout;
import javax.swing.ButtonGroup;
import javax.swing.JButton;
import javax.swing.JCheckBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JList;
import javax.swing.JPanel;
import javax.swing.JRadioButton;
import javax.swing.JScrollPane;
import javax.swing.ListCellRenderer;
import javax.swing.ListModel;
/**This class creates a gui popup window for choosing which statistics and titles should be displayed
*in the StatisticsBlock, and for setting the number formatting parameters for
* base.jas.util.ScientificFormat. The window uses the jpane created by base.jas.util.SciFormatPanel
* for setting the ScientificForm parameters. This window created by selecting "Stats Properties.."
* from the popup menu. If generated, the number formatting method in Statistics Block is
* set to ScientificFormat.
* @author Paul Spence
* @version 03/20/2000
* "userInterface.propertiesDialog.Statistics"
* */
public class StatsWindow extends JASDialog implements ActionListener
{
public static JFrame frame;
private JButton all;
private JButton none;
private JRadioButton alltitles;
private JRadioButton notitles;
private JRadioButton sometitles;
private JRadioButton leftalign;
private JRadioButton rightalign;
private JRadioButton noalign;
private JRadioButton alwaysall;
private JRadioButton subset;
private String[] names;
private JLabel selectlabel;
private SciFormatPanel scipanel;
private ScientificFormat f;
private StatisticsBlock statblock;
private JList list;
private int showtitles;
private int splitalign;
public StatsWindow(StatisticsBlock b)
{
super(frame, "Statistic Display Options", true, JASDialog.OK_BUTTON | JASDialog.CANCEL_BUTTON | JASDialog.APPLY_BUTTON | JASDialog.HELP_BUTTON);
statblock = b;
Format sf = b.getFormat();
if (sf instanceof ScientificFormat) f = (ScientificFormat) sf;
else f = new ScientificFormat();
}
/**
* This method will create and show the Statistics Window
*/
public void showStatsWindow()
{
super.setHelpTopic("userInterface.Statistics");
Container c = getContentPane();
c.removeAll();
scipanel = new SciFormatPanel(f);
//always all or subset buttoons
ButtonGroup allways_subset_group = new ButtonGroup();
alwaysall = new JRadioButton("Always show all statistics");
alwaysall.addActionListener(this);
alwaysall.setActionCommand("alwaysall");
subset = new JRadioButton("Show selection of current statistics");
subset.addActionListener(this);
subset.setActionCommand("subset");
allways_subset_group.add(alwaysall);
allways_subset_group.add(subset);
Box allways_subset_box = new Box(BoxLayout.X_AXIS);
allways_subset_box.add(alwaysall);
allways_subset_box.add(subset);
//checkbox list
names = statblock.getStatNames();
list = new JList( createData(names) );
list.setVisibleRowCount(3);
list.setCellRenderer(new CheckListRenderer());
list.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
int index = list.locationToIndex(e.getPoint());
if(index != -1 && list.getModel().getSize() >index){
CheckableItem item = (CheckableItem)list.getModel().getElementAt(index);
item.setSelected(! item.isSelected());
Rectangle rect = list.getCellBounds(index, index);
list.repaint(rect);
}
}
});
JScrollPane checkbuttonspanel = new JScrollPane(list);
Box subsetbuttons = new Box(BoxLayout.Y_AXIS);
all = new JButton("All");
none = new JButton("None");
all.setActionCommand("all");
all.addActionListener(this);
none.setActionCommand("none");
none.addActionListener(this);
subsetbuttons.add(all);
subsetbuttons.add(none);
JPanel statselection = new JPanel();
statselection.setLayout(new BorderLayout());
selectlabel = new JLabel("Choose selection of current statistics for display");
statselection.add(selectlabel,BorderLayout.NORTH);
statselection.add(subsetbuttons,BorderLayout.EAST);
statselection.add(checkbuttonspanel, BorderLayout.CENTER);
Box statoptionsbox = new Box(BoxLayout.Y_AXIS);
statoptionsbox.add(allways_subset_box);
statoptionsbox.add(statselection);
JPanel statoptions = new JPanel();
statoptions.setBorder(BorderFactory.createTitledBorder("Choose a statistics display options"));
statoptions.add(statoptionsbox);
//display title and alignment
showtitles = statblock.getShowTitles();
alltitles = new JRadioButton("Always show title");
notitles = new JRadioButton("Never show title");
sometitles = new JRadioButton("Show if multiple plots");
alltitles.setActionCommand("alltitles");
alltitles.addActionListener(this);
notitles.setActionCommand("notitles");
notitles.addActionListener(this);
sometitles.setActionCommand("sometitles");
sometitles.addActionListener(this);
Box titlebox = new Box(BoxLayout.X_AXIS);
titlebox.add(alltitles);
titlebox.add(notitles);
titlebox.add(sometitles);
ButtonGroup titlegroup = new ButtonGroup();
titlegroup.add(alltitles);
titlegroup.add(notitles);
titlegroup.add(sometitles);
if(showtitles == statblock.SHOWTITLES_ALWAYS) alltitles.setSelected(true);
else if(showtitles == statblock.SHOWTITLES_NEVER) notitles.setSelected(true);
else if(showtitles == statblock.SHOWTITLES_AUTOMATIC) sometitles.setSelected(true);
JPanel titleoptions = new JPanel();
titleoptions.setBorder(BorderFactory.createTitledBorder("Select a title display option for plots with statistics"));
titleoptions.add(titlebox);
splitalign = statblock.getSplitStringAlign();
leftalign = new JRadioButton("Left align numbers");
rightalign = new JRadioButton("Right align numbers");
noalign = new JRadioButton("Do not align numbers");
leftalign.setActionCommand("leftalign");
leftalign.addActionListener(this);
rightalign.setActionCommand("rightalign");
rightalign.addActionListener(this);
noalign.setActionCommand("noalign");
noalign.addActionListener(this);
ButtonGroup aligngroup = new ButtonGroup();
Box alignbox = new Box(BoxLayout.X_AXIS);
aligngroup.add(leftalign);
aligngroup.add(rightalign);
aligngroup.add(noalign);
alignbox.add(leftalign);
alignbox.add(rightalign);
alignbox.add(noalign);
JPanel alignoptions = new JPanel();
alignoptions.setBorder(BorderFactory.createTitledBorder("Select an alignment display option for the statistics values"));
alignoptions.add(alignbox);
if(splitalign == statblock.LEFTALIGNSPLIT) leftalign.setSelected(true);
else if(splitalign == statblock.RIGHTALIGNSPLIT) rightalign.setSelected(true);
else if(splitalign == statblock.NOALIGNSPLIT) noalign.setSelected(true);
JPanel scioptions = scipanel.getPanel();
scioptions.setBorder(BorderFactory.createTitledBorder("Set number formating parameters for numerical statistics"));
if(statblock.get_AllwaysAll_Subset()){
alwaysall.setSelected(true);
this.enableStatSelections(false);
}else subset.setSelected(true);
Box box = new Box(BoxLayout.Y_AXIS);
box.add(statoptions);
box.add(titleoptions);
box.add(alignoptions);
box.add(scioptions);
c.add(box);
pack();
show();
}
public void onOK(){
String[] s;
scipanel.updateSciFormat();//sets max width, sig digits and style for doubles
ListModel model = list.getModel();
if(alwaysall.isSelected()){
statblock.setSelectedEntries(s = null);
statblock.set_AllwaysAll_Subset(true);
}else if(model.getSize()>0){
int n = model.getSize();
int j = 0;
for(int i=0;i
*
* If the minus error is absent the errors are assumed to be symmetric,
* if the plus error is also absent the errors are assumed to be the
* square root of the data.
* @param bin The number of bins requested
* @param min The min of the range over which to bin
* @param max The max of the range over which to bin
* @param wantErrors If false indicates that the errors are not required and need not be calculated (most implementations will ignore this parameter)
* @param hurry If true indicates the results should be provided as fast as possible, even if some approximation is needed (most implementations will ignore this parameter)
* @return An array representing the binned data and errors (see description above)
*/
public double[][] rebin(int bins, double min, double max, boolean wantErrors, boolean hurry);
/**
* Returns the (suggested) minimum value for the X axis
*/
public double getMin();
/**
* Returns the (suggested) maximum value for the X axis
*/
public double getMax();
/**
* Returns the (suggested) number of bins to use
*/
public int getBins();
/**
* Returns true if the data source is capable of recalculating the bin
* contents, or false of the interface is not-capable of recalculating the
* bin contents. In the former case the values returned by getMin, getMax and
* getBins are just taken to be suggestions, in the latter case they are
* taken to be fixed in stone.
* @return True if the datasource is rebinnable
*/
public boolean isRebinnable();
/**
* Returns one of DOUBLE,INTEGER,STRING,DATE or DELTATIME
*/
public int getAxisType();
/**
* Returns the axis labels.
* Only relevant if the axisType is STRING, otherwise can return null
* @return An array of bin labels to use on the X axis
*/
public String[] getAxisLabels();
}
jas-plotter-2.2.10/src/main/java/jas/hist/XMLHistBuilder.java 0000644 0002656 0002032 00000074742 10631357137 023175 0 ustar andreas admin package jas.hist;
import jas.hist.normalization.AreaNormalizer;
import jas.hist.normalization.BinNormalizer;
import jas.hist.normalization.EntriesNormalizer;
import jas.hist.normalization.MaxBinNormalizer;
import jas.hist.normalization.Normalizer;
import jas.hist.normalization.RelativeNormalizer;
import jas.hist.normalization.SimpleNormalizer;
import jas.hist.normalization.StatisticsNormalizer;
import jas.plot.Axis;
import jas.plot.DataArea;
import jas.plot.EditableLabel;
import jas.plot.Legend;
import jas.plot.Title;
import jas.util.ScientificFormat;
import jas.util.xml.ClassPathEntityResolver;
import jas.util.xml.JASDOMParser;
import jas.util.xml.XMLNodeTraverser;
import jas.util.xml.XMLNodeTraverser.BadXMLException;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.Rectangle;
import java.io.Reader;
import java.util.Hashtable;
import java.util.Vector;
import javax.swing.BorderFactory;
import javax.swing.JComponent;
import org.w3c.dom.Attr;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
/**
* Create a Plot from an XML file.
*
* Reads an XML file describing a Plot and creates
* or modifies a plot to correspond to the data specified in
* the XML file.
*/
public class XMLHistBuilder
{
//
// constructors
//
/**
* Create an XMLHistBuilder by reading an XML file
* @param xmlFile The xmlFile to read.
* @param fileName The file name (for error messages)
*/
public XMLHistBuilder(Reader xmlFile, String fileName) throws JASDOMParser.JASXMLException, BadXMLException
{
ClassPathEntityResolver er = new ClassPathEntityResolver("plotML.dtd",XMLHistBuilder.class);
Document node = JASDOMParser.instance().parse(xmlFile,fileName,er);
plotML = new PlotMLNodeTraverser(node);
}
/**
* Create an XMLHistBuilder from a pre-parsed Document Object Model
*/
public XMLHistBuilder(Document dom) throws BadXMLException
{
plotML = new PlotMLNodeTraverser(dom);
}
/**
* Create a plot using the parsed XML.
*/
public JASHist getSoloPlot() throws BadXMLException
{
return modifyPlot(new JASHist());
}
/**
* Modify an existing plot using the parsed XML.
*/
public JASHist modifyPlot(JASHist theHist) throws BadXMLException
{
Node node = plotML.getPlot();
JASHistNodeTraverser traverser = new JASHistNodeTraverser();
theHist.removeAllData();
traverser.traverse(node,theHist);
return theHist;
}
/**
* Get a plot page. Not implemented yet.
*/
public jas.plot.PlotPanel getPlotPage()
{
return null;//!PA - stub
//return (jas.plot.PlotPanel)(getIt("plotPage"));
}
private PlotMLNodeTraverser plotML;
}
class PlotMLNodeTraverser extends XMLNodeTraverser
{
PlotMLNodeTraverser(Document node) throws BadXMLException
{
traverse(node);
}
protected void handleElement(Element node, String name) throws BadXMLException
{
if (name.equals("plotML")) traverse(node);
else hash.put(name,node);
}
protected void handleOtherNode(Node node, String name) throws BadXMLException
{
if (node.getNodeType() == node.DOCUMENT_TYPE_NODE) return;
else super.handleOtherNode(node,name);
}
Node getPlot() throws BadXMLException
{
Node node = (Node) hash.get("plot");
if (node == null) throw new BadXMLException("TimeAxis, 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
{
}
jas-plotter-2.2.10/src/main/java/jas/plot/SetablePlotGraphics.java 0000644 0002656 0002032 00000000212 10631354456 024262 0 ustar andreas admin package jas.plot;
import java.awt.Graphics;
public interface SetablePlotGraphics extends PlotGraphics
{
void setGraphics(Graphics g);
}
jas-plotter-2.2.10/src/main/java/jas/plot/ColorMapAxis.java 0000644 0002656 0002032 00000002664 10631354456 022741 0 ustar andreas admin 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; iOMIT 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(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 - plot_min) / 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
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
}
jas-plotter-2.2.10/src/main/java/jas/plot/DoubleCoordinateTransformation.java 0000644 0002656 0002032 00000001175 10631354456 026545 0 ustar andreas admin package jas.plot;
/**
* Converts between double values and pixel values for the DoubleAxis
* 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();
}
jas-plotter-2.2.10/src/main/java/jas/plot/Title.java 0000644 0002656 0002032 00000001455 10631357137 021455 0 ustar andreas admin 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;
}
jas-plotter-2.2.10/src/main/java/jas/plot/PlotPopupItem.java 0000644 0002656 0002032 00000005144 10631357137 023154 0 ustar andreas admin package jas.plot;
import java.lang.reflect.Method;
import javax.swing.JMenuItem;
import javax.swing.JOptionPane;
/**
* This 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];
}
jas-plotter-2.2.10/src/main/java/jas/plot/TimeCoordinateTransformation.java 0000644 0002656 0002032 00000000505 10631354456 026225 0 ustar andreas admin package jas.plot;
/**
* Converts coordinates between time values to pixel values for the
* 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.TimeAxis type.
* @see TimeAxis
* @author Jonas Gifford
*/
public interface TimeCoordinateTransformation extends CoordinateTransformation
{
/** Returns a pixel value for a time value. */
double convert(long d);
}
jas-plotter-2.2.10/src/main/java/jas/plot/TextBlock.java 0000644 0002656 0002032 00000014252 10631357137 022272 0 ustar andreas admin package jas.plot;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.Insets;
import javax.swing.JPopupMenu;
/**
* TextBlock is the base class for creating moveable text boxes in the jas display.
*/
public abstract class TextBlock extends MovableObject
{
public TextBlock(String prefix)
{
super(prefix);
setBorderType(LINE);
setFont(new Font("SansSerif",Font.PLAIN,10));
}
/**When implemented, getNLines() should return an integer count of the
* number of lines of text to be displayed in the text block.
*/
public abstract int getNLines();
/**When implemented, getLine(int n) should return a String corresponding to the nth
* text line to be displayed in the text block.
*/
public abstract String getLine(int n);
/**When implemented, getSplitStringAlignment() should return an integer between 1 and 3
* corresponding to the chosen alignment for the second half of strings split by '\t'.
* For leftalignment: return 1. For rightaignment: return 2. For noalignment: return 3.
* */
public abstract int getSplitStringAlign();
/**Sets the horizontal and vertical dimensions of the text block.
*/
public Dimension getPreferredSize()
{
if (fm == null) fm = getToolkit().getFontMetrics(getFont());
allocateSize();
Insets i = getInsets();
return new Dimension(blockwidth+i.right+i.left,i.top+i.bottom+blockheight);
}
/**Draws each line of text in the text block. If "\n" is returned by getLine() a
* seperator line will be drawn in the block. All other strings are formatted by
* formatLine() before being drawn.
*/
public void paintComponent(Graphics g)
{
super.paintComponent(g); // paint the background (perhaps)
g.setColor(getForeground());
if (fm == null) fm = g.getFontMetrics(getFont());
Insets insets = getInsets();
int y = fm.getAscent()+insets.top;
String line;
int fmheight=fm.getHeight();
int splitalign=getSplitStringAlign();
boolean callrevalidate = false;
if(getNLines() != numberlinesallocated)callrevalidate = true;
for (int i=0; isizeRequirements. 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();
}
jas-plotter-2.2.10/src/main/java/jas/plot/MutableLegendEntry.java 0000644 0002656 0002032 00000000213 10631354456 024116 0 ustar andreas admin package jas.plot;
public interface MutableLegendEntry extends LegendEntry
{
void setTitle(String newTitle);
boolean titleIsChanged();
}
jas-plotter-2.2.10/src/main/java/jas/plot/JASPlotMouseListener.java 0000644 0002656 0002032 00000000201 10631354456 024354 0 ustar andreas admin package jas.plot;
public interface JASPlotMouseListener
{
abstract public void mouseEventNotify(java.awt.event.MouseEvent e);
}
jas-plotter-2.2.10/src/main/java/jas/plot/StringAxis.java 0000644 0002656 0002032 00000026445 10631357137 022475 0 ustar andreas admin 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;
import java.util.Hashtable;
/**
* This class simply displays a given array of strings. Use for a histogram with a string
* partition, or if there are very specific labels (numeric or other) you want on the axis.
* This class displays strings in two formats, represented by two static constants:
*
*
* 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
}
jas-plotter-2.2.10/src/main/java/jas/plot/Transformation.java 0000644 0002656 0002032 00000000126 10631354456 023375 0 ustar andreas admin package jas.plot;
public interface Transformation
{
double convert(double value);
}
jas-plotter-2.2.10/src/main/java/jas/plot/StringCoordinateTransformation.java 0000644 0002656 0002032 00000000227 10631354456 026576 0 ustar andreas admin package jas.plot;
public interface StringCoordinateTransformation extends CoordinateTransformation
{
double convert(String d);
double binWidth();
}
jas-plotter-2.2.10/src/main/java/jas/plot/DataArea.java 0000644 0002656 0002032 00000020332 11200614177 022022 0 ustar andreas admin 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(); ilong values, representing
* the number of milliseconds after midnight on Jan 1, 1970 GMT.
* @author Jonas Gifford
*/
public final class DateAxis extends AxisType implements DateCoordinateTransformation
{
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* begin AxisType methods
*/
CoordinateTransformation getCoordinateTransformation()
{
return this;
}
void assumeAxisLength(final int axisLength)
{
Font font = axis.getFont();
final FontMetrics fm = axis.getToolkit().getFontMetrics(font);
final int maxNumberOfDivisions = getMaxNumberOfDivisions(fm,axisLength);
if (!labelsValid || labels == null || labels.length > maxNumberOfDivisions || labels.length < maxNumberOfDivisions / 2)
labels = getAxisLabels(maxNumberOfDivisions);
final DateLabel first = labels[0];
final DateLabel lastLabel = labels[labels.length - 1];
if (axis.getAxisOrientation() == Axis.HORIZONTAL)
{
spaceRequirements.height = fm.getMaxAscent() + fm.getMaxDescent() + Axis.padFromAxis;
spaceRequirements.width = Math.max(fm.stringWidth(first.text) / 2 -
(int) (first.position * axisLength), 0);
if (first.subtext != null)
{
spaceRequirements.height += fm.getHeight(); // add room for a second line
spaceRequirements.width = Math.max(fm.stringWidth(first.subtext) -
(int) (first.position * axisLength),
spaceRequirements.width);
}
int lastLabelWidth = fm.stringWidth(lastLabel.text);
if (lastLabel.subtext != null)
lastLabelWidth = Math.max(fm.stringWidth(lastLabel.subtext), lastLabelWidth);
spaceRequirements.flowPastEnd = Math.max(lastLabelWidth / 2 +
(int) (lastLabel.position * axisLength) - axisLength, 0);
}
else
{
int longest = 0;
for (int i = 0; i < labels.length; i++)
longest = Math.max(fm.stringWidth(labels[i].text), longest);
spaceRequirements.width = longest + Axis.padFromAxis;
spaceRequirements.height = Math.max(fm.getAscent() / 2 + fm.getMaxDescent() -
(int) (first.position * axisLength), 0);
spaceRequirements.flowPastEnd = Math.max(fm.getMaxAscent() - fm.getAscent() / 2 +
(int) (lastLabel.position * axisLength) - axisLength, 0);
}
}
void paintAxis(final PlotGraphics g, final double originX, final double originY,
final double length,
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 * length;
g.setColor(textColor);
g.drawString(text, x - fm.stringWidth(text) / 2, y);
final String subtext = labels[i].subtext;
if (subtext != null)
g.drawString(subtext, i != 0 ? x - fm.stringWidth(subtext) / 2 :
x - fm.stringWidth(subtext), y + fm.getHeight());
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 lineOffset = fm.getAscent() / 2;
for (int i = 0; i < labels.length; i++)
{
final String text = labels[i].text;
final double y = originY - labels[i].position * length;
g.setColor(majorTickColor);
g.drawLine(originX - majorTickLength, y, originX + majorTickLength, y);
g.setColor(textColor);
g.drawString(text, axis.onLeftSide ? x - fm.stringWidth(text) : x, y + lineOffset);
}
}
}
int getMajorTickMarkLength()
{
return majorTickLength;
}
/*
* end AxisType methods
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* begin coordinate transformation methods
*/
public double convert(final long d)
{
return timeToPixel(d);
}
public long map(final double i)
{
final int minL = axis.getMinLocation();
final int maxL = axis.getMaxLocation();
final double d = (i - minL) / (maxL - minL);
return axis_min + (long) (d * (axis_max - axis_min));
}
/*
* end coordinate transformation methods
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* begin private methods
*/
private int getMaxNumberOfDivisions(final FontMetrics fm, final int axisLength)
{
return Math.max(minNumberOfDivisions, axis.getAxisOrientation() == Axis.HORIZONTAL ?
axisLength / (fm.charWidth('5') * maxCharsPerLabel + minSpaceBetweenLabels) : // assume '5' has typical width
axisLength / (fm.getMaxAscent() + fm.getMaxDescent() + fm.getHeight() +
minSpaceBetweenLabels));
// getMaxAscent() covers height of first line
// getMaxDescent() + getHeight() covers second line
}
/**
* Returns the index corresponding to the units we will use on the axis.
* As an example, if the argument represents a number greater than or equal to 30 seconds
* and less than 30 minutes, minutes will be the major units on the axis. The
* algorithm finds the units such that the minDivisionSpan given is
* greater than or equal to half of one of the units it returns but less than
* half of one of the next larger units (if they exist).
* @param minDivisionSpan the minimum number of milliseconds in a division
*/
private int getScaleIndex(final long minDivisionSpan)
{
final long minTime = minDivisionSpan * 2L;
int scaleIndex = scaleFactors.length;
while (--scaleIndex > 0 && minTime < scaleFactors[scaleIndex]);
return scaleIndex;
}
private boolean setToZero(final int scaleIndex)
{
boolean allMin = true;
for (int i = 0; i < scaleIndex; i++)
{
int field = calendarFields[i];
final int min = calendar.getMinimum(field);
final boolean isMin = calendar.get(field) == min;
allMin = allMin && isMin;
if (! isMin) calendar.set(field, min);
}
return allMin;
}
private DateLabel[] getAxisLabels(final int maxNumberOfDivisions)
{
// some initialization:
calendar.setTimeInMillis(data_min); // may go forward or backward
calendar.setTimeZone(timeZone);
format.setTimeZone(timeZone);
axis_min = data_min;
axis_max = data_max;
labelsValid = true;
final long difference = data_max - data_min;
final int scaleIndex = getScaleIndex(difference / (long) maxNumberOfDivisions);
// scaleIndex represents the units that will appear on the axis
// we may clump several of these units into one division, but we won't divide them up
int unitsPerDivision = 1; // 1 is default, we may increase this
if ((int) (difference / scaleFactors[scaleIndex]) > maxNumberOfDivisions)
{
final int naturalNumberInClump = (int) (difference /
(long) maxNumberOfDivisions / scaleFactors[scaleIndex]) + 1;
int[] acceptableClumps;
if (scaleIndex == DAYS)
{
final int[] a = {2, 5, 10, 15};
acceptableClumps = a;
}
else if (scaleIndex == YEARS)
{
if (naturalNumberInClump > 100)
{
int i = naturalNumberInClump;
int mult = 1;
while (i > 100)
{
mult *= 100;
i /= 100;
}
final int[] a = {2 * mult, 5 * mult, 10 * mult, 25 * mult, 50 * mult, 100 * mult};
acceptableClumps = a;
}
else
{
final int[] a = {2, 5, 10, 25, 50, 100};
acceptableClumps = a;
}
}
else if (scaleIndex == MILLISECONDS)
{
final int[] a = {2, 5, 10, 25, 50, 100, 200, 250, 500};
acceptableClumps = a;
}
else if (scaleIndex == MONTHS)
{
final int[] a = {2, 3, 4, 6};
acceptableClumps = a;
}
else if (scaleIndex == HOURS)
{
final int[] a = {2, 3, 4, 6, 12};
acceptableClumps = a;
}
else // we're in seconds or minutes
{
final int[] a = {2, 5, 10, 15, 20, 30};
acceptableClumps = a;
}
int i = 0;
while (i - 1 < acceptableClumps.length && naturalNumberInClump > acceptableClumps[i])
i++;
unitsPerDivision = acceptableClumps[i];
}
final boolean allMinAtMin = setToZero(scaleIndex);
if (useSuggestedRange)
{
int fieldValue;
int mod;
// set the min
fieldValue = calendar.get(calendarFields[scaleIndex]);
mod = (scaleIndex == DAYS && unitsPerDivision == 2 ? fieldValue - 1 : fieldValue)
% unitsPerDivision;
if (scaleIndex == DAYS && mod != 0 && fieldValue - mod +
unitsPerDivision > monthLengths[calendar.get(Calendar.MONTH)])
calendar.add(calendarFields[scaleIndex], -mod - unitsPerDivision);
else if (mod != 0)
{
if (scaleIndex != DAYS || fieldValue > unitsPerDivision)
calendar.add(calendarFields[scaleIndex], -mod);
else
calendar.set(Calendar.DATE, 1);
}
axis_min = calendar.getTimeInMillis();
// temporarily set the calendar to the maximum: here we determine how to round up and set the max
calendar.setTimeInMillis(data_max);
fieldValue = calendar.get(calendarFields[scaleIndex]);
mod = (scaleIndex == DAYS && unitsPerDivision == 2 ? fieldValue - 1 : fieldValue)
% unitsPerDivision;
if (!setToZero(scaleIndex) || mod != 0)
{
calendar.add(calendarFields[scaleIndex], unitsPerDivision - mod);
}
axis_max = calendar.getTimeInMillis();
// restore to min
calendar.setTimeInMillis(axis_min);
}
else if (! allMinAtMin)
{
if (scaleIndex == DAYS && calendar.get(Calendar.DATE) % unitsPerDivision != 0 &&
calendar.get(Calendar.DATE) + unitsPerDivision >= monthLengths[calendar.get(Calendar.MONTH)])
{
calendar.set(Calendar.DATE, 1);
calendar.add(Calendar.MONTH, 1);
}
else if (scaleIndex == DAYS && calendar.get(Calendar.DATE) < unitsPerDivision)
{
calendar.set(Calendar.DATE, 1);
}
else
{
calendar.add(calendarFields[scaleIndex], unitsPerDivision -
calendar.get(calendarFields[scaleIndex]) % unitsPerDivision);
}
}
final String normalLine = normalTimeFormats[scaleIndex];
int lastValueOfNextHigherField = -1;
final boolean isHorizontal = axis.getAxisOrientation() == Axis.HORIZONTAL;
boolean first = true;
while (true)
{
DateLabel newLabel = new DateLabel();
labelVector.addElement(newLabel);
format.applyPattern(first && !isHorizontal ? verticalAxisFirstEntryTimeFormats[scaleIndex] :
normalLine);
newLabel.text = format.format(calendar.getTime());
newLabel.position = timeToDouble(calendar.getTimeInMillis());
if (first)
{
first = false;
if (isHorizontal)
{
final String pattern = horizontalAxisSecondLineFirstEntryTimeFormats[scaleIndex];
if (pattern != null)
{
format.applyPattern(pattern);
newLabel.subtext = format.format(calendar.getTime());
}
}
if (scaleIndex + 1 < calendarFields.length)
lastValueOfNextHigherField =
calendar.get(calendarFields[getIndexForNextHighestField(scaleIndex)]);
}
else if (scaleIndex + 1 < calendarFields.length)
{
int currentValueOfNextHigherField =
calendar.get(calendarFields[getIndexForNextHighestField(scaleIndex)]);
if (currentValueOfNextHigherField != lastValueOfNextHigherField)
{
if (isHorizontal)
{
format.applyPattern(horizontalAxisSecondLineSubsequentEntryTimeFormats[scaleIndex]);
newLabel.subtext = format.format(calendar.getTime());
}
else
{
format.applyPattern(verticalAxisChangedUnitsTimeFormatsPrefix[scaleIndex]);
newLabel.text = format.format(calendar.getTime()).concat(newLabel.text);
}
lastValueOfNextHigherField = currentValueOfNextHigherField;
}
}
if (scaleIndex == DAYS && unitsPerDivision != 1)
{
final int day = calendar.get(Calendar.DAY_OF_MONTH);
int nextLabel = day + unitsPerDivision;
if (day == 1 && unitsPerDivision != 2)
nextLabel--;
if (nextLabel + unitsPerDivision / 2 > monthLengths[calendar.get(Calendar.MONTH)])
{
calendar.set(Calendar.DAY_OF_MONTH, 1);
calendar.add(Calendar.MONTH, 1);
if (calendar.getTimeInMillis() > axis_max &&
nextLabel <= monthLengths[calendar.get(Calendar.MONTH)])
{
calendar.add(Calendar.MONTH, -1);
calendar.set(Calendar.DAY_OF_MONTH, nextLabel);
}
}
else
calendar.set(Calendar.DAY_OF_MONTH, nextLabel);
}
else
calendar.add(calendarFields[scaleIndex], unitsPerDivision);
if (calendar.getTimeInMillis() <= axis_max)
// we're set up for the next label, so we...
continue;
// we're done, so we...
break;
}
DateLabel[] result = new DateLabel[labelVector.size()];
labelVector.copyInto(result);
labelVector.removeAllElements();
return result;
}
private int getIndexForNextHighestField(final int scaleIndex)
{
switch (scaleIndex)
{
case MILLISECONDS:
// When our units are in milliseconds, we will display seconds so we only
// need a subtext update when the minute changes.
return MINUTES;
case MINUTES:
// When our units are in minutes, we will display hours so we only
// need a subtext update when the day changes.
return DAYS;
default:
// For all other cases, we need an update when the next higher
// field has changed.
return scaleIndex + 1;
}
}
private double timeToPixel(long time)
{
final int minL = axis.getMinLocation();
final int maxL = axis.getMaxLocation();
return minL + timeToDouble(time) * (maxL - minL);
}
private double timeToDouble(long time)
{
return ((double) (time - axis_min)) / ((double) (axis_max - axis_min));
}
/*
* end private methods
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* begin public interface
*/
public void setMin(final long min)
{
if (data_min != min)
{
labelsValid = false;
data_min = min;
axis_min = min;
if (axis != null) axis.revalidate();
}
}
public void setMax(final long max)
{
if (data_max != max)
{
labelsValid = false;
data_max = max;
axis_max = max;
if (axis != null) axis.revalidate();
}
}
public long getDataMin()
{
return data_min;
}
public long getDataMax()
{
return data_max;
}
public long getAxisMin()
{
return axis_min;
}
public long getAxisMax()
{
return axis_max;
}
public void setTimeZone(final TimeZone z)
{
if (timeZone != z)
{
labelsValid = false;
timeZone = z;
}
}
public TimeZone getTimeZone()
{
return timeZone;
}
public void setUseSuggestedRange(boolean useSuggestedRange)
{
if (this.useSuggestedRange != useSuggestedRange)
{
labelsValid = false;
this.useSuggestedRange = useSuggestedRange;
if (axis != null) axis.revalidate();
}
}
public boolean getUseSuggestedRange()
{
return useSuggestedRange;
}
/*
* end public interface
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* begin externalization methods
*/
public void writeExternal(final ObjectOutput out) throws IOException
{
out.writeBoolean(useSuggestedRange);
out.writeObject(timeZone);
}
public void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException
{
useSuggestedRange = in.readBoolean();
timeZone = (TimeZone) in.readObject();
}
/*
* end externalization methods
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
private TimeZone timeZone = TimeZone.getDefault();
private final int majorTickLength = 5;
private final int maxCharsPerLabel = 6;
private final int minSpaceBetweenLabels = 3;
private final int minNumberOfDivisions = 1;
private long data_min=0, data_max=3600000; // actual min/max for the data set
private long axis_min=0, axis_max=3600000; // min/max of the axis
private DateLabel[] labels;
private final JASCalendar calendar = new JASCalendar();
private final SimpleDateFormat format = new SimpleDateFormat();
private final Vector labelVector = new Vector();
boolean useSuggestedRange = false;
// scale index values
private final int MILLISECONDS = 0;
private final int SECONDS = 1;
private final int MINUTES = 2;
private final int HOURS = 3;
private final int DAYS = 4;
private final int MONTHS = 5;
private final int YEARS = 6;
final private static long[] scaleFactors = // used to determine an approximate scale
{
1L, // index 0: milliseconds
1000L, // index 1: seconds
1000L * 60L, // index 2: minutes
1000L * 60L * 60L, // index 3: hours
1000L * 60L * 60L * 24L, // index 4: days
1000L * 60L * 60L * 24L * 30L, // index 5: months
1000L * 60L * 60L * 24L * 30L * 12L, // index 6: years
};
final private static int[] calendarFields =
{
Calendar.MILLISECOND,
Calendar.SECOND,
Calendar.MINUTE,
Calendar.HOUR_OF_DAY,
Calendar.DATE,
Calendar.MONTH,
Calendar.YEAR
};
final private String[] normalTimeFormats =
{
"s.SSS", // millisecond
"s", // second
"H:mm", // minute
"H:mm", // hour
"d", // day
"MMM", // month
"yyyy" // year
};
final private String[] horizontalAxisSecondLineFirstEntryTimeFormats =
{
"MMM d, yyyy, H:mm", // millisecond
"MMM d, yyyy, H:mm", // second
"MMM d, yyyy", // minute
"MMM d, yyyy", // hour
"MMM, yyyy", // day
"yyyy", // month
null
};
final private String[] horizontalAxisSecondLineSubsequentEntryTimeFormats =
{
"H:mm", // millisecond
"H:mm", // second
"MMM d", // minute
"MMM d", // hour
"MMM", // day
"yyyy", // month
null
};
final private String[] verticalAxisFirstEntryTimeFormats =
{
"MMM d, yyyy, H:mm:ss.SSS", // millisecond
"MMM d, yyyy, H:mm:ss", // second
"MMM d, yyyy, H:mm", // minute
"MMM d, yyyy, H:mm", // hour
"MMM d, yyyy", // day
"MMM, yyyy", // month
"yyyy" // year
};
final private String[] verticalAxisChangedUnitsTimeFormatsPrefix =
// for labels on vertical axes, the normal formats are concatenated to these formats when the units change
{
"(H:mm) ", // millisecond
"(H:mm) ", // second
"MMM d, ", // minute
"MMM d, ", // hour
"MMM ", // day
"(yyyy) ", // month
null
};
final private int[] monthLengths =
{
31, // Jan
28, // Feb
31, // Mar
30, // Apr
31, // May
30, // Jun
31, // Jul
31, // Aug
30, // Sep
31, // Oct
30, // Nov
31 // Dec
};
private final static class DateLabel extends AxisLabel
{
String subtext = null;
}
private final static class JASCalendar extends GregorianCalendar
{
// we convert a protected method to public
public long getTimeInMillis()
{
return super.getTimeInMillis();
}
// we convert a protected method to public
public void setTimeInMillis(final long time)
{
super.setTimeInMillis(time);
}
}
}
jas-plotter-2.2.10/src/main/java/jas/plot/Legend.java 0000644 0002656 0002032 00000015152 10631357137 021571 0 ustar andreas admin 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; iAxisType 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
}
jas-plotter-2.2.10/src/main/java/jas/plot/java2/ 0000755 0002656 0002032 00000000000 14746176461 020541 5 ustar andreas admin jas-plotter-2.2.10/src/main/java/jas/plot/java2/PlotGraphics12.java 0000644 0002656 0002032 00000017547 10631354456 024153 0 ustar andreas admin package jas.plot.java2;
import jas.plot.SetablePlotGraphics;
import jas.plot.Transformation;
import java.awt.Color;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.RenderingHints;
import java.awt.Shape;
import java.awt.Stroke;
import java.awt.geom.Arc2D;
import java.awt.geom.GeneralPath;
import java.awt.geom.Line2D;
import java.awt.geom.Rectangle2D;
import java.awt.Rectangle;
import java.awt.image.BufferedImage;
public class PlotGraphics12 implements SetablePlotGraphics
{
public void setStroke(Stroke s)
{
if (s == null) g.setStroke(oldStroke);
else g.setStroke(s);
}
public void setGraphics(Graphics gin)
{
this.g = (Graphics2D) gin;
if (g == null)
{
oldClip = null;
oldStroke = null;
}
else
{
oldClip = g.getClip();
oldStroke = g.getStroke();
g.setRenderingHints(rh);
}
clearTransformation();
}
public Graphics2D graphics() {
return g;
}
public void setTransformation(Transformation x, Transformation y)
{
xt = x == null ? defaultTransformation : x;
yt = y == null ? defaultTransformation : y;
}
public void clearTransformation()
{
xt = defaultTransformation;
yt = defaultTransformation;
}
public void drawLine(double x1, double y1, double x2, double y2)
{
line.setLine(xt.convert(x1),yt.convert(y1),
xt.convert(x2),yt.convert(y2));
g.draw(line);
}
public void fillRect(double x1, double y1, double x2, double y2)
{
double xx1 = xt.convert(x1);
double yy1 = yt.convert(y1);
double xx2 = xt.convert(x2);
double yy2 = yt.convert(y2);
if (xx2 < xx1)
{ double t = xx1; xx1 = xx2; xx2 = t; }
if (yy2 < yy1)
{ double t = yy1; yy1 = yy2; yy2 = t; }
// force rectangle width and height to be at least 1 pixel
double w = xx2-xx1;
if (w < 1.0) w = 1;
double h = yy2-yy1;
if (h < 1.0) h = 1;
rect.setRect(xx1,yy1,w,h);
g.fill(rect);
}
public void drawOval(double x1, double y1, double x2, double y2)
{
double xx1 = xt.convert(x1);
double yy1 = yt.convert(y1);
double xx2 = xt.convert(x2);
double yy2 = yt.convert(y2);
if (xx2 < xx1)
{ double t = xx1; xx1 = xx2; xx2 = t; }
if (yy2 < yy1)
{ double t = yy1; yy1 = yy2; yy2 = t; }
// force oval width and height to be at least 1 pixel
double w = xx2-xx1;
if (w < 1.0) w = 1;
double h = yy2-yy1;
if (h < 1.0) h = 1;
arc.setArc(xx1,yy1,w,h,0,360,arc.CHORD);
g.draw(arc);
}
public void drawRect(double x1, double y1, double x2, double y2)
{
double xx1 = xt.convert(x1);
double yy1 = yt.convert(y1);
double xx2 = xt.convert(x2);
double yy2 = yt.convert(y2);
if (xx2 < xx1)
{ double t = xx1; xx1 = xx2; xx2 = t; }
if (yy2 < yy1)
{ double t = yy1; yy1 = yy2; yy2 = t; }
// force rectangle width and height to be at least 1 pixel
double w = xx2-xx1;
if (w < 1.0) w = 1;
double h = yy2-yy1;
if (h < 1.0) h = 1;
rect.setRect(xx1,yy1,w,h);
g.draw(rect);
}
public void setColor(Color c)
{
g.setColor(c);
}
public void drawString(String s, double x, double y)
{
g.drawString(s,(float) xt.convert(x), (float) yt.convert(y));
}
public FontMetrics getFontMetrics()
{
return g.getFontMetrics();
}
public void drawSymbol(double x, double y, double size, int type)
{
Shape s = getShapeForSymbol(x,y,size,type);
if (isFilled[type]) g.fill(s);
else g.draw(s);
}
private Shape getShapeForSymbol(double x, double y, double size, int type)
{
float xx = (float) xt.convert(x);
float yy = (float) yt.convert(y);
float ss = (float) size/2;
switch (type)
{
case SYMBOL_CIRCLE:
case SYMBOL_DOT:
arc.setArc(xx-ss,yy-ss,size,size,0,360,arc.PIE);
return arc;
case SYMBOL_BOX:
case SYMBOL_SQUARE:
rect.setRect(xx-ss,yy-ss,size,size);
return rect;
case SYMBOL_TRIANGLE:
path.reset();
path.moveTo(xx-ss,yy+ss);
path.lineTo(xx+ss,yy+ss);
path.lineTo(xx,yy-ss);
path.closePath();
return path;
case SYMBOL_DIAMOND:
path.reset();
path.moveTo(xx-ss,yy);
path.lineTo(xx,yy+ss);
path.lineTo(xx+ss,yy);
path.lineTo(xx,yy-ss);
path.closePath();
return path;
case SYMBOL_STAR:
path.reset();
path.moveTo(xx,yy+ss);
path.lineTo(xx,yy-ss);
path.moveTo(xx-ss,yy);
path.lineTo(xx+ss,yy);
path.moveTo(xx-ss,yy-ss);
path.lineTo(xx+ss,yy+ss);
path.moveTo(xx+ss,yy-ss);
path.lineTo(xx-ss,yy+ss);
return path;
case SYMBOL_VERT_LINE:
line.setLine(xx,yy+ss,xx,yy-ss);
return line;
case SYMBOL_HORIZ_LINE:
line.setLine(xx-ss,yy,xx+ss,yy);
return line;
case SYMBOL_CROSS:
path.reset();
path.moveTo(xx,yy+ss);
path.lineTo(xx,yy-ss);
path.moveTo(xx-ss,yy);
path.lineTo(xx+ss,yy);
return path;
}
throw new RuntimeException("Unknown symbol "+type);
}
public void drawPolyLine(double[] x, double[] y, int n)
{
if (n <= 0) return;
path.reset();
path.moveTo((float) xt.convert(x[0]),(float) yt.convert(y[0]));
for (int i=1; iDateAxis type.
* @see DateAxis
* @author Jonas Gifford
*/
public interface DateCoordinateTransformation extends CoordinateTransformation
{
/** Returns a pixel value on the axis for the given date value. */
double convert(long d);
/** Returns a date value for the given pixel value. */
long map(double i);
/** Returns the minimum value on the axis. */
long getAxisMin();
/** Returns the maximum value on the axis. */
long getAxisMax();
}
jas-plotter-2.2.10/src/main/java/jas/plot/DoubleNumberFormatter.java 0000644 0002656 0002032 00000001156 10631354456 024642 0 ustar andreas admin package jas.plot;
import java.text.NumberFormat;
// Used only by the DoubleAxis type to format number.
// Not meant to be public.
final class DoubleNumberFormatter
{
DoubleNumberFormatter(int power)
{
if (formatter == null)
formatter = NumberFormat.getInstance();
this.power = power;
}
void setFractionDigits(int fractDigits)
{
formatter.setMinimumFractionDigits(fractDigits);
formatter.setMaximumFractionDigits(fractDigits);
}
String format(final double d)
{
return formatter.format(power != 0 ? d / Math.pow(10.0, power) : d);
}
private static NumberFormat formatter = null;
private int power;
}
jas-plotter-2.2.10/src/main/java/jas/plot/HasPopupItems.java 0000644 0002656 0002032 00000001367 10631354456 023140 0 ustar andreas admin 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);
}
jas-plotter-2.2.10/src/main/java/jas/plot/FontMenuItem.java 0000644 0002656 0002032 00000001407 10631357137 022743 0 ustar andreas admin 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;
}
jas-plotter-2.2.10/src/main/resources/ 0000755 0002656 0002032 00000000000 14746176463 017076 5 ustar andreas admin jas-plotter-2.2.10/src/main/resources/jas/ 0000755 0002656 0002032 00000000000 14746176464 017654 5 ustar andreas admin jas-plotter-2.2.10/src/main/resources/jas/util/ 0000755 0002656 0002032 00000000000 14746176463 020630 5 ustar andreas admin jas-plotter-2.2.10/src/main/resources/jas/util/pluginmanager/ 0000755 0002656 0002032 00000000000 14746176463 023461 5 ustar andreas admin jas-plotter-2.2.10/src/main/resources/jas/util/pluginmanager/jasplugin.dtd 0000644 0002656 0002032 00000001101 10631354456 026130 0 ustar andreas admin
jas-plotter-2.2.10/src/main/resources/jas/util/xmlmenus/ 0000755 0002656 0002032 00000000000 14746176464 022501 5 ustar andreas admin jas-plotter-2.2.10/src/main/resources/jas/util/xmlmenus/menus.dtd 0000644 0002656 0002032 00000006457 10631354456 024325 0 ustar andreas admin
jas-plotter-2.2.10/src/main/resources/jas/util/down.gif 0000644 0002656 0002032 00000001464 10631354456 022260 0 ustar andreas admin 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 33333f33™33Ì33ÿ33 f33f3ff3™f3Ìf3ÿf3 ™33™3f™3™™3Ì™3ÿ™3 Ì33Ì3fÌ3™Ì3ÌÌ3ÿÌ3 ÿ33ÿ3fÿ3™ÿ3Ìÿ3ÿÿ3 f3 ff f™ fÌ fÿ f 3f33ff3f™3fÌ3fÿ3f ff3fffff™ffÌffÿff ™f3™ff™f™™fÌ™fÿ™f Ìf3ÌffÌf™ÌfÌÌfÿÌf ÿf3ÿffÿf™ÿfÌÿfÿÿf ™3 ™f ™™ ™Ì ™ÿ ™ 3™33™f3™™3™Ì3™ÿ3™ f™3f™ff™™f™Ìf™ÿf™ ™™3™™f™™™™™Ì™™ÿ™™ Ì™3Ì™fÌ™™Ì™ÌÌ™ÿÌ™ ÿ™3ÿ™fÿ™™ÿ™Ìÿ™ÿÿ™ Ì3 Ìf Ì™ ÌÌ Ìÿ Ì 3Ì33Ìf3Ì™3ÌÌ3Ìÿ3Ì fÌ3fÌffÌ™fÌÌfÌÿfÌ ™Ì3™Ìf™Ì™™ÌÌ™Ìÿ™Ì ÌÌ3ÌÌfÌÌ™ÌÌÌÌÌÿÌÌ ÿÌ3ÿÌfÿÌ™ÿÌÌÿÌÿÿÌ ÿ3 ÿf ÿ™ ÿÌ ÿÿ ÿ 3ÿ33ÿf3ÿ™3ÿÌ3ÿÿ3ÿ fÿ3fÿffÿ™fÿÌfÿÿfÿ ™ÿ3™ÿf™ÿ™™ÿÌ™ÿÿ™ÿ Ìÿ3ÌÿfÌÿ™ÌÿÌÌÿÿÌÿ ÿÿ3ÿÿfÿÿ™ÿÿÌÿÿÿÿÿ !ù ¬ , @ €«Lx0a@ ; jas-plotter-2.2.10/src/main/resources/jas/util/up.gif 0000644 0002656 0002032 00000001463 10631354456 021734 0 ustar andreas admin 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 33333f33™33Ì33ÿ33 f33f3ff3™f3Ìf3ÿf3 ™33™3f™3™™3Ì™3ÿ™3 Ì33Ì3fÌ3™Ì3ÌÌ3ÿÌ3 ÿ33ÿ3fÿ3™ÿ3Ìÿ3ÿÿ3 f3 ff f™ fÌ fÿ f 3f33ff3f™3fÌ3fÿ3f ff3fffff™ffÌffÿff ™f3™ff™f™™fÌ™fÿ™f Ìf3ÌffÌf™ÌfÌÌfÿÌf ÿf3ÿffÿf™ÿfÌÿfÿÿf ™3 ™f ™™ ™Ì ™ÿ ™ 3™33™f3™™3™Ì3™ÿ3™ f™3f™ff™™f™Ìf™ÿf™ ™™3™™f™™™™™Ì™™ÿ™™ Ì™3Ì™fÌ™™Ì™ÌÌ™ÿÌ™ ÿ™3ÿ™fÿ™™ÿ™Ìÿ™ÿÿ™ Ì3 Ìf Ì™ ÌÌ Ìÿ Ì 3Ì33Ìf3Ì™3ÌÌ3Ìÿ3Ì fÌ3fÌffÌ™fÌÌfÌÿfÌ ™Ì3™Ìf™Ì™™ÌÌ™Ìÿ™Ì ÌÌ3ÌÌfÌÌ™ÌÌÌÌÌÿÌÌ ÿÌ3ÿÌfÿÌ™ÿÌÌÿÌÿÿÌ ÿ3 ÿf ÿ™ ÿÌ ÿÿ ÿ 3ÿ33ÿf3ÿ™3ÿÌ3ÿÿ3ÿ fÿ3fÿffÿ™fÿÌfÿÿfÿ ™ÿ3™ÿf™ÿ™™ÿÌ™ÿÿ™ÿ Ìÿ3ÌÿfÌÿ™ÌÿÌÌÿÿÌÿ ÿÿ3ÿÿfÿÿ™ÿÿÌÿÿÿÿÿ !ù ¬ , @ Y p €ƒ
&DÈ0 ; jas-plotter-2.2.10/src/main/resources/jas/util/brokenIcon.gif 0000644 0002656 0002032 00000001641 10631354456 023377 0 ustar andreas admin 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 33333f33™33Ì33ÿ33 f33f3ff3™f3Ìf3ÿf3 ™33™3f™3™™3Ì™3ÿ™3 Ì33Ì3fÌ3™Ì3ÌÌ3ÿÌ3 ÿ33ÿ3fÿ3™ÿ3Ìÿ3ÿÿ3 f3 ff f™ fÌ fÿ f 3f33ff3f™3fÌ3fÿ3f ff3fffff™ffÌffÿff ™f3™ff™f™™fÌ™fÿ™f Ìf3ÌffÌf™ÌfÌÌfÿÌf ÿf3ÿffÿf™ÿfÌÿfÿÿf ™3 ™f ™™ ™Ì ™ÿ ™ 3™33™f3™™3™Ì3™ÿ3™ f™3f™ff™™f™Ìf™ÿf™ ™™3™™f™™™™™Ì™™ÿ™™ Ì™3Ì™fÌ™™Ì™ÌÌ™ÿÌ™ ÿ™3ÿ™fÿ™™ÿ™Ìÿ™ÿÿ™ Ì3 Ìf Ì™ ÌÌ Ìÿ Ì 3Ì33Ìf3Ì™3ÌÌ3Ìÿ3Ì fÌ3fÌffÌ™fÌÌfÌÿfÌ ™Ì3™Ìf™Ì™™ÌÌ™Ìÿ™Ì ÌÌ3ÌÌfÌÌ™ÌÌÌÌÌÿÌÌ ÿÌ3ÿÌfÿÌ™ÿÌÌÿÌÿÿÌ ÿ3 ÿf ÿ™ ÿÌ ÿÿ ÿ 3ÿ33ÿf3ÿ™3ÿÌ3ÿÿ3ÿ fÿ3fÿffÿ™fÿÌfÿÿfÿ ™ÿ3™ÿf™ÿ™™ÿÌ™ÿÿ™ÿ Ìÿ3ÌÿfÌÿ™ÌÿÌÌÿÿÌÿ ÿÿ3ÿÿfÿÿ™ÿÿÌÿÿÿÿÿ !ù , ~ H° ÁƒYQÈp¡C…\›H±â5V]{(±"Æˆ× ÀâG Œ,PÒã@‰"IšÌ¸‘`È…!_Z¼Æ… Nj´¸ç§„ :)îáé¨PŠ\h• x1é ZX[N|kVŠ'% ›‘•Ù³hDȶ-Á€ ; jas-plotter-2.2.10/src/main/resources/jas/hist/ 0000755 0002656 0002032 00000000000 14746176464 020623 5 ustar andreas admin jas-plotter-2.2.10/src/main/resources/jas/hist/tick.gif 0000644 0002656 0002032 00000002135 10631354456 022231 0 ustar andreas admin 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 33333f33™33Ì33ÿ33 f33f3ff3™f3Ìf3ÿf3 ™33™3f™3™™3Ì™3ÿ™3 Ì33Ì3fÌ3™Ì3ÌÌ3ÿÌ3 ÿ33ÿ3fÿ3™ÿ3Ìÿ3ÿÿ3 f3 ff f™ fÌ fÿ f 3f33ff3f™3fÌ3fÿ3f ff3fffff™ffÌffÿff ™f3™ff™f™™fÌ™fÿ™f Ìf3ÌffÌf™ÌfÌÌfÿÌf ÿf3ÿffÿf™ÿfÌÿfÿÿf ™3 ™f ™™ ™Ì ™ÿ ™ 3™33™f3™™3™Ì3™ÿ3™ f™3f™ff™™f™Ìf™ÿf™ ™™3™™f™™™™™Ì™™ÿ™™ Ì™3Ì™fÌ™™Ì™ÌÌ™ÿÌ™ ÿ™3ÿ™fÿ™™ÿ™Ìÿ™ÿÿ™ Ì3 Ìf Ì™ ÌÌ Ìÿ Ì 3Ì33Ìf3Ì™3ÌÌ3Ìÿ3Ì fÌ3fÌffÌ™fÌÌfÌÿfÌ ™Ì3™Ìf™Ì™™ÌÌ™Ìÿ™Ì ÌÌ3ÌÌfÌÌ™ÌÌÌÌÌÿÌÌ ÿÌ3ÿÌfÿÌ™ÿÌÌÿÌÿÿÌ ÿ3 ÿf ÿ™ ÿÌ ÿÿ ÿ 3ÿ33ÿf3ÿ™3ÿÌ3ÿÿ3ÿ fÿ3fÿffÿ™fÿÌfÿÿfÿ ™ÿ3™ÿf™ÿ™™ÿÌ™ÿÿ™ÿ Ìÿ3ÌÿfÌÿ™ÌÿÌÌÿÿÌÿ ÿÿ3ÿÿfÿÿ™ÿÿÌÿÿÿÿÿ !ù × , % # ÿ ¯ H° Aƒÿ*\ÈðÚ
Jd¨Aĉ 6¨h1bƉ8Vœàñ#E‘#Kš4¸eÊ•CºäHfA
3E6Pi²eNŽl^û÷S$Dž'Mù¯©Ó§P£úü¹³éШX¡.ÕP5bÖ¯ÿ”=àt`Ó@ÕÈRبèQ•gŽÑpHaQ’V ƽö£"ŽƒssâEzV–Ž
:¢Zö`S+(dœ×ñÔŠ’åæ$‹” Q—X
”5óÄ2E† xåà‰MÅr¤ úšÐOa7u‰–td¨ºÅ@‰¶¯ÎVrŸþˆÕÔ@mE’µrµ2øds1ºWyýq3:7ÛøûxÃU7-Ðûõóל#þ·aù÷hÂ9Ýñý…MÈ€ Àâ €`5h ƒ‚5Q@ ; jas-plotter-2.2.10/src/main/resources/jas/hist/chi2.gif 0000644 0002656 0002032 00000001624 10631354456 022126 0 ustar andreas admin 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 33333f33™33Ì33ÿ33 f33f3ff3™f3Ìf3ÿf3 ™33™3f™3™™3Ì™3ÿ™3 Ì33Ì3fÌ3™Ì3ÌÌ3ÿÌ3 ÿ33ÿ3fÿ3™ÿ3Ìÿ3ÿÿ3 f3 ff f™ fÌ fÿ f 3f33ff3f™3fÌ3fÿ3f ff3fffff™ffÌffÿff ™f3™ff™f™™fÌ™fÿ™f Ìf3ÌffÌf™ÌfÌÌfÿÌf ÿf3ÿffÿf™ÿfÌÿfÿÿf ™3 ™f ™™ ™Ì ™ÿ ™ 3™33™f3™™3™Ì3™ÿ3™ f™3f™ff™™f™Ìf™ÿf™ ™™3™™f™™™™™Ì™™ÿ™™ Ì™3Ì™fÌ™™Ì™ÌÌ™ÿÌ™ ÿ™3ÿ™fÿ™™ÿ™Ìÿ™ÿÿ™ Ì3 Ìf Ì™ ÌÌ Ìÿ Ì 3Ì33Ìf3Ì™3ÌÌ3Ìÿ3Ì fÌ3fÌffÌ™fÌÌfÌÿfÌ ™Ì3™Ìf™Ì™™ÌÌ™Ìÿ™Ì ÌÌ3ÌÌfÌÌ™ÌÌÌÌÌÿÌÌ ÿÌ3ÿÌfÿÌ™ÿÌÌÿÌÿÿÌ ÿ3 ÿf ÿ™ ÿÌ ÿÿ ÿ 3ÿ33ÿf3ÿ™3ÿÌ3ÿÿ3ÿ fÿ3fÿffÿ™fÿÌfÿÿfÿ ™ÿ3™ÿf™ÿ™™ÿÌ™ÿÿ™ÿ Ìÿ3ÌÿfÌÿ™ÌÿÌÌÿÿÌÿ ÿÿ3ÿÿfÿÿ™ÿÿÌÿÿÿÿÿ !ù × , " q ¯ H €ƒ
*\Èp`BJløâÄ‹+bÜh‘#Ĉ5väˆ$Hƒ G><9ÒcÅ„,¯i¹æÌ’/qêTˆ0eMš>Æ ºp(QžF‹êÄiæQŠNŸ"U)õ£Ã–D{~LêR$ת`Ã. ; jas-plotter-2.2.10/src/main/resources/jas/hist/function.gif 0000644 0002656 0002032 00000001473 10631354456 023130 0 ustar andreas admin 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 33333f33™33Ì33ÿ33 f33f3ff3™f3Ìf3ÿf3 ™33™3f™3™™3Ì™3ÿ™3 Ì33Ì3fÌ3™Ì3ÌÌ3ÿÌ3 ÿ33ÿ3fÿ3™ÿ3Ìÿ3ÿÿ3 f3 ff f™ fÌ fÿ f 3f33ff3f™3fÌ3fÿ3f ff3fffff™ffÌffÿff ™f3™ff™f™™fÌ™fÿ™f Ìf3ÌffÌf™ÌfÌÌfÿÌf ÿf3ÿffÿf™ÿfÌÿfÿÿf ™3 ™f ™™ ™Ì ™ÿ ™ 3™33™f3™™3™Ì3™ÿ3™ f™3f™ff™™f™Ìf™ÿf™ ™™3™™f™™™™™Ì™™ÿ™™ Ì™3Ì™fÌ™™Ì™ÌÌ™ÿÌ™ ÿ™3ÿ™fÿ™™ÿ™Ìÿ™ÿÿ™ Ì3 Ìf Ì™ ÌÌ Ìÿ Ì 3Ì33Ìf3Ì™3ÌÌ3Ìÿ3Ì fÌ3fÌffÌ™fÌÌfÌÿfÌ ™Ì3™Ìf™Ì™™ÌÌ™Ìÿ™Ì ÌÌ3ÌÌfÌÌ™ÌÌÌÌÌÿÌÌ ÿÌ3ÿÌfÿÌ™ÿÌÌÿÌÿÿÌ ÿ3 ÿf ÿ™ ÿÌ ÿÿ ÿ 3ÿ33ÿf3ÿ™3ÿÌ3ÿÿ3ÿ fÿ3fÿffÿ™fÿÌfÿÿfÿ ™ÿ3™ÿf™ÿ™™ÿÌ™ÿÿ™ÿ Ìÿ3ÌÿfÌÿ™ÌÿÌÌÿÿÌÿ ÿÿ3ÿÿfÿÿ™ÿÿÌÿÿÿÿÿ !ù , ¯ HðZƒ6Yˆ°áA‡ #6, ; jas-plotter-2.2.10/src/main/resources/jas/hist/plotML.dtd 0000644 0002656 0002032 00000037537 10631354456 022532 0 ustar andreas admin
jas-plotter-2.2.10/src/main/resources/jas/hist/cross.gif 0000644 0002656 0002032 00000001761 10631354456 022434 0 ustar andreas admin GIF89a ÷ ÿÿÿÿÿÌÿÌÌÿÌ™ÿ™™ÿ™fÿffÿ33ÌÌÌÌ™™Ì™fÌffÌf3Ì33Ì 3Ì TÙ Wöw©XöwPYúwtXöwà ìý 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ࣼ £¼ øëý €Ù Ù zeöwF H ìý
àQöw
0 X f …» f …» ê œÙ wÞ f …» ê ª f …» ê ࣼ !ù , Î ç H° ÁY*\È°!C @±¢EŠ0X`\ )ࣃ L60²â€ @@eK ||0`&M“XZ `ÒÁ >~< ’âËG‘´X3&Å’P+&¥XÕA¢&£RÜʵhV‹dË«uêȧ1›¢ukQ Ì¢
F’Å
Ò Ð‹[èy´ëʶ+Ú=«Ô+âN×^ìRjâÅ„[`P0ã‘]t {³bU™ 4øZšêÔcËžM{a@ ; jas-plotter-2.2.10/src/main/resources/jas/hist/running.gif 0000644 0002656 0002032 00000002053 10631354456 022756 0 ustar andreas admin GIF89a# ÷ ÿÿÿðß3ÿÌÿÿ ÌÌÿ™™™fff3333 33 × CC¸ @ DÙ ”þøwÈ°ùwÿÿÿÿTÙ TÙ Wöw©XöwPYúwtXöwð ìý 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ࣼ £¼ øëý €Ù ‰JöwH J L ÂÎ÷wÿÿÿÿ,Ù dÙ X f …» f …» ê œÙ wÞ f …» ê ª f …» ê ࣼ !ù , # ÿ 7DE° ÁƒÈP¡Ã‡„ˆÐÀ‹
”¸¢A‹C^Œ(Ñ#ÁR¦ ©‘£IŒ*c®œwÑ%E2ˆ9¦Í‡ç¥ q'OŸ
!Â$ÊQ&ž%•
%À´¨Ìžó’:´ˆ %GFjU”ê×
aUB¸õ€Ê³œ®íôÀÔª uÊ´;VaϘ:Ñ:%´/B»S&p1+Û„Aÿ.ŽÉ5*äÆX'«llù H¬™'sîL°@dÐ=/:ÅŒê'*Ó§±L-ò@‚ž -›F ú êÞ$ØÚ$BŽ»yã6¾QàðØó˜'tN\¶ôé>[¿~|ƒrînßÝ0y’ ; jas-plotter-2.2.10/src/main/resources/jas/swingstudio/ 0000755 0002656 0002032 00000000000 14746176464 022233 5 ustar andreas admin jas-plotter-2.2.10/src/main/resources/jas/swingstudio/menus_devel.xml 0000644 0002656 0002032 00000031501 10631354456 025247 0 ustar andreas admin