();
private boolean addingItems = false;
}
figtree-1.4/src/figtree/treeviewer/painters/Roman.java 0000644 0001750 0001750 00000014312 11015357543 023067 0 ustar osallou osallou package figtree.treeviewer.painters;
import java.text.*;
/**
This NumberFormat converts long integers to and from Roman Numeral notation.
Once an instance has been created, the format and parse methods may be used
as defined in java.text.NumberFormat.
The
RomanNumeralConverter
applet demonstrates the use of this class.
@author Ben Clifford
@version $Revision: 1.1 $
*/
public class Roman extends NumberFormat
{
/** This method returns null. I have found no meaningful translation
of floating point numbers to Roman numerals, however the NumberFormat
method requires that it is implemented. Perhaps should just cast
the double to a long and format accordingly.
*/
public StringBuffer format(double n, StringBuffer a, FieldPosition p)
{
return format((long)n, a, p);
}
/** This nested class is used to map Roman symbols onto their numerical
values. Used in the Roman class.
*/
public static class SymTab
{
/** Roman symbol */
char symbol;
/** Numerical value */
long value;
/** Constructor to build a SymTab from supplied symbol and value
@param s Roman symbol
@param v Numerical value
*/
public SymTab(char s, long v) { this.symbol=s; this.value=v; }
};
/** This table maps individual Roman symbols onto their numerical
values.
Unfortunately, JavaDoc JDK 1.1 does not create documentation
for the inner class Roman.SymTab, so the reader
cannot see the definition.
*/
public static Roman.SymTab syms[]= {
new Roman.SymTab('M',1000),
new Roman.SymTab('D',500),
new Roman.SymTab('C',100),
new Roman.SymTab('L',50),
new Roman.SymTab('X',10),
new Roman.SymTab('V',5),
new Roman.SymTab('I',1)
};
/** This method converts a Roman Numeral string to a long integer. It does
not check that the string is in the correct format - for some incorrectly
formatted numbers, i.e. iix, it will produce a number. For others,
it will throw an exception.
@param text string of Roman Numerals
@param parsePosition the place to start parsing
@return A Long object containing the parsed Roman numeral
*/
public Number parse(String text, ParsePosition parsePosition)
{
String s = text.substring(parsePosition.getIndex());
long tot=0,max=0;
char ch[]=s.toUpperCase().toCharArray();
int i,p;
for(p=ch.length-1;p>=0;p--)
{
for(i=0;i=max)
tot+= (max = syms[i].value);
else
tot-= syms[i].value;
}
}
}
// say that we parsed the whole string
parsePosition.setIndex(s.length());
return new Long(tot);
}
/** This method converts a Roman Numeral string to a long integer. It does
not check that the string is in the correct format - for some incorrectly
formatted numbers, i.e. iix, it will produce a number. For others,
it will throw an exception.
@param s string of Roman Numerals
@return The integer representation of the Numerals
*/
public static long toLong(String s)
{
long tot=0,max=0;
char ch[]=s.toUpperCase().toCharArray();
int i,p;
for(p=ch.length-1;p>=0;p--)
{
for(i=0;i=max)
tot+= (max = syms[i].value);
else
tot-= syms[i].value;
}
}
}
return tot;
};
/** This method converts the supplied long into capitalised Roman
numerals.
BUG: the method does not take account of the
FieldPosition p parameter.
@param n The number to be converted into Roman numerals
@param s The StringBuffer into which the output is to be placed.
@return The StringBuffer s
*/
public StringBuffer format(long n, StringBuffer s, FieldPosition p)
{
int i;
while(n>0)
{
for(i=0;i0 && shift0)
{
for(i=0;i0 && shift implements ScalePainter {
private double majorTickSpacing = 1.0;
private double minorTickSpacing = 0.5;
public ScaleAxisPainter() {
super(null);
}
public void setTreePane(TreePane treePane) {
this.treePane = treePane;
}
public void setAutomatic(boolean automatic) {
if (automatic) {
treePane.setAutomaticScale();
majorTickSpacing = treePane.getMajorTickSpacing();
minorTickSpacing = treePane.getMinorTickSpacing();
} else {
treePane.setTickSpacing(majorTickSpacing, minorTickSpacing);
}
}
public void setAxisReversed(final boolean isAxisReversed) {
treePane.setAxisReversed(isAxisReversed);
}
public void setAxisSpacing(double majorTickSpacing, double minorTickSpacing) {
treePane.setTickSpacing(majorTickSpacing, minorTickSpacing);
}
public double getAxisOrigin() {
return 0.0;
}
public void setAxisOrigin(double axisOrigin) {
//
}
public double getMajorTickSpacing() {
return majorTickSpacing;
}
public double getMinorTickSpacing() {
return minorTickSpacing;
}
public Rectangle2D calibrate(Graphics2D g2, TreePane treePane) {
Font oldFont = g2.getFont();
g2.setFont(getFont());
FontMetrics fm = g2.getFontMetrics();
double labelHeight = fm.getHeight();
preferredWidth = treePane.getTreeBounds().getWidth();
preferredHeight = labelHeight + topMargin + bottomMargin + scaleBarStroke.getLineWidth() + majorTickSize;
if (!(treePane.getTreeLayout() instanceof RectilinearTreeLayout)) {
// if the tree layout is not rectilinear, we are not going to display
// an axis at the moment so make the height 0.
preferredHeight = 0.0;
}
tickLabelOffset = (float) (fm.getAscent() + topMargin + bottomMargin + majorTickSize) + scaleBarStroke.getLineWidth();
g2.setFont(oldFont);
return new Rectangle2D.Double(0.0, 0.0, preferredWidth, preferredHeight);
}
public void paint(Graphics2D g2, TreePane treePane, Justification justification, Rectangle2D bounds) {
Font oldFont = g2.getFont();
Paint oldPaint = g2.getPaint();
Stroke oldStroke = g2.getStroke();
if (TreePane.DEBUG_OUTLINE) {
g2.setPaint(Color.red);
g2.draw(bounds);
}
if (treePane.getTreeLayout() instanceof RadialTreeLayout) {
// Unless the layout is the rectilinear or polar one, the grid won't make sense...
return;
}
if (getBackground() != null) {
g2.setPaint(getBackground());
g2.fill(bounds);
}
if (getBorderPaint() != null && getBorderStroke() != null) {
g2.setPaint(getBorderPaint());
g2.setStroke(getBorderStroke());
g2.draw(bounds);
}
g2.setFont(getFont());
g2.setPaint(getForeground());
g2.setStroke(getScaleBarStroke());
paintAxis(g2, bounds);
g2.setFont(oldFont);
g2.setPaint(oldPaint);
g2.setStroke(oldStroke);
}
/**
* Get the maximum width of the labels of an axis
* @param g2
* @return
*/
protected double getMaxTickLabelWidth(Graphics2D g2)
{
String label;
double width;
double maxWidth = 0;
ScaleAxis axis = treePane.getScaleAxis();
if (axis.getLabelFirst()) { // Draw first minor tick as a major one (with a label)
label = axis.getFormatter().format(axis.getMinorTickValue(0, -1));
width = g2.getFontMetrics().stringWidth(label);
if (maxWidth < width)
maxWidth = width;
}
int n = axis.getMajorTickCount();
for (int i = 0; i < n; i++) {
label = axis.getFormatter().format(axis.getMajorTickValue(i));
width = g2.getFontMetrics().stringWidth(label);
if (maxWidth < width)
maxWidth = width;
}
if (axis.getLabelLast()) { // Draw first minor tick as a major one (with a label)
label = axis.getFormatter().format(axis.getMinorTickValue(0, n - 1));
width = g2.getFontMetrics().stringWidth(label);
if (maxWidth < width)
maxWidth = width;
}
return maxWidth;
}
protected void paintAxis(Graphics2D g2, Rectangle2D axisBounds)
{
ScaleAxis axis = treePane.getScaleAxis();
g2.setPaint(getForeground());
g2.setStroke(getScaleBarStroke());
double minX = treePane.scaleOnAxis(axis.getMinAxis());
double maxX = treePane.scaleOnAxis(axis.getMaxAxis());
Line2D line = new Line2D.Double(minX, axisBounds.getMinY(), maxX, axisBounds.getMinY());
g2.draw(line);
int n1 = axis.getMajorTickCount();
int n2, i, j;
n2 = axis.getMinorTickCount(-1);
if (axis.getLabelFirst()) { // Draw first minor tick as a major one (with a label)
paintMajorTick(g2, axisBounds, axis, axis.getMinorTickValue(0, -1));
for (j = 1; j < n2; j++) {
paintMinorTick(g2, axisBounds, axis.getMinorTickValue(j, -1));
}
} else {
for (j = 0; j < n2; j++) {
paintMinorTick(g2, axisBounds, axis.getMinorTickValue(j, -1));
}
}
for (i = 0; i < n1; i++) {
paintMajorTick(g2, axisBounds, axis, axis.getMajorTickValue(i));
n2 = axis.getMinorTickCount(i);
if (i == (n1-1) && axis.getLabelLast()) { // Draw last minor tick as a major one
paintMajorTick(g2, axisBounds, axis, axis.getMinorTickValue(0, i));
for (j = 1; j < n2; j++) {
paintMinorTick(g2, axisBounds, axis.getMinorTickValue(j, i));
}
} else {
for (j = 0; j < n2; j++) {
paintMinorTick(g2, axisBounds, axis.getMinorTickValue(j, i));
}
}
}
}
protected void paintMajorTick(Graphics2D g2, Rectangle2D axisBounds, ScaleAxis axis, double value)
{
g2.setPaint(getForeground());
g2.setStroke(getScaleBarStroke());
String label = axis.getFormatter().format(value);
double pos = treePane.scaleOnAxis(value);
Line2D line = new Line2D.Double(pos, axisBounds.getMinY(), pos, axisBounds.getMinY() + majorTickSize);
g2.draw(line);
g2.setPaint(getForeground());
double width = g2.getFontMetrics().stringWidth(label);
g2.drawString(label, (float)(pos - (width / 2)), (float)(axisBounds.getMinY() + tickLabelOffset));
}
protected void paintMinorTick(Graphics2D g2, Rectangle2D axisBounds, double value)
{
g2.setPaint(getForeground());
g2.setStroke(getScaleBarStroke());
double pos = treePane.scaleOnAxis(value);
Line2D line = new Line2D.Double(pos, axisBounds.getMinY(), pos, axisBounds.getMinY() + minorTickSize);
g2.draw(line);
}
public double getPreferredWidth() {
return preferredWidth;
}
public double getPreferredHeight() {
return preferredHeight;
}
public double getHeightBound() {
return preferredHeight + tickLabelOffset;
}
public BasicStroke getScaleBarStroke() {
return scaleBarStroke;
}
public void setScaleBarStroke(BasicStroke scaleBarStroke) {
this.scaleBarStroke = scaleBarStroke;
firePainterChanged();
}
public void setControlPalette(ControlPalette controlPalette) {
// nothing to do
}
public String[] getAttributes() {
return new String[0];
}
public void setupAttributes(Collection trees) {
// nothing to do...
}
public void setDisplayAttribute(String displayAttribute) {
throw new UnsupportedOperationException("setDisplayAttribute not implemented in ScaleAxisPainter");
}
public void setTextDecorator(Decorator textDecorator) {
}
public Set getAttributableItems() {
return null;
}
private BasicStroke scaleBarStroke = new BasicStroke(1.0f, BasicStroke.CAP_BUTT, BasicStroke.JOIN_BEVEL);
private double topMargin = 4.0;
private double bottomMargin = 4.0;
private double majorTickSize = 5.0;
private double minorTickSize = 2.0;
private double tickLabelOffset = 4.0;
private double preferredHeight;
private double preferredWidth;
protected TreePane treePane;
}
figtree-1.4/src/figtree/treeviewer/painters/LegendPainterController.java 0000644 0001750 0001750 00000025215 12047530032 026574 0 ustar osallou osallou /*
* LegendPainterController.java
*
* Copyright (C) 2012 Andrew Rambaut
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
package figtree.treeviewer.painters;
import figtree.treeviewer.AttributeColourController;
import figtree.treeviewer.ControllerOptionsPanel;
import figtree.treeviewer.TreeViewer;
import figtree.treeviewer.decorators.ColourDecorator;
import figtree.treeviewer.decorators.Decorator;
import figtree.ui.components.RealNumberField;
import jam.controlpalettes.AbstractController;
import jam.controlpalettes.ControllerListener;
import jam.panels.OptionsPanel;
import jebl.util.Attributable;
import javax.swing.*;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import java.text.DecimalFormat;
import java.text.NumberFormat;
import java.util.*;
import java.util.prefs.Preferences;
/**
* @author Andrew Rambaut
* @version $Id: ScaleBarPainterController.java 760 2007-08-21 00:05:45Z rambaut $
*/
public class LegendPainterController extends AbstractController {
public static Preferences PREFS = Preferences.userNodeForPackage(TreeViewer.class);
public static final String CONTROLLER_KEY = "legend";
public static final String FONT_NAME_KEY = "fontName";
public static final String FONT_SIZE_KEY = "fontSize";
public static final String FONT_STYLE_KEY = "fontStyle";
public static final String ATTRIBUTE_KEY = "attribute";
public static final String NUMBER_FORMATTING_KEY = "numberFormatting";
public static final String SIGNIFICANT_DIGITS_KEY = "significantDigits";
// The defaults if there is nothing in the preferences
public static String DEFAULT_FONT_NAME = "sansserif";
public static int DEFAULT_FONT_SIZE = 10;
public static int DEFAULT_FONT_STYLE = Font.PLAIN;
public static String DEFAULT_ATTRIBUTE_KEY = "";
public static String DECIMAL_NUMBER_FORMATTING = "#.####";
public static String SCIENTIFIC_NUMBER_FORMATTING = "0.###E0";
public static int DEFAULT_SIGNIFICANT_DIGITS = 2;
public static String DEFAULT_NUMBER_FORMATTING = DECIMAL_NUMBER_FORMATTING;
public LegendPainterController(final LegendPainter legendPainter,
final AttributeColourController colourController,
final TreeViewer treeViewer) {
final String defaultFontName = PREFS.get(CONTROLLER_KEY + "." + FONT_NAME_KEY, DEFAULT_FONT_NAME);
final int defaultFontStyle = PREFS.getInt(CONTROLLER_KEY + "." + FONT_STYLE_KEY, DEFAULT_FONT_STYLE);
final int defaultFontSize = PREFS.getInt(CONTROLLER_KEY + "." + FONT_SIZE_KEY, DEFAULT_FONT_SIZE);
final int defaultSignificantDigits = PREFS.getInt(CONTROLLER_KEY + "." + SIGNIFICANT_DIGITS_KEY, DEFAULT_SIGNIFICANT_DIGITS);
final String defaultNumberFormatting = PREFS.get(CONTROLLER_KEY + "." + NUMBER_FORMATTING_KEY, DEFAULT_NUMBER_FORMATTING);
final String attribute = PREFS.get(CONTROLLER_KEY + "." + ATTRIBUTE_KEY, DEFAULT_ATTRIBUTE_KEY);
legendPainter.setFont(new Font(defaultFontName, defaultFontStyle, defaultFontSize));
// legendPainter.setDisplayAttribute(attribute);
legendPainter.setNumberFormat(new DecimalFormat(defaultNumberFormatting));
optionsPanel = new ControllerOptionsPanel(2, 2);
titleCheckBox = new JCheckBox(getTitle());
titleCheckBox.setSelected(legendPainter.isVisible());
attributeCombo = new JComboBox();
new AttributeComboHelper(attributeCombo, treeViewer).addListener(new AttributeComboHelperListener() {
@Override
public void attributeComboChanged() {
ColourDecorator colourDecorator = (ColourDecorator)colourController.getColourDecorator(attributeCombo, null);
legendPainter.setColourDecorator(colourDecorator);
}
});
colourController.setupControls(attributeCombo, null);
colourController.addControllerListener(new ControllerListener() {
@Override
public void controlsChanged() {
ColourDecorator colourDecorator = (ColourDecorator)colourController.getColourDecorator(attributeCombo, null);
legendPainter.setColourDecorator(colourDecorator);
}
});
// attributeCombo.addActionListener(new ActionListener() {
// public void actionPerformed(ActionEvent event) {
// legendPainter.setDisplayAttribute((String) attributeCombo.getSelectedItem());
// }
// });
Font font = legendPainter.getFont();
fontSizeSpinner = new JSpinner(new SpinnerNumberModel(font.getSize(), 0.01, 48, 1));
fontSizeSpinner.addChangeListener(new ChangeListener() {
public void stateChanged(ChangeEvent changeEvent) {
final float size = ((Double) fontSizeSpinner.getValue()).floatValue();
Font font = legendPainter.getFont().deriveFont(size);
legendPainter.setFont(font);
}
});
NumberFormat format = legendPainter.getNumberFormat();
int digits = format.getMaximumFractionDigits();
numericalFormatCombo = new JComboBox(new String[] { "Decimal", "Scientific", "Percent", "Roman"});
numericalFormatCombo.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent event) {
String formatType = (String) numericalFormatCombo.getSelectedItem();
final int digits = (Integer) digitsSpinner.getValue();
NumberFormat format = null;
if (formatType.equals("Decimal")) {
format = new DecimalFormat(DECIMAL_NUMBER_FORMATTING);
} else if (formatType.equals("Scientific")) {
format = new DecimalFormat(SCIENTIFIC_NUMBER_FORMATTING);
} else if (formatType.equals("Percent")) {
format = new PercentFormat();
} else if (formatType.equals("Roman")) {
format = new Roman();
}
format.setMaximumFractionDigits(digits);
legendPainter.setNumberFormat(format);
}
});
digitsSpinner = new JSpinner(new SpinnerNumberModel(digits, defaultSignificantDigits, 14, 1));
digitsSpinner.addChangeListener(new ChangeListener() {
public void stateChanged(ChangeEvent changeEvent) {
final int digits = (Integer)digitsSpinner.getValue();
NumberFormat format = legendPainter.getNumberFormat();
format.setMaximumFractionDigits(digits);
legendPainter.setNumberFormat(format);
}
});
final JLabel label1 = optionsPanel.addComponentWithLabel("Attribute:", attributeCombo);
final JLabel label2 = optionsPanel.addComponentWithLabel("Font Size:", fontSizeSpinner);
final JLabel label3 = optionsPanel.addComponentWithLabel("Format:", numericalFormatCombo);
final JLabel label4 = optionsPanel.addComponentWithLabel("Sig. Digits:", digitsSpinner);
addComponent(label1);
addComponent(attributeCombo);
addComponent(label2);
addComponent(fontSizeSpinner);
addComponent(label3);
addComponent(numericalFormatCombo);
addComponent(label4);
addComponent(digitsSpinner);
enableComponents(titleCheckBox.isSelected());
titleCheckBox.addChangeListener(new ChangeListener() {
@Override
public void stateChanged(ChangeEvent changeEvent) {
enableComponents(titleCheckBox.isSelected());
legendPainter.setVisible(titleCheckBox.isSelected());
}
});
// autoScaleCheck.addActionListener(new ActionListener() {
// @Override
// public void actionPerformed(ActionEvent actionEvent) {
// public void stateChanged(ChangeEvent changeEvent) {
// if (autoScaleCheck.isSelected()) {
// scaleBarPainter.setAutomaticScale(true);
// double range = scaleBarPainter.getScaleRange();
// scaleRangeText.setValue(range);
// label1.setEnabled(false);
// scaleRangeText.setEnabled(false);
// } else {
// label1.setEnabled(true);
// scaleRangeText.setEnabled(true);
// scaleBarPainter.setAutomaticScale(false);
// }
// }
// });
}
public JComponent getTitleComponent() {
return titleCheckBox;
}
public JPanel getPanel() {
return optionsPanel;
}
public boolean isInitiallyVisible() {
return false;
}
public void initialize() {
}
public void setSettings(Map settings) {
titleCheckBox.setSelected((Boolean) settings.get(CONTROLLER_KEY + "." + IS_SHOWN));
attributeCombo.setSelectedItem((String) settings.get(CONTROLLER_KEY + "." + ATTRIBUTE_KEY));
fontSizeSpinner.setValue((Double)settings.get(CONTROLLER_KEY + "." + FONT_SIZE_KEY));
digitsSpinner.setValue((Integer) settings.get(CONTROLLER_KEY + "." + SIGNIFICANT_DIGITS_KEY));
}
public void getSettings(Map settings) {
settings.put(CONTROLLER_KEY + "." + IS_SHOWN, titleCheckBox.isSelected());
settings.put(CONTROLLER_KEY + "." + ATTRIBUTE_KEY, attributeCombo.getSelectedItem());
settings.put(CONTROLLER_KEY + "." + FONT_SIZE_KEY, fontSizeSpinner.getValue());
settings.put(CONTROLLER_KEY + "." + SIGNIFICANT_DIGITS_KEY, digitsSpinner.getValue());
}
private final JCheckBox titleCheckBox;
private final OptionsPanel optionsPanel;
private final JComboBox attributeCombo;
private final JSpinner fontSizeSpinner;
private final JComboBox numericalFormatCombo;
private final JSpinner digitsSpinner;
public String getTitle() {
return "Legend";
}
}
figtree-1.4/src/figtree/treeviewer/painters/NodeBarController.java 0000644 0001750 0001750 00000012372 12047530032 025365 0 ustar osallou osallou /*
* NodeBarController.java
*
* Copyright (C) 2012 Andrew Rambaut
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
package figtree.treeviewer.painters;
import figtree.treeviewer.TreeViewer;
import jam.controlpalettes.AbstractController;
import jam.panels.OptionsPanel;
import javax.swing.*;
import javax.swing.event.ChangeListener;
import javax.swing.event.ChangeEvent;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ItemListener;
import java.awt.event.ItemEvent;
import java.awt.*;
import java.util.*;
import java.util.prefs.Preferences;
import figtree.treeviewer.ControllerOptionsPanel;
import jebl.util.Attributable;
/**
* @author Andrew Rambaut
* @version $Id: NodeBarController.java 760 2007-08-21 00:05:45Z rambaut $
*/
public class NodeBarController extends AbstractController {
private static Preferences PREFS = Preferences.userNodeForPackage(NodeBarController.class);
private static final String NODE_BARS_KEY = "nodeBars";
public static final String DISPLAY_ATTRIBUTE_KEY = "displayAttribute";
private static final String BAR_WIDTH_KEY = "barWidth";
private static float DEFAULT_BAR_WIDTH = 4.0f;
public NodeBarController(String title, final NodeBarPainter nodeBarPainter,
final TreeViewer treeViewer) {
this.title = title;
this.nodeBarPainter = nodeBarPainter;
final float defaultBarWidth = PREFS.getFloat(BAR_WIDTH_KEY, DEFAULT_BAR_WIDTH);
optionsPanel = new ControllerOptionsPanel(2, 2);
titleCheckBox = new JCheckBox(getTitle());
titleCheckBox.setSelected(this.nodeBarPainter.isVisible());
displayAttributeCombo = new JComboBox();
new AttributeComboHelper(displayAttributeCombo, treeViewer, LabelPainter.PainterIntent.RANGE).addListener(new AttributeComboHelperListener() {
@Override
public void attributeComboChanged() {
String attribute = (String) displayAttributeCombo.getSelectedItem();
nodeBarPainter.setDisplayAttribute(attribute);
}
});
barWidthSpinner = new JSpinner(new SpinnerNumberModel(defaultBarWidth, 0.01, 48.0, 1.0));
barWidthSpinner.addChangeListener(new ChangeListener() {
public void stateChanged(ChangeEvent changeEvent) {
float lineWidth = ((Double) barWidthSpinner.getValue()).floatValue();
nodeBarPainter.setStroke(new BasicStroke(lineWidth, BasicStroke.CAP_BUTT, BasicStroke.JOIN_BEVEL));
}
});
nodeBarPainter.setStroke(new BasicStroke(defaultBarWidth, BasicStroke.CAP_BUTT, BasicStroke.JOIN_BEVEL));
final JLabel label1 = optionsPanel.addComponentWithLabel("Display:", displayAttributeCombo);
final JLabel label2 = optionsPanel.addComponentWithLabel("Bar Width:", barWidthSpinner);
addComponent(label1);
addComponent(displayAttributeCombo);
addComponent(label2);
addComponent(barWidthSpinner);
enableComponents(titleCheckBox.isSelected());
titleCheckBox.addChangeListener(new ChangeListener() {
public void stateChanged(ChangeEvent changeEvent) {
enableComponents(titleCheckBox.isSelected());
nodeBarPainter.setVisible(titleCheckBox.isSelected());
}
});
}
public JComponent getTitleComponent() {
return titleCheckBox;
}
public JPanel getPanel() {
return optionsPanel;
}
public boolean isInitiallyVisible() {
return false;
}
public void initialize() {
// nothing to do
}
public void setSettings(Map settings) {
titleCheckBox.setSelected((Boolean) settings.get(NODE_BARS_KEY + "." + IS_SHOWN));
displayAttributeCombo.setSelectedItem((String) settings.get(NODE_BARS_KEY + "." + DISPLAY_ATTRIBUTE_KEY));
barWidthSpinner.setValue((Double)settings.get(NODE_BARS_KEY + "." + BAR_WIDTH_KEY));
}
public void getSettings(Map settings) {
settings.put(NODE_BARS_KEY + "." + IS_SHOWN, titleCheckBox.isSelected());
settings.put(NODE_BARS_KEY + "." + DISPLAY_ATTRIBUTE_KEY, displayAttributeCombo.getSelectedItem());
settings.put(NODE_BARS_KEY + "." + BAR_WIDTH_KEY, barWidthSpinner.getValue());
}
private final JCheckBox titleCheckBox;
private final OptionsPanel optionsPanel;
private JComboBox displayAttributeCombo;
public String getTitle() {
return title;
}
private final String title;
private final NodeBarPainter nodeBarPainter;
private final JSpinner barWidthSpinner;
}
figtree-1.4/src/figtree/treeviewer/painters/PainterListener.java 0000644 0001750 0001750 00000002057 12047530032 025116 0 ustar osallou osallou /*
* PainterListener.java
*
* Copyright (C) 2012 Andrew Rambaut
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
package figtree.treeviewer.painters;
/**
* @author Andrew Rambaut
* @version $Id: PainterListener.java 308 2006-05-01 21:15:41Z rambaut $
*/
public interface PainterListener {
void painterChanged();
void painterSettingsChanged();
void attributesChanged();
}
figtree-1.4/src/figtree/treeviewer/painters/NodeShapeController.java 0000644 0001750 0001750 00000024121 12047530032 025714 0 ustar osallou osallou /*
* NodeShapeController.java
*
* Copyright (C) 2012 Andrew Rambaut
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
package figtree.treeviewer.painters;
import figtree.treeviewer.AttributeColourController;
import figtree.treeviewer.TreeViewer;
import figtree.treeviewer.decorators.Decorator;
import jam.controlpalettes.AbstractController;
import jam.controlpalettes.ControllerListener;
import jam.panels.OptionsPanel;
import javax.swing.*;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Map;
import java.util.prefs.Preferences;
import figtree.treeviewer.ControllerOptionsPanel;
/**
* @author Andrew Rambaut
* @version $Id: NodeShapeController.java 760 2007-08-21 00:05:45Z rambaut $
*/
public class NodeShapeController extends AbstractController {
private static Preferences PREFS = Preferences.userNodeForPackage(NodeBarController.class);
private static final String NODE_SHAPE_KEY = "nodeShape";
public static final String SHAPE_TYPE_KEY = "shapeType";
public static final String SCALE_TYPE_KEY = "scaleType";
public static final String SIZE_ATTRIBUTE_KEY = "sizeAttribute";
public static final String COLOUR_ATTRIBUTE_KEY = "colourAttribute";
private static final String SHAPE_SIZE_KEY = "size";
private static final String SHAPE_MIN_SIZE_KEY = "minSize";
public NodeShapeController(String title, final NodeShapePainter nodeShapePainter,
final AttributeColourController colourController,
final TreeViewer treeViewer) {
this.title = title;
this.nodeShapePainter = nodeShapePainter;
final float defaultShapeSize = PREFS.getFloat(SHAPE_SIZE_KEY, (float)NodeShapePainter.MAX_SIZE);
optionsPanel = new ControllerOptionsPanel(2, 2);
titleCheckBox = new JCheckBox(getTitle());
titleCheckBox.setSelected(this.nodeShapePainter.isVisible());
titleCheckBox.addChangeListener(new ChangeListener() {
public void stateChanged(ChangeEvent changeEvent) {
final boolean selected = titleCheckBox.isSelected();
nodeShapePainter.setVisible(selected);
}
});
shapeTypeCombo = new JComboBox(NodeShapePainter.ShapeType.values());
shapeTypeCombo.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent event) {
nodeShapePainter.setShapeType((NodeShapePainter.ShapeType) shapeTypeCombo.getSelectedItem());
}
});
scaleTypeCombo = new JComboBox(NodeShapePainter.ScaleType.values());
scaleTypeCombo.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent event) {
nodeShapePainter.setScaleType((NodeShapePainter.ScaleType) scaleTypeCombo.getSelectedItem());
}
});
sizeAttributeCombo = new JComboBox();
// AttributeComboHelper & listener set after other controls are created...
colourAttributeCombo = new JComboBox();
JButton setupColourButton = new JButton("Colour");
colourController.setupControls(colourAttributeCombo, setupColourButton);
shapeSizeSpinner = new JSpinner(new SpinnerNumberModel(defaultShapeSize, 0.0, 100.0, 1.0));
shapeSizeSpinner.addChangeListener(new ChangeListener() {
public void stateChanged(ChangeEvent changeEvent) {
double shapeSize = ((Double)shapeSizeSpinner.getValue());
nodeShapePainter.setMaxSize(shapeSize);
}
});
shapeMinSizeSpinner = new JSpinner(new SpinnerNumberModel(10.0, 0.0, 100.0, 1.0));
shapeMinSizeSpinner.addChangeListener(new ChangeListener() {
public void stateChanged(ChangeEvent changeEvent) {
double minSize = ((Double)shapeMinSizeSpinner.getValue());
nodeShapePainter.setMinSize(minSize);
}
});
final JLabel label1 = optionsPanel.addComponentWithLabel("Shape:", shapeTypeCombo);
final JLabel label2 = optionsPanel.addComponentWithLabel("Max size:", shapeSizeSpinner);
final JLabel label3 = optionsPanel.addComponentWithLabel("Size by:", sizeAttributeCombo);
final JLabel label4 = optionsPanel.addComponentWithLabel("Min size:", shapeMinSizeSpinner);
final JLabel label5 = optionsPanel.addComponentWithLabel("Using:", scaleTypeCombo);
optionsPanel.addSeparator();
final JLabel label6 = optionsPanel.addComponentWithLabel("Colour by:", colourAttributeCombo);
final JLabel label7 = optionsPanel.addComponentWithLabel("Setup:", setupColourButton);
new AttributeComboHelper(colourAttributeCombo, treeViewer, "User selection").addListener(new AttributeComboHelperListener() {
@Override
public void attributeComboChanged() {
Decorator colourDecorator = colourController.getColourDecorator(colourAttributeCombo, null);
nodeShapePainter.setColourDecorator(colourDecorator);
}
});
new AttributeComboHelper(sizeAttributeCombo,
treeViewer,
NodeShapePainter.FIXED, true, false).addListener(new AttributeComboHelperListener() {
@Override
public void attributeComboChanged() {
String attribute = (String) sizeAttributeCombo.getSelectedItem();
nodeShapePainter.setSizeAttribute(attribute);
if (attribute != null) {
boolean isSelected = !attribute.equals(NodeShapePainter.FIXED);
label4.setEnabled(isSelected);
shapeMinSizeSpinner.setEnabled(isSelected);
label5.setEnabled(isSelected);
scaleTypeCombo.setEnabled(isSelected);
}
}
});
// only needed if we want to change the options depending on
// the choice of shapeTypeCombo
// shapeTypeCombo.addActionListener(new ActionListener() {
// public void actionPerformed(ActionEvent event) {
// setupOptions();
// optionsPanel.validate();
// }
// });
addComponent(label1);
addComponent(shapeTypeCombo);
addComponent(label2);
addComponent(shapeSizeSpinner);
addComponent(label3);
addComponent(sizeAttributeCombo);
addComponent(label4);
addComponent(shapeMinSizeSpinner);
addComponent(label5);
addComponent(scaleTypeCombo);
addComponent(label6);
addComponent(colourAttributeCombo);
addComponent(label7);
addComponent(setupColourButton);
enableComponents(titleCheckBox.isSelected());
titleCheckBox.addChangeListener(new ChangeListener() {
public void stateChanged(ChangeEvent changeEvent) {
enableComponents(titleCheckBox.isSelected());
}
});
}
private void setupOptions() {
// optionsPanel.removeAll();
fireControllerChanged();
}
public JComponent getTitleComponent() {
return titleCheckBox;
}
public JPanel getPanel() {
return optionsPanel;
}
public boolean isInitiallyVisible() {
return false;
}
public void initialize() {
// nothing to do
}
public void setSettings(Map settings) {
titleCheckBox.setSelected((Boolean)settings.get(NODE_SHAPE_KEY + "." + IS_SHOWN));
shapeTypeCombo.setSelectedItem((NodeShapePainter.ShapeType.valueOf(settings.get(NODE_SHAPE_KEY + "." + SHAPE_TYPE_KEY).toString().toUpperCase())));
scaleTypeCombo.setSelectedItem((NodeShapePainter.ScaleType.valueOf(settings.get(NODE_SHAPE_KEY + "." + SCALE_TYPE_KEY).toString().toUpperCase())));
colourAttributeCombo.setSelectedItem((String) settings.get(NODE_SHAPE_KEY + "." + COLOUR_ATTRIBUTE_KEY));
sizeAttributeCombo.setSelectedItem((String) settings.get(NODE_SHAPE_KEY + "." + SIZE_ATTRIBUTE_KEY));
shapeSizeSpinner.setValue((Double)settings.get(NODE_SHAPE_KEY + "." + SHAPE_SIZE_KEY));
shapeMinSizeSpinner.setValue((Double) settings.get(NODE_SHAPE_KEY + "." + SHAPE_MIN_SIZE_KEY));
}
public void getSettings(Map settings) {
settings.put(NODE_SHAPE_KEY + "." + IS_SHOWN, titleCheckBox.isSelected());
settings.put(NODE_SHAPE_KEY + "." + SHAPE_TYPE_KEY, shapeTypeCombo.getSelectedItem());
settings.put(NODE_SHAPE_KEY + "." + SCALE_TYPE_KEY, scaleTypeCombo.getSelectedItem());
settings.put(NODE_SHAPE_KEY + "." + COLOUR_ATTRIBUTE_KEY, colourAttributeCombo.getSelectedItem());
settings.put(NODE_SHAPE_KEY + "." + SIZE_ATTRIBUTE_KEY, sizeAttributeCombo.getSelectedItem());
settings.put(NODE_SHAPE_KEY + "." + SHAPE_SIZE_KEY, shapeSizeSpinner.getValue());
settings.put(NODE_SHAPE_KEY + "." + SHAPE_MIN_SIZE_KEY, shapeMinSizeSpinner.getValue());
}
private final JCheckBox titleCheckBox;
private final OptionsPanel optionsPanel;
private final JComboBox shapeTypeCombo;
private final JComboBox scaleTypeCombo;
private final JComboBox sizeAttributeCombo;
private final JComboBox colourAttributeCombo;
private final JSpinner shapeSizeSpinner;
private final JSpinner shapeMinSizeSpinner;
public String getTitle() {
return title;
}
private final String title;
private final NodeShapePainter nodeShapePainter;
}
figtree-1.4/src/figtree/treeviewer/painters/ScaleBarPainter.java 0000644 0001750 0001750 00000016652 12047530032 025013 0 ustar osallou osallou /*
* ScaleBarPainter.java
*
* Copyright (C) 2012 Andrew Rambaut
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
package figtree.treeviewer.painters;
import figtree.treeviewer.*;
import figtree.treeviewer.decorators.Decorator;
import jebl.evolution.trees.RootedTree;
import jebl.evolution.trees.Tree;
import jebl.util.Attributable;
import jam.controlpalettes.ControlPalette;
import java.awt.*;
import java.awt.geom.Line2D;
import java.awt.geom.Rectangle2D;
import java.util.Collection;
import java.util.Set;
/**
* @author Andrew Rambaut
* @version $Id: ScaleBarPainter.java 769 2007-08-30 12:14:37Z rambaut $
*/
public class ScaleBarPainter extends LabelPainter implements ScalePainter {
public enum ScaleBarType {
BAR,
AXIS
}
public ScaleBarPainter() {
this(0.0);
}
public ScaleBarPainter(double scaleRange) {
super(null);
this.scaleRange = scaleRange;
type = ScaleBarType.BAR;
}
public void setTreePane(TreePane treePane) {
this.treePane = treePane;
}
public Rectangle2D calibrate(Graphics2D g2, TreePane treePane) {
Font oldFont = g2.getFont();
g2.setFont(getFont());
FontMetrics fm = g2.getFontMetrics();
double labelHeight = fm.getHeight();
preferredWidth = treePane.getTreeScale() * scaleRange;
preferredHeight = labelHeight + topMargin + bottomMargin + scaleBarStroke.getLineWidth();
yOffset = (float) (fm.getAscent() + topMargin + bottomMargin) + scaleBarStroke.getLineWidth();
g2.setFont(oldFont);
return new Rectangle2D.Double(0.0, 0.0, preferredWidth, preferredHeight);
}
public void paint(Graphics2D g2, TreePane treePane, Justification justification, Rectangle2D bounds) {
Font oldFont = g2.getFont();
Paint oldPaint = g2.getPaint();
Stroke oldStroke = g2.getStroke();
if (getBackground() != null) {
g2.setPaint(getBackground());
g2.fill(bounds);
}
if (getBorderPaint() != null && getBorderStroke() != null) {
g2.setPaint(getBorderPaint());
g2.setStroke(getBorderStroke());
g2.draw(bounds);
}
g2.setFont(getFont());
// we don't need accuracy but a nice short number
final String label = Double.toString(scaleRange);
Rectangle2D rect = g2.getFontMetrics().getStringBounds(label, g2);
double x1, x2;
float xOffset;
switch (justification) {
case CENTER:
xOffset = (float) (bounds.getX() + (bounds.getWidth() - rect.getWidth()) / 2.0);
x1 = (bounds.getX() + (bounds.getWidth() - preferredWidth) / 2.0);
x2 = x1 + preferredWidth;
break;
case FLUSH:
case LEFT:
xOffset = (float) bounds.getX();
x1 = bounds.getX();
x2 = x1 + preferredWidth;
break;
case RIGHT:
xOffset = (float) (bounds.getX() + bounds.getWidth() - rect.getWidth());
x2 = bounds.getX() + bounds.getWidth();
x1 = x2 - preferredWidth;
break;
default:
throw new IllegalArgumentException("Unrecognized alignment enum option");
}
g2.setPaint(getForeground());
g2.setStroke(getScaleBarStroke());
g2.draw(new Line2D.Double(x1, bounds.getY() + topMargin, x2, bounds.getY() + topMargin));
g2.drawString(label, xOffset, yOffset + (float) bounds.getY());
g2.setFont(oldFont);
g2.setPaint(oldPaint);
g2.setStroke(oldStroke);
}
public double getPreferredWidth() {
return preferredWidth;
}
public double getPreferredHeight() {
return preferredHeight;
}
public double getHeightBound() {
return preferredHeight + yOffset;
}
public ScaleBarType getType() {
return type;
}
public void setType(ScaleBarType type) {
this.type = type;
firePainterChanged();
}
public BasicStroke getScaleBarStroke() {
return scaleBarStroke;
}
public void setScaleBarStroke(BasicStroke scaleBarStroke) {
this.scaleBarStroke = scaleBarStroke;
firePainterChanged();
}
public double getScaleRange() {
return scaleRange;
}
public void setScaleRange(double scaleRange) {
this.userScaleRange = scaleRange;
calculateScaleRange();
firePainterChanged();
}
public void setAutomaticScale(boolean automaticScale) {
this.automaticScale = automaticScale;
calculateScaleRange();
firePainterChanged();
}
public void setControlPalette(ControlPalette controlPalette) {
// nothing to do
}
public void calculateScaleRange() {
if( !automaticScale && userScaleRange != 0.0 ) {
scaleRange = userScaleRange;
} else {
RootedTree tree = treePane.getTree();
if (tree != null) {
final double treeHeight = tree.getHeight(tree.getRootNode());
if( treeHeight == 0.0 ) {
scaleRange = 0.0;
} else {
double low = treeHeight / 10.0;
double b = -(Math.ceil(Math.log10(low)) - 1);
for(int n = 0; n < 3; ++n) {
double factor = Math.pow(10, b);
double x = ((int)(low * factor) + 1)/factor;
if( n == 2 || x < treeHeight / 5.0 ) {
scaleRange = x;
break;
}
++b;
}
}
}
}
}
public String[] getAttributes() {
return new String[0];
}
public void setupAttributes(Collection trees) {
// nothing to do...
}
public void setDisplayAttribute(String displayAttribute) {
throw new UnsupportedOperationException("setDisplayAttribute not implemented in ScaleBarPainter");
}
public void setTextDecorator(Decorator textDecorator) {
}
public Set getAttributableItems() {
return null;
}
private BasicStroke scaleBarStroke = new BasicStroke(1.0f, BasicStroke.CAP_BUTT, BasicStroke.JOIN_BEVEL);
private ScaleBarType type = ScaleBarType.BAR;
private ScaleAxis axis = new ScaleAxis(ScaleAxis.AT_DATA, ScaleAxis.AT_DATA);
private double scaleRange;
private double topMargin = 4.0;
private double bottomMargin = 4.0;
private double userScaleRange = 0.0;
private boolean automaticScale = true;
private double preferredHeight;
private double preferredWidth;
private float yOffset;
protected TreePane treePane;
} figtree-1.4/src/figtree/treeviewer/painters/NodeBarPainter.java 0000644 0001750 0001750 00000010504 12047530032 024637 0 ustar osallou osallou /*
* NodeBarPainter.java
*
* Copyright (C) 2012 Andrew Rambaut
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
package figtree.treeviewer.painters;
import figtree.treeviewer.TreePane;
import jebl.evolution.graphs.Node;
import jebl.evolution.trees.RootedTree;
import jebl.evolution.trees.Tree;
import java.awt.*;
import java.awt.geom.Line2D;
import java.awt.geom.Rectangle2D;
import java.util.Collection;
import java.util.TreeSet;
/**
* @author Andrew Rambaut
* @version $Id: NodeBarPainter.java 536 2006-11-21 16:10:24Z rambaut $
*/
public class NodeBarPainter extends NodePainter {
public NodeBarPainter() {
}
public void setTreePane(TreePane treePane) {
this.treePane = treePane;
}
public Line2D getNodeBar() {
return nodeBar;
}
public Rectangle2D calibrate(Graphics2D g2, Node node) {
RootedTree tree = treePane.getTree();
nodeBar = null;
Line2D barPath = treePane.getTreeLayoutCache().getNodeShapePath(node);
if (barPath != null) {
double height = tree.getHeight(node);
double upper = height;
double lower = height;
boolean hasBar = false;
Object[] values = (Object[])node.getAttribute(displayAttribute);
if (values != null) {
Object value = values[0];
if (value != null ) {
if (value instanceof Number) {
lower = ((Number)value).doubleValue();
} else {
lower = Double.parseDouble(value.toString());
}
hasBar = true;
} else {
// todo - warn the user somehow?
}
value = values[1];
if (value != null ) {
if (value instanceof Number) {
upper = ((Number)value).doubleValue();
} else {
upper = Double.parseDouble(value.toString());
}
hasBar = true;
} else {
// todo - warn the user somehow?
}
}
if (hasBar) {
// x1,y1 is the node point
double x1 = barPath.getX1();
double y1 = barPath.getY1();
// x2,y2 is 1.0 units higher than the node
double x2 = barPath.getX2();
double y2 = barPath.getY2();
// dx,dy is the change in x,y for one unit of height
double dx = x2 - x1;
double dy = y2 - y1;
double h1 = lower - height;
double h2 = upper - height;
nodeBar = new Line2D.Double(
x1 + (dx * h1), y1 + (dy * h1),
x1 + (dx * h2), y1 + (dy * h2));
}
}
if (nodeBar == null) {
return new Rectangle2D.Double(0,0,0,0);
}
return nodeBar.getBounds2D();
}
public double getPreferredWidth() {
return 1.0;
}
public double getPreferredHeight() {
return 1.0;
}
public double getHeightBound() {
return 1.0;
}
/**
* The bounds define the shape of the nodeBar so just draw it
* @param g2
* @param node
* @param justification
* @param barShape
*/
public void paint(Graphics2D g2, Node node, Justification justification, Shape barShape) {
if (barShape != null) {
Stroke stroke = getStroke();
Shape strokedOutline = stroke.createStrokedShape(barShape);
g2.setPaint(getForeground());
g2.fill(strokedOutline);
g2.setPaint(Color.black);
g2.setStroke(new BasicStroke(0.5F));
g2.draw(strokedOutline);
}
}
/**
* The bounds define the shape of the nodeBar so just draw it
* @param g2
* @param node
* @param justification
* @param bounds
*/
public void paint(Graphics2D g2, Node node, Justification justification, Rectangle2D bounds) {
throw new UnsupportedOperationException("This version of paint is not used in NodeBarPainter");
}
public String getDisplayAttributeName() {
return displayAttribute;
}
public void setDisplayAttribute(String displayAttribute) {
this.displayAttribute = displayAttribute;
firePainterChanged();
}
private String displayAttribute = null;
private TreePane treePane;
private Line2D nodeBar = null;
}
figtree-1.4/src/figtree/treeviewer/painters/LabelPainter.java 0000644 0001750 0001750 00000006531 12047530032 024351 0 ustar osallou osallou /*
* LabelPainter.java
*
* Copyright (C) 2012 Andrew Rambaut
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
package figtree.treeviewer.painters;
import com.sun.tools.corba.se.idl.InterfaceEntry;
import jebl.evolution.trees.Tree;
import jebl.util.Attributable;
import java.awt.*;
import java.text.NumberFormat;
import java.util.Collection;
import java.util.Set;
import figtree.treeviewer.decorators.Decorator;
/**
* @author Andrew Rambaut
* @version $Id: LabelPainter.java 536 2006-11-21 16:10:24Z rambaut $
*/
public abstract class LabelPainter extends AbstractPainter {
public static final String NAMES = "Names";
public static final String NODE_AGES = "Node ages";
public static final String NODE_HEIGHTS = "Node heights (raw)";
public static final String BRANCH_TIMES = "Branch times";
public static final String BRANCH_LENGTHS = "Branch lengths (raw)";
public enum PainterIntent {
NODE,
BRANCH,
TIP,
RANGE
};
protected LabelPainter(PainterIntent intent) {
this.intent = intent;
}
// Abstract
public abstract void setDisplayAttribute(String displayAttribute);
public abstract void setTextDecorator(Decorator textDecorator);
// Getters
public Paint getForeground() {
return foreground;
}
public Paint getBackground() {
return background;
}
public Paint getBorderPaint() {
return borderPaint;
}
public Stroke getBorderStroke() {
return borderStroke;
}
public Font getFont() {
return font;
}
public NumberFormat getNumberFormat() {
return numberFormat;
}
public boolean isVisible() {
return visible;
}
// Setters
public void setBackground(Paint background) {
this.background = background;
firePainterChanged();
}
public void setBorder(Paint borderPaint, Stroke borderStroke) {
this.borderPaint = borderPaint;
this.borderStroke = borderStroke;
firePainterChanged();
}
public void setFont(Font font) {
this.font = font;
firePainterChanged();
}
public void setForeground(Paint foreground) {
this.foreground = foreground;
firePainterChanged();
}
public void setNumberFormat(NumberFormat numberFormat) {
this.numberFormat = numberFormat;
firePainterChanged();
}
public void setVisible(boolean visible) {
this.visible = visible;
firePainterChanged();
}
public PainterIntent getIntent() {
return intent;
}
private Paint foreground = Color.BLACK;
private Paint background = null;
private Paint borderPaint = null;
private Stroke borderStroke = null;
private Font font;
private boolean visible = true;
private NumberFormat numberFormat = null;
private final PainterIntent intent;
}
figtree-1.4/src/figtree/treeviewer/painters/ScaleAxisPainterController.java 0000644 0001750 0001750 00000036420 12162600401 027246 0 ustar osallou osallou /*
* ScaleAxisPainterController.java
*
* Copyright (C) 2012 Andrew Rambaut
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
package figtree.treeviewer.painters;
import figtree.treeviewer.TreeViewerListener;
import jam.controlpalettes.AbstractController;
import jam.panels.OptionsPanel;
import javax.swing.*;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.text.DecimalFormat;
import java.text.NumberFormat;
import java.util.Map;
import java.util.prefs.Preferences;
import figtree.treeviewer.ControllerOptionsPanel;
import figtree.treeviewer.TreeViewer;
import figtree.ui.components.RealNumberField;
/**
* @author Andrew Rambaut
* @version $Id: ScaleAxisPainterController.java 819 2007-10-22 14:42:58Z rambaut $
*/
public class ScaleAxisPainterController extends AbstractController {
private static Preferences PREFS = Preferences.userNodeForPackage(TreeViewer.class);
private static final String SCALE_AXIS_KEY = "scaleAxis";
private static final String FONT_NAME_KEY = "fontName";
private static final String FONT_SIZE_KEY = "fontSize";
private static final String FONT_STYLE_KEY = "fontStyle";
private static final String NUMBER_FORMATTING_KEY = "numberFormatting";
private static final String REVERSE_AXIS_KEY = "reverseAxis";
private static final String SHOW_GRID_KEY = "showGrid";
private static final String AUTOMATIC_SCALE_KEY = "automaticScale";
private static final String MINOR_TICKS_KEY = "minorTicks";
private static final String MAJOR_TICKS_KEY = "majorTicks";
private static final String ORIGIN_KEY = "origin";
private static final String LINE_WIDTH_KEY = "lineWidth";
// private static final String SIGNIFICANT_DIGITS_KEY = "significantDigits";
// The defaults if there is nothing in the preferences
private static String DEFAULT_FONT_NAME = "sansserif";
private static int DEFAULT_FONT_SIZE = 8;
private static int DEFAULT_FONT_STYLE = Font.PLAIN;
private static String DEFAULT_NUMBER_FORMATTING = "#.####";
private static float DEFAULT_LINE_WIDTH = 1.0f;
public ScaleAxisPainterController(final ScaleAxisPainter scaleAxisPainter, final ScaleGridPainter scaleGridPainter, final TreeViewer treeViewer) {
this.scaleAxisPainter = scaleAxisPainter;
this.scaleGridPainter = scaleGridPainter;
final String defaultFontName = PREFS.get(FONT_NAME_KEY, DEFAULT_FONT_NAME);
final int defaultFontStyle = PREFS.getInt(FONT_SIZE_KEY, DEFAULT_FONT_STYLE);
final int defaultFontSize = PREFS.getInt(FONT_STYLE_KEY, DEFAULT_FONT_SIZE);
final String defaultNumberFormatting = PREFS.get(NUMBER_FORMATTING_KEY, DEFAULT_NUMBER_FORMATTING);
float lineWidth = PREFS.getFloat(LINE_WIDTH_KEY, DEFAULT_LINE_WIDTH);
scaleAxisPainter.setFont(new Font(defaultFontName, defaultFontStyle, defaultFontSize));
scaleAxisPainter.setNumberFormat(new DecimalFormat(defaultNumberFormatting));
scaleAxisPainter.setScaleBarStroke(new BasicStroke(lineWidth, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
optionsPanel = new ControllerOptionsPanel(2, 2);
titleCheckBox = new JCheckBox(getTitle());
titleCheckBox.setSelected(scaleAxisPainter.isVisible());
reverseAxisCheck = new JCheckBox("Reverse axis");
reverseAxisCheck.setSelected(false);
showGridCheck = new JCheckBox("Show grid");
showGridCheck.setSelected(true);
optionsPanel.addSpanningComponent(showGridCheck);
autoScaleCheck = new JCheckBox("Automatic scale");
autoScaleCheck.setSelected(true);
majorTicksText = new RealNumberField();
majorTicksText.setValue(1.0);
minorTicksText = new RealNumberField();
minorTicksText.setValue(0.5);
originText = new RealNumberField();
originText.setValue(0.0);
Font font = scaleAxisPainter.getFont();
fontSizeSpinner = new JSpinner(new SpinnerNumberModel(font.getSize(), 0.01, 48, 1));
fontSizeSpinner.addChangeListener(new ChangeListener() {
public void stateChanged(ChangeEvent changeEvent) {
final float size = ((Double) fontSizeSpinner.getValue()).floatValue();
Font font = scaleAxisPainter.getFont().deriveFont(size);
scaleAxisPainter.setFont(font);
}
});
// NumberFormat format = this.scaleAxisPainter.getNumberFormat();
// int digits = format.getMaximumFractionDigits();
// digitsSpinner = new JSpinner(new SpinnerNumberModel(digits, 2, 14, 1));
// final JLabel label5 = optionsPanel.addComponentWithLabel("Sig. Digits:", digitsSpinner);
//
// digitsSpinner.addChangeListener(new ChangeListener() {
// public void stateChanged(ChangeEvent changeEvent) {
// final int digits = (Integer)digitsSpinner.getValue();
// NumberFormat format = scaleAxisPainter.getNumberFormat();
// format.setMaximumFractionDigits(digits);
// scaleAxisPainter.setNumberFormat(format);
// }
// });
lineWeightSpinner = new JSpinner(new SpinnerNumberModel(1.0, 0.01, 48.0, 1.0));
lineWeightSpinner.addChangeListener(new ChangeListener() {
public void stateChanged(ChangeEvent changeEvent) {
float weight = ((Double) lineWeightSpinner.getValue()).floatValue();
scaleAxisPainter.setScaleBarStroke(new BasicStroke(weight, BasicStroke.CAP_BUTT, BasicStroke.JOIN_BEVEL));
}
});
final JLabel label6 = optionsPanel.addComponentWithLabel("Line Weight:", lineWeightSpinner);
optionsPanel.addSpanningComponent(reverseAxisCheck);
optionsPanel.addSpanningComponent(autoScaleCheck);
final JLabel label1 = optionsPanel.addComponentWithLabel("Label spacing:", majorTicksText, true);
final JLabel label2 = optionsPanel.addComponentWithLabel("Tick spacing:", minorTicksText, true);
final JLabel label3 = optionsPanel.addComponentWithLabel("Origin value:", originText, true);
final JLabel label4 = optionsPanel.addComponentWithLabel("Font Size:", fontSizeSpinner);
final boolean isSelected1 = titleCheckBox.isSelected();
final boolean isSelected2 = autoScaleCheck.isSelected();
showGridCheck.setEnabled(isSelected1);
reverseAxisCheck.setEnabled(isSelected1);
autoScaleCheck.setEnabled(isSelected1);
label1.setEnabled(isSelected1 && !isSelected2);
majorTicksText.setEnabled(isSelected1 && !isSelected2);
label2.setEnabled(isSelected1 && !isSelected2);
minorTicksText.setEnabled(isSelected1 && !isSelected2);
label3.setEnabled(isSelected1 && !isSelected2);
originText.setEnabled(isSelected1 && !isSelected2);
label4.setEnabled(isSelected1);
fontSizeSpinner.setEnabled(isSelected1);
// label5.setEnabled(isSelected1);
// digitsSpinner.setEnabled(isSelected1);
label6.setEnabled(isSelected1);
lineWeightSpinner.setEnabled(isSelected1);
titleCheckBox.addChangeListener(new ChangeListener() {
public void stateChanged(ChangeEvent changeEvent) {
final boolean isSelected1 = titleCheckBox.isSelected();
final boolean isSelected2 = autoScaleCheck.isSelected();
showGridCheck.setEnabled(isSelected1);
reverseAxisCheck.setEnabled(isSelected1);
autoScaleCheck.setEnabled(isSelected1);
label1.setEnabled(isSelected1 && !isSelected2);
majorTicksText.setEnabled(isSelected1 && !isSelected2);
label2.setEnabled(isSelected1 && !isSelected2);
minorTicksText.setEnabled(isSelected1 && !isSelected2);
label3.setEnabled(isSelected1 && !isSelected2);
originText.setEnabled(isSelected1 && !isSelected2);
label4.setEnabled(isSelected1);
fontSizeSpinner.setEnabled(isSelected1);
// label5.setEnabled(isSelected1);
// digitsSpinner.setEnabled(isSelected1);
label6.setEnabled(isSelected1);
lineWeightSpinner.setEnabled(isSelected1);
scaleAxisPainter.setVisible(isSelected1);
scaleGridPainter.setVisible(isSelected1);
}
});
reverseAxisCheck.addChangeListener(new ChangeListener() {
public void stateChanged(ChangeEvent changeEvent) {
scaleAxisPainter.setAxisReversed(reverseAxisCheck.isSelected());
}
});
showGridCheck.addChangeListener(new ChangeListener() {
public void stateChanged(ChangeEvent changeEvent) {
scaleGridPainter.setVisible(showGridCheck.isSelected());
}
});
autoScaleCheck.addChangeListener(new ChangeListener() {
public void stateChanged(ChangeEvent changeEvent) {
if (autoScaleCheck.isSelected()) {
scaleAxisPainter.setAutomatic(true);
majorTicksText.setValue(scaleAxisPainter.getMajorTickSpacing());
minorTicksText.setValue(scaleAxisPainter.getMinorTickSpacing());
originText.setValue(scaleAxisPainter.getAxisOrigin());
label1.setEnabled(false);
majorTicksText.setEnabled(false);
label2.setEnabled(false);
minorTicksText.setEnabled(false);
label3.setEnabled(false);
originText.setEnabled(false);
} else {
label1.setEnabled(true);
minorTicksText.setEnabled(true);
label2.setEnabled(true);
majorTicksText.setEnabled(true);
label3.setEnabled(true);
originText.setEnabled(true);
double majorTickSpacing = getValue(majorTicksText, 1.0);
double minorTickSpacing = getValue(minorTicksText, 0.5);
double originValue = getValue(originText, 0.0);
scaleAxisPainter.setAutomatic(false);
scaleAxisPainter.setAxisSpacing(majorTickSpacing, minorTickSpacing);
scaleAxisPainter.setAxisOrigin(originValue);
}
}
});
ChangeListener listener = new ChangeListener() {
@Override
public void stateChanged(ChangeEvent changeEvent) {
if (!autoScaleCheck.isSelected()) {
double majorTickSpacing = getValue(majorTicksText, 1.0);
double minorTickSpacing = getValue(minorTicksText, 0.5);
scaleAxisPainter.setAxisSpacing(majorTickSpacing, minorTickSpacing);
}
}
};
minorTicksText.addChangeListener(listener);
majorTicksText.addChangeListener(listener);
originText.addChangeListener(new ChangeListener() {
public void stateChanged(ChangeEvent changeEvent) {
if (!autoScaleCheck.isSelected()) {
double originValue = getValue(originText, 0.0);
scaleAxisPainter.setAxisOrigin(originValue);
}
}
});
treeViewer.addTreeViewerListener(new TreeViewerListener() {
public void treeChanged() {
scaleAxisPainter.firePainterChanged();
}
public void treeSettingsChanged() {
// nothing to do
}
});
}
private double getValue(RealNumberField field, double defaultValue) {
Double value = field.getValue();
return (value != null ? value : defaultValue);
}
public JComponent getTitleComponent() {
return titleCheckBox;
}
public JPanel getPanel() {
return optionsPanel;
}
public boolean isInitiallyVisible() {
return false;
}
public void initialize() {
// force a toggle of the checkbox
autoScaleCheck.setSelected(false);
autoScaleCheck.setSelected(true);
}
public void setSettings(Map settings) {
titleCheckBox.setSelected((Boolean)settings.get(SCALE_AXIS_KEY + "." + IS_SHOWN));
reverseAxisCheck.setSelected((Boolean)settings.get(SCALE_AXIS_KEY + "." + REVERSE_AXIS_KEY));
showGridCheck.setSelected((Boolean)settings.get(SCALE_AXIS_KEY + "." + SHOW_GRID_KEY));
// minorTicksText.setValue((Double)settings.get(SCALE_AXIS_KEY + "." + MINOR_TICKS_KEY));
majorTicksText.setValue((Double)settings.get(SCALE_AXIS_KEY + "." + MAJOR_TICKS_KEY));
originText.setValue((Double)settings.get(SCALE_AXIS_KEY + "." + ORIGIN_KEY));
autoScaleCheck.setSelected((Boolean)settings.get(SCALE_AXIS_KEY + "." + AUTOMATIC_SCALE_KEY));
// scaleAxisPainter.setAutomaticScale(autoScaleCheck.isSelected());
fontSizeSpinner.setValue((Double)settings.get(SCALE_AXIS_KEY + "." + FONT_SIZE_KEY));
// digitsSpinner.setValue((Integer)settings.get(SCALE_AXIS_KEY + "." + SIGNIFICANT_DIGITS_KEY));
lineWeightSpinner.setValue((Double)settings.get(SCALE_AXIS_KEY + "." + LINE_WIDTH_KEY));
}
public void getSettings(Map settings) {
settings.put(SCALE_AXIS_KEY + "." + IS_SHOWN, titleCheckBox.isSelected());
settings.put(SCALE_AXIS_KEY + "." + REVERSE_AXIS_KEY, reverseAxisCheck.isSelected());
settings.put(SCALE_AXIS_KEY + "." + SHOW_GRID_KEY, showGridCheck.isSelected());
settings.put(SCALE_AXIS_KEY + "." + AUTOMATIC_SCALE_KEY, autoScaleCheck.isSelected());
// settings.put(SCALE_AXIS_KEY + "." + MINOR_TICKS_KEY, minorTicksText.getValue());
settings.put(SCALE_AXIS_KEY + "." + MAJOR_TICKS_KEY, majorTicksText.getValue());
settings.put(SCALE_AXIS_KEY + "." + ORIGIN_KEY, originText.getValue());
settings.put(SCALE_AXIS_KEY + "." + FONT_SIZE_KEY, fontSizeSpinner.getValue());
// settings.put(SCALE_AXIS_KEY + "." + SIGNIFICANT_DIGITS_KEY, digitsSpinner.getValue());
settings.put(SCALE_AXIS_KEY + "." + LINE_WIDTH_KEY, lineWeightSpinner.getValue());
}
private final JCheckBox titleCheckBox;
private final OptionsPanel optionsPanel;
private final JCheckBox reverseAxisCheck;
private final JCheckBox showGridCheck;
private final JCheckBox autoScaleCheck;
private final RealNumberField minorTicksText;
private final RealNumberField majorTicksText;
private final RealNumberField originText;
private final JSpinner fontSizeSpinner;
// private final JSpinner digitsSpinner;
private final JSpinner lineWeightSpinner;
public String getTitle() {
return "Scale Axis";
}
private final ScaleAxisPainter scaleAxisPainter;
private final ScaleGridPainter scaleGridPainter;
} figtree-1.4/src/figtree/treeviewer/painters/LegendPainter.java 0000644 0001750 0001750 00000020206 12162510216 024523 0 ustar osallou osallou /*
* LegendPainter.java
*
* Copyright (C) 2012 Andrew Rambaut
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
package figtree.treeviewer.painters;
import figtree.treeviewer.AttributeColourController;
import figtree.treeviewer.TreePane;
import figtree.treeviewer.decorators.*;
import jam.controlpalettes.ControlPalette;
import java.awt.*;
import java.awt.geom.Line2D;
import java.awt.geom.Rectangle2D;
/**
* @author Andrew Rambaut
* @version $Id$
*/
public class LegendPainter extends LabelPainter implements ScalePainter {
public final static int CONTINUOUS_LENGTH = 320;
public LegendPainter(AttributeColourController attributeColourController) {
super(null);
this.attributeColourController = attributeColourController;
}
public void setTreePane(TreePane treePane) {
this.treePane = treePane;
}
public Decorator getBorderDecorator() {
return borderDecorator;
}
public void setBorderDecorator(Decorator borderDecorator) {
this.borderDecorator = borderDecorator;
firePainterSettingsChanged();
}
public Decorator getTextDecorator() {
return textDecorator;
}
public void setTextDecorator(Decorator textDecorator) {
this.textDecorator = textDecorator;
firePainterSettingsChanged();
}
public Rectangle2D calibrate(Graphics2D g2, TreePane treePane) {
final Font oldFont = g2.getFont();
if (textDecorator != null) {
g2.setFont(textDecorator.getFont(getFont()));
} else {
g2.setFont(getFont());
}
FontMetrics fm = g2.getFontMetrics();
preferredHeight = fm.getHeight();
preferredWidth = 0;
if (colourDecorator instanceof DiscreteColourDecorator) {
for (Object value : ((DiscreteColourDecorator)colourDecorator).getValues()) {
Rectangle2D rect = fm.getStringBounds(value.toString(), g2);
if (rect.getWidth() > preferredWidth) {
preferredWidth = rect.getWidth();
}
}
} else if (colourDecorator instanceof ContinuousColourDecorator){
// draw a continuous legend
ContinuousScale scale = ((ContinuousColourDecorator)colourDecorator).getContinuousScale();
double min = scale.getMinValue();
double max = scale.getMaxValue();
Rectangle2D rect = g2.getFontMetrics().getStringBounds(getNumberFormat().format(max), g2);
if (rect.getWidth() > preferredWidth) {
preferredWidth = rect.getWidth();
}
rect = g2.getFontMetrics().getStringBounds(getNumberFormat().format(min), g2);
if (rect.getWidth() > preferredWidth) {
preferredWidth = rect.getWidth();
}
} else if (colourDecorator != null) {
throw new IllegalArgumentException("Unrecognized ColourDecorator class");
}
g2.setFont(oldFont);
preferredWidth += insets.left + insets.right + fm.getHeight() * 2;
return new Rectangle2D.Double(0.0, 0.0, preferredWidth, preferredHeight);
}
public void paint(Graphics2D g2, TreePane treePane, Justification justification, Rectangle2D bounds) {
if (colourDecorator == null) {
return;
}
String attribute = colourDecorator.getAttributeName();
Font oldFont = g2.getFont();
Paint oldPaint = g2.getPaint();
Stroke oldStroke = g2.getStroke();
if (getBackground() != null) {
g2.setPaint(getBackground());
g2.fill(bounds);
}
if (getBorderPaint() != null && getBorderStroke() != null) {
g2.setPaint(getBorderPaint());
g2.setStroke(getBorderStroke());
g2.draw(bounds);
}
g2.setFont(getFont());
Rectangle2D labelBounds = g2.getFontMetrics().getStringBounds("ty", g2);
// vertical inset
float y = (float)(insets.top);
float yOffset = (float)g2.getFontMetrics().getAscent();
float xOffset1 = (float)(insets.left);
float yDelta = (float)labelBounds.getHeight() * 1.5F;
float xOffset2 = (float)(insets.left + labelBounds.getHeight() * 2);
g2.setPaint(Color.BLACK);
g2.drawString(attribute, xOffset1, y + yOffset);
y += yDelta;
if (colourDecorator instanceof DiscreteColourDecorator) {
for (Object value : ((DiscreteColourDecorator)colourDecorator).getValues()) {
g2.setPaint(((DiscreteColourDecorator)colourDecorator).getColor(value));
Rectangle2D rect = new Rectangle2D.Double(xOffset1, y, labelBounds.getHeight(), labelBounds.getHeight());
g2.fill(rect);
g2.drawString(value.toString(), xOffset2, y + yOffset);
y += yDelta;
}
} else if (colourDecorator instanceof ContinuousColourDecorator){
// draw a continuous legend
ContinuousScale scale = ((ContinuousColourDecorator)colourDecorator).getContinuousScale();
double min = scale.getMinValue();
double max = scale.getMaxValue();
double delta = (max - min) / CONTINUOUS_LENGTH;
final String label = "0.0";
labelBounds = g2.getFontMetrics().getStringBounds(label, g2);
float y0 = y;
double v = max;
for (int i = 0; i < CONTINUOUS_LENGTH; i++) {
g2.setPaint(((ContinuousColourDecorator)colourDecorator).getColourForValue(v));
Rectangle2D rect = new Rectangle2D.Double(xOffset1, y, labelBounds.getHeight(), 1);
g2.fill(rect);
y += 1;
v -= delta;
}
g2.setPaint(Color.BLACK);
g2.drawString(getNumberFormat().format(max), xOffset2, y0 + (yOffset / 2));
g2.drawString(getNumberFormat().format(min), xOffset2, y + (yOffset / 2));
Line2D line = new Line2D.Double(xOffset1, y0, xOffset1 + labelBounds.getHeight() * 1.25, y0);
g2.draw(line);
line = new Line2D.Double(xOffset1, y, xOffset1 + labelBounds.getHeight() * 1.25, y);
g2.draw(line);
line = new Line2D.Double(xOffset1, y0, xOffset1, y);
g2.draw(line);
} else {
throw new IllegalArgumentException("Unrecognized ColourDecorator class");
}
g2.setFont(oldFont);
g2.setPaint(oldPaint);
g2.setStroke(oldStroke);
}
public double getPreferredWidth() {
return preferredWidth;
}
public double getPreferredHeight() {
return preferredHeight;
}
public double getHeightBound() {
return preferredHeight;
}
public void setColourDecorator(ColourDecorator colourDecorator) {
this.colourDecorator = colourDecorator;
firePainterChanged();
}
public void setControlPalette(ControlPalette controlPalette) {
// nothing to do
}
protected ColourDecorator colourDecorator;
private double preferredHeight;
private double preferredWidth;
protected final AttributeColourController attributeColourController;
protected TreePane treePane;
private Decorator textDecorator = null;
private Decorator borderDecorator = null;
private Insets insets = new Insets(8, 8, 8, 8);
@Override
public void setDisplayAttribute(String displayAttribute) {
throw new UnsupportedOperationException("setDisplayAttribute not implmented - use setColourDecorator directly");
}
} figtree-1.4/src/figtree/treeviewer/painters/CharactersPainter.java 0000644 0001750 0001750 00000014557 12047530032 025420 0 ustar osallou osallou /*
* CharactersPainter.java
*
* Copyright (C) 2012 Andrew Rambaut
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
package figtree.treeviewer.painters;
import jebl.evolution.alignments.Alignment;
import jebl.evolution.graphs.Node;
import jebl.evolution.sequences.AminoAcids;
import jebl.evolution.sequences.Sequence;
import jebl.evolution.trees.Tree;
import figtree.treeviewer.painters.BasicLabelPainter;
import java.awt.*;
import java.awt.geom.Rectangle2D;
/**
* @author Andrew Rambaut
* @version $Id$
*/
public class CharactersPainter extends BasicLabelPainter {
public CharactersPainter(Alignment characters) {
super(BasicLabelPainter.PainterIntent.TIP);
this.characters = characters;
paints[AminoAcids.A_STATE.getIndex()] = new Color(204, 255, 255);
paints[AminoAcids.C_STATE.getIndex()] = new Color(0, 255, 255);
paints[AminoAcids.D_STATE.getIndex()] = new Color(255, 204, 153);
paints[AminoAcids.E_STATE.getIndex()] = new Color(255, 204, 0);
paints[AminoAcids.F_STATE.getIndex()] = new Color(0, 204, 255);
paints[AminoAcids.G_STATE.getIndex()] = new Color(0, 255, 0);
paints[AminoAcids.H_STATE.getIndex()] = new Color(255, 255, 153);
paints[AminoAcids.I_STATE.getIndex()] = new Color(0, 0, 128);
paints[AminoAcids.K_STATE.getIndex()] = new Color(198, 66, 0);
paints[AminoAcids.L_STATE.getIndex()] = new Color(51, 102, 255);
paints[AminoAcids.M_STATE.getIndex()] = new Color(153, 204, 255);
paints[AminoAcids.N_STATE.getIndex()] = new Color(255, 153, 0);
paints[AminoAcids.P_STATE.getIndex()] = new Color(255, 255, 0);
paints[AminoAcids.Q_STATE.getIndex()] = new Color(255, 102, 0);
paints[AminoAcids.R_STATE.getIndex()] = new Color(230, 6, 6);
paints[AminoAcids.S_STATE.getIndex()] = new Color(204, 255, 153);
paints[AminoAcids.T_STATE.getIndex()] = new Color(0, 255, 153);
paints[AminoAcids.V_STATE.getIndex()] = new Color(0, 0, 255);
paints[AminoAcids.W_STATE.getIndex()] = new Color(204, 153, 255);
paints[AminoAcids.Y_STATE.getIndex()] = new Color(204, 255, 204);
paints[AminoAcids.B_STATE.getIndex()] = Color.DARK_GRAY;
paints[AminoAcids.Z_STATE.getIndex()] = Color.DARK_GRAY;
paints[AminoAcids.X_STATE.getIndex()] = Color.GRAY;
paints[AminoAcids.UNKNOWN_STATE.getIndex()] = Color.GRAY;
paints[AminoAcids.STOP_STATE.getIndex()] = Color.GRAY;
paints[AminoAcids.GAP_STATE.getIndex()] = Color.GRAY;
};
public Rectangle2D calibrate(Graphics2D g2, Node node) {
super.calibrate(g2, node);
int siteCount = characters.getSiteCount();
blockSize = super.getPreferredHeight() / 2;
blockGap = blockSize / 2;
width = (siteCount * (blockSize + blockGap)) + blockGap + blockGap;
return new Rectangle2D.Double(0.0, 0.0, getPreferredWidth(), getPreferredHeight());
}
public double getPreferredWidth() {
return super.getPreferredWidth() + width;
}
public void paint(Graphics2D g2, Node node, Justification justification, Rectangle2D bounds) {
Tree tree = getTree();
Stroke oldStroke = g2.getStroke();
Paint oldPaint = g2.getPaint();
float yOffset = (float)getPreferredHeight() / 2;
switch (justification) {
case FLUSH:
case LEFT: {
super.paint(g2, node, justification,
new Rectangle2D.Double(bounds.getX() + width, bounds.getY(), bounds.getWidth() - width, bounds.getHeight()));
Sequence sequence = characters.getSequence(tree.getTaxon(node));
if (sequence != null) {
double x = blockGap;
for (int state : sequence.getStateIndices()) {
if (state != AminoAcids.GAP_STATE.getIndex()) {
// Now create a bounds for the label
Rectangle2D block = new Rectangle2D.Double(
x, yOffset - (blockSize / 2.0),
blockSize, blockSize);
g2.setPaint(getStatePaint(state));
g2.fill(block);
}
x += blockSize + blockGap;
}
}
} break;
case RIGHT: {
super.paint(g2, node, justification,
new Rectangle2D.Double(bounds.getX(), bounds.getY(), bounds.getWidth() - width, bounds.getHeight()));
Sequence sequence = characters.getSequence(tree.getTaxon(node));
if (sequence != null) {
double x = getPreferredWidth() - blockGap - blockSize;
for (int state : sequence.getStateIndices()) {
// Now create a bounds for the label
Rectangle2D block = new Rectangle2D.Double(
x, yOffset - (blockSize / 2.0),
blockSize, blockSize);
g2.setPaint(getStatePaint(state));
g2.fill(block);
x -= (blockSize + blockGap);
}
}
} break;
default:
throw new IllegalArgumentException("Unrecognized alignment enum option");
}
g2.setStroke(oldStroke);
g2.setPaint(oldPaint);
}
private Alignment characters = null;
private double width;
private double blockSize = 6;
private double blockGap = 2;
Paint[] paints = new Paint[AminoAcids.getStateCount()];
public Paint getStatePaint(int stateIndex) {
return paints[stateIndex];
}
}
figtree-1.4/src/figtree/treeviewer/painters/Painter.java 0000644 0001750 0001750 00000004527 12047530032 023414 0 ustar osallou osallou /*
* Painter.java
*
* Copyright (C) 2012 Andrew Rambaut
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
package figtree.treeviewer.painters;
import figtree.treeviewer.TreePane;
import java.awt.*;
import java.awt.geom.Rectangle2D;
/**
* A painter draws a particular decoration onto the tree within a
* rectangle.
* @author Andrew Rambaut
* @version $Id: Painter.java 370 2006-06-29 18:57:56Z rambaut $
*/
public interface Painter {
public enum Orientation {
TOP,
LEFT,
BOTTOM,
RIGHT
}
public enum Justification {
FLUSH,
LEFT,
RIGHT,
CENTER
}
/**
* Called when the painter is installed in a TreePane. Gives the
* painter a handle on the TreePane so that it get additional
* information.
* @param treePane
*/
void setTreePane(TreePane treePane);
/**
* If this is false then the painter should not be displayed.
* @return is visible?
*/
boolean isVisible();
/**
* Called to calibrate the painters for a given graphics context. This should
* work out the preferred width and height (perhaps for the current font).
* @param g2
* @param item
*/
Rectangle2D calibrate(Graphics2D g2, T item);
/**
* Called to actually paint into the current graphics context. The painter should
* respect the bounds.
* @param g2
* @param item
* @param justification
* @param bounds
*/
void paint(Graphics2D g2, T item, Justification justification, Rectangle2D bounds);
double getPreferredWidth();
double getPreferredHeight();
double getHeightBound();
void addPainterListener(PainterListener listener);
void removePainterListener(PainterListener listener);
}
figtree-1.4/src/figtree/treeviewer/treelayouts/ 0000755 0001750 0001750 00000000000 12163040540 021671 5 ustar osallou osallou figtree-1.4/src/figtree/treeviewer/treelayouts/RadialTreeLayout.java 0000644 0001750 0001750 00000024635 12025066670 025771 0 ustar osallou osallou package figtree.treeviewer.treelayouts;
import jebl.evolution.graphs.Graph;
import jebl.evolution.graphs.Node;
import jebl.evolution.trees.RootedTree;
import java.awt.*;
import java.awt.geom.*;
import java.util.List;
/**
* @author Andrew Rambaut
* @version $Id: RadialTreeLayout.java 780 2007-09-09 09:46:01Z rambaut $
*/
public class RadialTreeLayout extends AbstractTreeLayout {
private double spread = 0.0;
public AxisType getXAxisType() {
return AxisType.CONTINUOUS;
}
public AxisType getYAxisType() {
return AxisType.CONTINUOUS;
}
public boolean isShowingRootBranch() {
return false;
}
public double getTotalRootLength() {
return 0.0;
}
public void setFishEye(double fishEye) {
// do nothing
}
public void setPointOfInterest(double x, double y) {
// do nothing
}
public boolean isShowingColouring() {
return (branchColouringAttribute != null);
}
public boolean maintainAspectRatio() {
return true;
}
public double getHeightOfPoint(Point2D point) {
throw new UnsupportedOperationException("Method getHeightOfPoint() is not supported in this TreeLayout");
}
public Line2D getAxisLine(double height) {
throw new UnsupportedOperationException("Method getHeightLine() is not supported in this TreeLayout");
}
public Shape getHeightArea(double height1, double height2) {
throw new UnsupportedOperationException("Method getHeightArea() is not supported in this TreeLayout");
}
public double getSpread() {
return spread;
}
public void setSpread(double spread) {
this.spread = spread;
fireTreeLayoutChanged();
}
public void layout(RootedTree tree, TreeLayoutCache cache) {
cache.clear();
try {
final Node root = tree.getRootNode();
constructNode(tree, root, 0.0, Math.PI * 2, 0.0, 0.0, 0.0, cache);
// Haven't been able to make these look nice....
// constructNodeAreas(tree, root, new Area(), cache);
} catch (Graph.NoEdgeException e) {
e.printStackTrace();
}
}
private Point2D constructNode(RootedTree tree, Node node,
double angleStart, double angleFinish, double xPosition,
double yPosition, double length,
TreeLayoutCache cache) throws Graph.NoEdgeException {
final double branchAngle = (angleStart + angleFinish) / 2.0;
final double directionX = Math.cos(branchAngle);
final double directionY = Math.sin(branchAngle);
Point2D nodePoint = new Point2D.Double(xPosition + (length * directionX), yPosition + (length * directionY));
// System.out.println("Node: " + Utils.DEBUGsubTreeRep(tree, node) + " at " + nodePoint);
if (!tree.isExternal(node)) {
// Not too clear how to do hilighting for radial trees so leave it out...
// if (hilightAttributeName != null && node.getAttribute(hilightAttributeName) != null) {
// constructHilight(tree, node, angleStart, angleFinish, xPosition, yPosition, length, cache);
// }
List children = tree.getChildren(node);
int[] leafCounts = new int[children.size()];
int sumLeafCount = 0;
int i = 0;
for (Node child : children) {
leafCounts[i] = jebl.evolution.trees.Utils.getExternalNodeCount(tree, child);
sumLeafCount += leafCounts[i];
i++;
}
double span = (angleFinish - angleStart);
if (!tree.isRoot(node)) {
span *= 1.0 + (spread / 10.0);
angleStart = branchAngle - (span / 2.0);
angleFinish = branchAngle + (span / 2.0);
}
double a2 = angleStart;
boolean rotate = false;
if (node.getAttribute("!rotate") != null &&
((Boolean)node.getAttribute("!rotate"))) {
rotate = true;
}
for(i = 0; i < children.size(); ++i) {
int index = i;
if (rotate) {
index = children.size() - i - 1;
}
Node child = children.get(index);
final double childLength = tree.getLength(child);
double a1 = a2;
a2 = a1 + (span * leafCounts[index] / sumLeafCount);
Point2D childPoint = constructNode(tree, child, a1, a2,
nodePoint.getX(), nodePoint.getY(), childLength, cache);
Line2D branchLine = new Line2D.Double(
childPoint.getX(), childPoint.getY(),
nodePoint.getX(), nodePoint.getY()
);
Object[] colouring = null;
if (branchColouringAttribute != null) {
colouring = (Object[])child.getAttribute(branchColouringAttribute);
}
if (colouring != null) {
// If there is a colouring, then we break the path up into
// segments. This should allow use to iterate along the segments
// and colour them as we draw them.
float nodeHeight = (float) tree.getHeight(node);
float childHeight = (float) tree.getHeight(child);
float x1 = (float)childPoint.getX();
float y1 = (float)childPoint.getY();
float x0 = (float)nodePoint.getX();
float y0 = (float)nodePoint.getY();
GeneralPath branchPath = new GeneralPath();
// to help this, we are going to draw the branch backwards
branchPath.moveTo(x1, y1);
float interval = 0.0F;
for (int j = 0; j < colouring.length - 1; j+=2) {
// float height = ((Number)colouring[j+1]).floatValue();
// float p = (height - childHeight) / (nodeHeight - childHeight);
interval += ((Number)colouring[j+1]).floatValue();
float p = interval / (nodeHeight - childHeight);
float x = x1 + ((x0 - x1) * p);
float y = y1 + ((y0 - y1) * p);
branchPath.lineTo(x, y);
}
branchPath.lineTo(x0, y0);
// add the branchPath to the map of branch paths
cache.branchPaths.put(child, branchPath);
} else {
// add the branchLine to the map of branch paths
cache.branchPaths.put(child, branchLine);
}
cache.branchLabelPaths.put(child, (Line2D)branchLine.clone());
}
Point2D nodeLabelPoint = new Point2D.Double(xPosition + ((length + 1.0) * directionX),
yPosition + ((length + 1.0) * directionY));
Line2D nodeLabelPath = new Line2D.Double(nodePoint, nodeLabelPoint);
cache.nodeLabelPaths.put(node, nodeLabelPath);
} else {
Point2D taxonPoint = new Point2D.Double(xPosition + ((length + 1.0) * directionX),
yPosition + ((length + 1.0) * directionY));
Line2D taxonLabelPath = new Line2D.Double(nodePoint, taxonPoint);
cache.tipLabelPaths.put(node, taxonLabelPath);
}
Point2D nodeShapePoint = new Point2D.Double(xPosition + ((length - 1.0) * directionX),
yPosition + ((length - 1.0) * directionY));
Line2D nodeShapePath = new Line2D.Double(nodePoint, nodeShapePoint);
cache.nodeShapePaths.put(node, nodeShapePath);
// add the node point to the map of node points
cache.nodePoints.put(node, nodePoint);
return nodePoint;
}
private void constructNodeAreas(final RootedTree tree, final Node node, final Area parentNodeArea, TreeLayoutCache cache) {
if (!tree.isExternal(node)) {
List children = tree.getChildren(node);
boolean rotate = false;
if (node.getAttribute("!rotate") != null &&
((Boolean)node.getAttribute("!rotate"))) {
rotate = true;
}
int index = (rotate ? children.size() - 1 : 0);
Node child1 = children.get(index);
Area childArea1 = new Area();
constructNodeAreas(tree, child1, childArea1, cache);
index = (rotate ? 0 : children.size() - 1);
Node child2 = children.get(index);
Area childArea2 = new Area();
constructNodeAreas(tree, child2, childArea2, cache);
GeneralPath nodePath = new GeneralPath();
Line2D line1 = (Line2D)cache.getBranchPath(child1);
Line2D line2 = (Line2D)cache.getBranchPath(child2);
nodePath.moveTo(line2.getX1(), line2.getY1());
nodePath.lineTo(line2.getX2(), line2.getY2());
nodePath.lineTo(line1.getX1(), line1.getY1());
nodePath.closePath();
Area nodeArea = new Area(nodePath);
parentNodeArea.add(nodeArea);
parentNodeArea.add(childArea1);
parentNodeArea.add(childArea2);
nodeArea.subtract(childArea1);
nodeArea.subtract(childArea2);
cache.nodeAreas.put(node, nodeArea);
}
}
private void constructHilight(RootedTree tree, Node node, double angleStart, double angleFinish, double xPosition,
double yPosition, double length, TreeLayoutCache cache) {
Object[] values = (Object[])node.getAttribute(hilightAttributeName);
int tipCount = (Integer)values[0];
double tipHeight = (Double)values[1];
double height = tree.getHeight(node);
GeneralPath hilightShape = new GeneralPath();
final double branchAngle = (angleStart + angleFinish) / 2.0;
float x0 = (float)(xPosition + (0.5 * length * Math.cos(branchAngle)));
float y0 = (float)(yPosition + (0.5 * length * Math.sin(branchAngle)));
float x1 = (float)(x0 + (tipHeight * Math.cos(angleStart)));
float y1 = (float)(y0 + (tipHeight * Math.sin(angleStart)));
float x2 = (float)(x0 + (tipHeight * Math.cos(angleFinish)));
float y2 = (float)(y0 + (tipHeight * Math.sin(angleFinish)));
hilightShape.moveTo(x0, y0);
hilightShape.lineTo(x1, y1);
hilightShape.lineTo(x2, y2);
hilightShape.lineTo(x0, y0);
hilightShape.closePath();
// add the collapsedShape to the map of branch paths
cache.hilightNodes.add(node);
cache.hilightShapes.put(node, hilightShape);
}
} figtree-1.4/src/figtree/treeviewer/treelayouts/RectilinearTreeLayoutController.java 0000644 0001750 0001750 00000010372 12017705351 031070 0 ustar osallou osallou package figtree.treeviewer.treelayouts;
import jam.controlpalettes.AbstractController;
import jam.panels.OptionsPanel;
import javax.swing.*;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Map;
import figtree.treeviewer.ControllerOptionsPanel;
/**
* @author Andrew Rambaut
* @version $Id: RectilinearTreeLayoutController.java 819 2007-10-22 14:42:58Z rambaut $
*/
public class RectilinearTreeLayoutController extends AbstractController {
private static final String RECTILINEAR_LAYOUT_KEY = "rectilinearLayout";
private static final String ROOT_LENGTH_KEY = "rootLength";
private static final String CURVATURE_KEY = "curvature";
private static final String ALIGN_TIP_LABELS_KEY = "alignTipLabels";
public RectilinearTreeLayoutController(final RectilinearTreeLayout treeLayout) {
this.treeLayout = treeLayout;
titleLabel = new JLabel("Rectangular Layout");
optionsPanel = new ControllerOptionsPanel(0, 0);
final int sliderMax = 10000;
rootLengthSlider = new JSlider(SwingConstants.HORIZONTAL, 0, sliderMax, 0);
rootLengthSlider.setOpaque(false);
rootLengthSlider.setValue((int) (treeLayout.getRootLengthProportion() * sliderMax));
//rootLengthSlider.setMajorTickSpacing(rootLengthSlider.getMaximum() / 5);
// rootLengthSlider.setPaintTicks(true);
rootLengthSlider.addChangeListener(new ChangeListener() {
public void stateChanged(ChangeEvent changeEvent) {
double value = rootLengthSlider.getValue();
treeLayout.setRootLengthProportion(value / sliderMax);
}
});
optionsPanel.addComponentWithLabel("Root Length:", rootLengthSlider, true);
curvatureSlider = new JSlider(SwingConstants.HORIZONTAL, 0, sliderMax, 0);
curvatureSlider.setOpaque(false);
curvatureSlider.setValue((int) (treeLayout.getCurvature() * sliderMax));
//curvatureSlider.setMajorTickSpacing(curvatureSlider.getMaximum() / 5);
// curvatureSlider.setPaintTicks(true);
curvatureSlider.addChangeListener(new ChangeListener() {
public void stateChanged(ChangeEvent changeEvent) {
double value = curvatureSlider.getValue();
treeLayout.setCurvature(value / sliderMax);
}
});
optionsPanel.addComponentWithLabel("Curvature:", curvatureSlider, true);
alignTipLabelsCheck = new JCheckBox("Align Tip Labels");
alignTipLabelsCheck.setOpaque(false);
alignTipLabelsCheck.setSelected(treeLayout.isAlignTipLabels());
alignTipLabelsCheck.addChangeListener(new ChangeListener() {
public void stateChanged(ChangeEvent changeEvent) {
treeLayout.setAlignTipLabels(alignTipLabelsCheck.isSelected());
}
});
optionsPanel.addSpanningComponent(alignTipLabelsCheck);
}
public JComponent getTitleComponent() {
return titleLabel;
}
public JPanel getPanel() {
return optionsPanel;
}
public boolean isInitiallyVisible() {
return false;
}
public void initialize() {
// nothing to do
}
public void setSettings(Map settings) {
rootLengthSlider.setValue((Integer) settings.get(RECTILINEAR_LAYOUT_KEY + "." + ROOT_LENGTH_KEY));
curvatureSlider.setValue((Integer) settings.get(RECTILINEAR_LAYOUT_KEY + "." + CURVATURE_KEY));
alignTipLabelsCheck.setSelected((Boolean) settings.get(RECTILINEAR_LAYOUT_KEY + "." + ALIGN_TIP_LABELS_KEY));
}
public void getSettings(Map settings) {
settings.put(RECTILINEAR_LAYOUT_KEY + "." + ROOT_LENGTH_KEY, rootLengthSlider.getValue());
settings.put(RECTILINEAR_LAYOUT_KEY + "." + CURVATURE_KEY, curvatureSlider.getValue());
settings.put(RECTILINEAR_LAYOUT_KEY + "." + ALIGN_TIP_LABELS_KEY, alignTipLabelsCheck.isSelected());
}
private final JLabel titleLabel;
private final OptionsPanel optionsPanel;
private final JSlider rootLengthSlider;
private final JSlider curvatureSlider;
private final JCheckBox alignTipLabelsCheck;
private final RectilinearTreeLayout treeLayout;
}
figtree-1.4/src/figtree/treeviewer/treelayouts/TreeLayoutCache.java 0000644 0001750 0001750 00000006437 11763075412 025602 0 ustar osallou osallou package figtree.treeviewer.treelayouts;
import jebl.evolution.graphs.Node;
import java.awt.*;
import java.awt.geom.Line2D;
import java.awt.geom.Point2D;
import java.util.*;
import java.util.List;
/**
* @author Andrew Rambaut
* @version $Id: TreeLayoutCache.java 535 2006-11-21 11:11:20Z rambaut $
*/
public class TreeLayoutCache {
public Point2D getNodePoint(Node node) {
return nodePoints.get(node);
}
public Map getNodePointMap() {
return nodePoints;
}
public Shape getBranchPath(Node node) {
return branchPaths.get(node);
}
public Map getBranchPathMap() {
return branchPaths;
}
public Shape getNodeArea(Node node) {
return nodeAreas.get(node);
}
public Map getNodeAreaMap() {
return nodeAreas;
}
public Shape getCollapsedShape(Node node) {
return collapsedShapes.get(node);
}
public Map getCollapsedShapeMap() {
return collapsedShapes;
}
public List getHilightNodesList() {
return hilightNodes;
}
public Shape getHilightShape(Node node) {
return hilightShapes.get(node);
}
public Map getHilightShapeMap() {
return hilightShapes;
}
public Line2D getTipLabelPath(Node node) {
return tipLabelPaths.get(node);
}
public Map getTipLabelPathMap() {
return tipLabelPaths;
}
public Line2D getBranchLabelPath(Node node) {
return branchLabelPaths.get(node);
}
public Map getBranchLabelPathMap() {
return branchLabelPaths;
}
public Line2D getNodeLabelPath(Node node) {
return nodeLabelPaths.get(node);
}
public Map getNodeLabelPathMap() {
return nodeLabelPaths;
}
public Line2D getNodeShapePath(Node node) {
return nodeShapePaths.get(node);
}
public Map getNodeShapePathMap() {
return nodeShapePaths;
}
public Shape getCalloutPath(Node node) {
return calloutPaths.get(node);
}
public Map getCalloutPathMap() {
return calloutPaths;
}
public void clear() {
nodePoints.clear();
branchPaths.clear();
nodeAreas.clear();
collapsedShapes.clear();
hilightNodes.clear();
hilightShapes.clear();
tipLabelPaths.clear();
branchLabelPaths.clear();
nodeLabelPaths.clear();
nodeShapePaths.clear();
calloutPaths.clear();
}
protected Map nodePoints = new HashMap();
protected Map branchPaths = new HashMap();
protected Map nodeAreas = new HashMap();
protected Map collapsedShapes = new HashMap();
protected List hilightNodes = new ArrayList();
protected Map hilightShapes = new HashMap();
protected Map tipLabelPaths = new HashMap();
protected Map branchLabelPaths = new HashMap();
protected Map nodeLabelPaths = new HashMap();
protected Map nodeShapePaths = new HashMap();
protected Map calloutPaths = new HashMap();
}
figtree-1.4/src/figtree/treeviewer/treelayouts/TreeLayoutListener.java 0000644 0001750 0001750 00000000337 10713767454 026365 0 ustar osallou osallou package figtree.treeviewer.treelayouts;
/**
* @author Andrew Rambaut
* @version $Id: TreeLayoutListener.java 294 2006-04-14 10:28:11Z rambaut $
*/
public interface TreeLayoutListener {
void treeLayoutChanged();
}
figtree-1.4/src/figtree/treeviewer/treelayouts/PolarTreeLayoutController.java 0000644 0001750 0001750 00000015556 12017705351 027715 0 ustar osallou osallou package figtree.treeviewer.treelayouts;
import jam.controlpalettes.AbstractController;
import jam.panels.OptionsPanel;
import javax.swing.*;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Map;
import figtree.treeviewer.ControllerOptionsPanel;
/**
* @author Andrew Rambaut
* @version $Id: PolarTreeLayoutController.java 769 2007-08-30 12:14:37Z rambaut $
*/
public class PolarTreeLayoutController extends AbstractController {
private static final String POLAR_LAYOUT_KEY = "polarLayout";
private static final String ROOT_ANGLE_KEY = "rootAngle";
private static final String ANGULAR_RANGE_KEY = "angularRange";
private static final String ROOT_LENGTH_KEY = "rootLength";
private static final String SHOW_ROOT_KEY = "showRoot";
private static final String ALIGN_TIP_LABELS_KEY = "alignTipLabels";
public PolarTreeLayoutController(final PolarTreeLayout treeLayout) {
this.treeLayout = treeLayout;
titleLabel = new JLabel("Polar Layout");
optionsPanel = new ControllerOptionsPanel(0, 0);
rootAngleSlider = new JSlider(SwingConstants.HORIZONTAL, 0, 360000, 0);
rootAngleSlider.setOpaque(false);
rootAngleSlider.setValue((int) ((180.0 - (treeLayout.getRootAngle()) * 1000)));
//rootAngleSlider.setMajorTickSpacing(rootAngleSlider.getMaximum() / 5);
// rootAngleSlider.setPaintTicks(true);
rootAngleSlider.addChangeListener(new ChangeListener() {
public void stateChanged(ChangeEvent changeEvent) {
double value = 180 + (rootAngleSlider.getValue() / 1000.0);
treeLayout.setRootAngle(value % 360);
}
});
optionsPanel.addComponentWithLabel("Root Angle:", rootAngleSlider, true);
angularRangeSlider = new JSlider(SwingConstants.HORIZONTAL, 0, 360000, 0);
angularRangeSlider.setOpaque(false);
angularRangeSlider.setValue((int) ((360.0 - (treeLayout.getAngularRange()) * 1000.0)));
//angularRangeSlider.setMajorTickSpacing(angularRangeSlider.getMaximum() / 5);
// angularRangeSlider.setPaintTicks(true);
angularRangeSlider.addChangeListener(new ChangeListener() {
public void stateChanged(ChangeEvent changeEvent) {
double value = 360.0 - (angularRangeSlider.getValue() / 1000.0);
treeLayout.setAngularRange(value);
}
});
optionsPanel.addComponentWithLabel("Angle Range:", angularRangeSlider, true);
final int sliderMax = 10000;
rootLengthSlider = new JSlider(SwingConstants.HORIZONTAL, 0, sliderMax, 0);
rootLengthSlider.setOpaque(false);
rootLengthSlider.setValue((int) (treeLayout.getRootLengthProportion() * sliderMax));
//rootLengthSlider.setMajorTickSpacing(rootLengthSlider.getMaximum() / 5);
// rootLengthSlider.setPaintTicks(true);
rootLengthSlider.addChangeListener(new ChangeListener() {
public void stateChanged(ChangeEvent changeEvent) {
double value = rootLengthSlider.getValue();
treeLayout.setRootLengthProportion(value / sliderMax);
}
});
optionsPanel.addComponentWithLabel("Root Length:", rootLengthSlider, true);
showRootCheck = new JCheckBox("Show Root");
showRootCheck.setOpaque(false);
optionsPanel.addComponent(showRootCheck);
showRootCheck.setSelected(treeLayout.isShowingRootBranch());
showRootCheck.addChangeListener(new ChangeListener() {
public void stateChanged(ChangeEvent changeEvent) {
treeLayout.setShowingRootBranch(showRootCheck.isSelected());
}
});
// labelPositionCombo = new JComboBox();
// for (PolarTreeLayout.TipLabelPosition position : PolarTreeLayout.TipLabelPosition.values()) {
// if (position != PolarTreeLayout.TipLabelPosition.HORIZONTAL) // not implemented yet
// labelPositionCombo.addItem(position);
// }
// labelPositionCombo.setSelectedItem(treeLayout.getTipLabelPosition());
// labelPositionCombo.addActionListener(new ActionListener() {
// public void actionPerformed(ActionEvent event) {
// treeLayout.setTipLabelPosition((PolarTreeLayout.TipLabelPosition) labelPositionCombo.getSelectedItem());
//
// }
// });
// optionsPanel.addComponentWithLabel("Label Position:", labelPositionCombo);
alignTipLabelsCheck = new JCheckBox("Align Tip Labels");
alignTipLabelsCheck.setOpaque(false);
alignTipLabelsCheck.setSelected(treeLayout.getTipLabelPosition() == PolarTreeLayout.TipLabelPosition.RADIAL);
alignTipLabelsCheck.addChangeListener(new ChangeListener() {
public void stateChanged(ChangeEvent changeEvent) {
treeLayout.setTipLabelPosition(alignTipLabelsCheck.isSelected() ? PolarTreeLayout.TipLabelPosition.RADIAL : PolarTreeLayout.TipLabelPosition.FLUSH);
}
});
optionsPanel.addSpanningComponent(alignTipLabelsCheck);
}
public JComponent getTitleComponent() {
return titleLabel;
}
public JPanel getPanel() {
return optionsPanel;
}
public boolean isInitiallyVisible() {
return false;
}
public void initialize() {
// nothing to do
}
public void setSettings(Map settings) {
rootAngleSlider.setValue((Integer) settings.get(POLAR_LAYOUT_KEY + "." + ROOT_ANGLE_KEY));
angularRangeSlider.setValue((Integer) settings.get(POLAR_LAYOUT_KEY + "." + ANGULAR_RANGE_KEY));
rootLengthSlider.setValue((Integer) settings.get(POLAR_LAYOUT_KEY + "." + ROOT_LENGTH_KEY));
showRootCheck.setSelected((Boolean) settings.get(POLAR_LAYOUT_KEY + "." + SHOW_ROOT_KEY));
alignTipLabelsCheck.setSelected((Boolean) settings.get(POLAR_LAYOUT_KEY + "." + ALIGN_TIP_LABELS_KEY));
}
public void getSettings(Map settings) {
settings.put(POLAR_LAYOUT_KEY + "." + ROOT_ANGLE_KEY, rootAngleSlider.getValue());
settings.put(POLAR_LAYOUT_KEY + "." + ANGULAR_RANGE_KEY, angularRangeSlider.getValue());
settings.put(POLAR_LAYOUT_KEY + "." + ROOT_LENGTH_KEY, rootLengthSlider.getValue());
settings.put(POLAR_LAYOUT_KEY + "." + SHOW_ROOT_KEY, showRootCheck.isSelected());
settings.put(POLAR_LAYOUT_KEY + "." + ALIGN_TIP_LABELS_KEY, alignTipLabelsCheck.isSelected());
}
private final JLabel titleLabel;
private final OptionsPanel optionsPanel;
private final JSlider rootAngleSlider;
private final JSlider rootLengthSlider;
private final JSlider angularRangeSlider;
//private final JComboBox labelPositionCombo;
private final JCheckBox alignTipLabelsCheck;
private final JCheckBox showRootCheck;
private final PolarTreeLayout treeLayout;
} figtree-1.4/src/figtree/treeviewer/treelayouts/RectilinearTreeLayout.java 0000644 0001750 0001750 00000052644 12025066670 027037 0 ustar osallou osallou package figtree.treeviewer.treelayouts;
import jebl.evolution.graphs.Node;
import jebl.evolution.trees.RootedTree;
import java.awt.*;
import java.awt.geom.*;
import java.util.List;
/**
* @author Andrew Rambaut
* @version $Id: RectilinearTreeLayout.java 819 2007-10-22 14:42:58Z rambaut $
*/
public class RectilinearTreeLayout extends AbstractTreeLayout {
private double curvature = 0.0;
private boolean alignTipLabels = false;
private double fishEye = 0.0;
private double pointOfInterest = 0.5;
private int tipCount = 0;
private double rootLengthProportion = 0.01;
private double yPosition;
private double yIncrement;
private double maxXPosition;
public AxisType getXAxisType() {
return AxisType.CONTINUOUS;
}
public AxisType getYAxisType() {
return AxisType.DISCRETE;
}
public boolean isShowingRootBranch() {
return true;
}
public boolean maintainAspectRatio() {
return false;
}
public double getRootLengthProportion() {
return rootLengthProportion;
}
public void setRootLengthProportion(double rootLengthProportion) {
this.rootLengthProportion = rootLengthProportion;
fireTreeLayoutChanged();
}
public double getHeightOfPoint(Point2D point) {
return point.getX();
}
public Shape getAxisLine(double height) {
double x = height;
if (isAxisReversed()) {
x = maxXPosition - x;
}
double y1 = 0.0;
double y2 = 1.0;
return new Line2D.Double(x, y1, x, y2);
}
public Shape getHeightArea(double height1, double height2) {
double x = height1;
if (isAxisReversed()) {
x = maxXPosition - x;
}
double y = 0.0;
double w = Math.abs(height2 - height1);
double h = 1.0;
return new Rectangle2D.Double(x, y, w, h);
}
public boolean isAlignTipLabels() {
return alignTipLabels;
}
public double getCurvature() {
return curvature;
}
public double getFishEye() {
return fishEye;
}
public double getPointOfInterest() {
return pointOfInterest;
}
public void setAlignTipLabels(boolean alignTipLabels) {
this.alignTipLabels = alignTipLabels;
fireTreeLayoutChanged();
}
public void setCurvature(double curvature) {
this.curvature = curvature;
fireTreeLayoutChanged();
}
public void setFishEye(double fishEye) {
this.fishEye = fishEye;
fireTreeLayoutChanged();
}
public void setPointOfInterest(double x, double y) {
this.pointOfInterest = y;
fireTreeLayoutChanged();
}
public boolean isShowingColouring() {
return (branchColouringAttribute != null && curvature == 0.0);
}
public void layout(RootedTree tree, TreeLayoutCache cache) {
cache.clear();
maxXPosition = 0.0;
yPosition = 0.0;
tipCount = tree.getExternalNodes().size();
yIncrement = 1.0 / (tipCount - 1);
Node root = tree.getRootNode();
setRootLength(rootLengthProportion * tree.getHeight(root));
maxXPosition = 0.0;
getMaxXPosition(tree, root, getRootLength());
Point2D rootPoint = constructNode(tree, root, 0.0, getRootLength(), cache);
constructNodeAreas(tree, root, new Area(), cache);
// construct a root branch line
double ty = transformY(rootPoint.getY());
Line2D line = new Line2D.Double(0.0, ty, rootPoint.getX(), ty);
// add the line to the map of branch paths
cache.branchPaths.put(root, line);
}
private Point2D constructNode(final RootedTree tree, final Node node, final double xParent, final double xPosition, TreeLayoutCache cache) {
Point2D nodePoint;
if (!tree.isExternal(node)) {
if (hilightAttributeName != null && node.getAttribute(hilightAttributeName) != null) {
constructHilight(tree, node, xParent, xPosition, cache);
}
if (collapsedAttributeName != null && node.getAttribute(collapsedAttributeName) != null) {
nodePoint = constructCollapsedNode(tree, node, xPosition, cache);
} else if (cartoonAttributeName != null && node.getAttribute(cartoonAttributeName) != null) {
nodePoint = constructCartoonNode(tree, node, xPosition, cache);
} else {
double yPos = 0.0;
List children = tree.getChildren(node);
boolean rotate = false;
if (node.getAttribute("!rotate") != null &&
((Boolean)node.getAttribute("!rotate"))) {
rotate = true;
}
for (int i = 0; i < children.size(); i++) {
int index = i;
if (rotate) {
index = children.size() - i - 1;
}
Node child = children.get(index);
double length = tree.getLength(child);
Point2D childPoint = constructNode(tree, child, xPosition, xPosition + length, cache);
yPos += childPoint.getY();
}
// the y-position of the node is the average of the child nodes
yPos /= children.size();
nodePoint = new Point2D.Double(xPosition, yPos);
final double ty = transformY(yPos);
// start point
final float x0 = (float) nodePoint.getX();
final float y0 = (float) ty;
for (Node child : children) {
Point2D childPoint = cache.nodePoints.get(child);
GeneralPath branchPath = new GeneralPath();
// end point
final float x1 = (float) childPoint.getX();
final float y1 = (float) transformY(childPoint.getY());
if (curvature == 0.0) {
Object[] colouring = null;
if (branchColouringAttribute != null) {
colouring = (Object[])child.getAttribute(branchColouringAttribute);
}
if (colouring != null) {
// If there is a colouring, then we break the path up into
// segments. This should allow us to iterate along the segments
// and colour them as we draw them.
float nodeHeight = (float) tree.getHeight(node);
float childHeight = (float) tree.getHeight(child);
// to help this, we are going to draw the branch backwards
branchPath.moveTo(x1, y1);
float x = x1;
for (int i = 0; i < colouring.length - 1; i+=2) {
// float height = ((Number)colouring[i+1]).floatValue();
// float p = (height - childHeight) / (nodeHeight - childHeight);
float interval = ((Number)colouring[i+1]).floatValue();
float p = interval / (nodeHeight - childHeight);
x -= ((x1 - x0) * p);
branchPath.lineTo(x, y1);
}
branchPath.lineTo(x0, y1);
branchPath.lineTo(x0, y0);
} else {
branchPath.moveTo(x1, y1);
branchPath.lineTo(x0, y1);
branchPath.lineTo(x0, y0);
}
} else if (curvature == 1.0) {
// The extreme is to use a triangular look
branchPath.moveTo(x0, y0);
branchPath.lineTo(x1, y1);
} else {
// if the curvature is on then we simply don't
// do tree colouring - I just can't be bothered to
// implement it (and it would probably be confusing anyway).
float x2 = x1 - ((x1 - x0) * (float) (1.0 - curvature));
float y2 = y0 + ((y1 - y0) * (float) (1.0 - curvature));
branchPath.moveTo(x1, y1);
branchPath.lineTo(x2, y1);
branchPath.quadTo(x0, y1, x0, y2);
branchPath.lineTo(x0, y0);
}
// add the branchPath to the map of branch paths
cache.branchPaths.put(child, branchPath);
double x3 = (nodePoint.getX() + childPoint.getX()) / 2;
Line2D branchLabelPath = new Line2D.Double(
x3 - 1.0, y1,
x3 + 1.0, y1);
cache.branchLabelPaths.put(child, branchLabelPath);
}
Line2D nodeLabelPath = new Line2D.Double(
nodePoint.getX(), ty,
nodePoint.getX() + 1.0, ty);
cache.nodeLabelPaths.put(node, nodeLabelPath);
Line2D nodeShapePath = new Line2D.Double(
nodePoint.getX(), ty,
nodePoint.getX() - 1.0, ty);
cache.nodeShapePaths.put(node, nodeShapePath);
}
} else {
nodePoint = new Point2D.Double(xPosition, yPosition);
double ty = transformY(yPosition);
Line2D tipLabelPath;
if (alignTipLabels) {
tipLabelPath = new Line2D.Double(
maxXPosition, ty,
maxXPosition + 1.0, ty);
Line2D calloutPath = new Line2D.Double(
nodePoint.getX(), ty,
maxXPosition, ty);
cache.calloutPaths.put(node, calloutPath);
} else {
tipLabelPath = new Line2D.Double(
nodePoint.getX(), ty,
nodePoint.getX() + 1.0, ty);
}
cache.tipLabelPaths.put(node, tipLabelPath);
Line2D nodeShapePath = new Line2D.Double(
nodePoint.getX(), ty,
nodePoint.getX() - 1.0, ty);
cache.nodeShapePaths.put(node, nodeShapePath);
yPosition += yIncrement;
}
// add the node point to the map of node points
cache.nodePoints.put(node, nodePoint);
return nodePoint;
}
private void constructNodeAreas(final RootedTree tree, final Node node, final Area parentNodeArea, TreeLayoutCache cache) {
if (!tree.isExternal(node) &&
(collapsedAttributeName == null || node.getAttribute(collapsedAttributeName) == null) &&
(cartoonAttributeName == null || node.getAttribute(cartoonAttributeName) == null)) {
List children = tree.getChildren(node);
boolean rotate = false;
if (node.getAttribute("!rotate") != null &&
((Boolean)node.getAttribute("!rotate"))) {
rotate = true;
}
int index = (rotate ? children.size() - 1 : 0);
Node child1 = children.get(index);
Area childArea1 = new Area();
constructNodeAreas(tree, child1, childArea1, cache);
Rectangle2D branchBounds1 = cache.getBranchPath(child1).getBounds2D();
index = (rotate ? 0 : children.size() - 1);
Node child2 = children.get(index);
Area childArea2 = new Area();
constructNodeAreas(tree, child2, childArea2, cache);
Rectangle2D branchBounds2 = cache.getBranchPath(child2).getBounds2D();
GeneralPath nodePath = new GeneralPath();
// start point
final float x0 = (float) branchBounds1.getX();
final float y0 = (float) (branchBounds1.getY() + branchBounds1.getHeight());
nodePath.moveTo(x0, y0);
if (curvature == 0.0) {
final float y1 = (float) branchBounds1.getY();
nodePath.lineTo(x0, y1);
nodePath.lineTo((float)maxXPosition, y1);
final float y2 = (float) (branchBounds2.getY() + branchBounds2.getHeight());
nodePath.lineTo((float)maxXPosition, y2);
nodePath.lineTo(x0, y2);
} else if (curvature == 1.0) {
// The extreme is to use a triangular look
final float x1 = (float) (branchBounds1.getX() + branchBounds1.getWidth());
final float y1 = (float) branchBounds1.getY();
nodePath.lineTo(x1, y1);
nodePath.lineTo((float)maxXPosition, y1);
final float y2 = (float) (branchBounds2.getY() + branchBounds2.getHeight());
nodePath.lineTo((float)maxXPosition, y2);
final float x2 = (float) (branchBounds2.getX() + branchBounds2.getWidth());
nodePath.lineTo(x2, y2);
} else {
final float x1 = (float) (branchBounds1.getX() + branchBounds1.getWidth());
final float y1 = (float) branchBounds1.getY();
float x2 = x1 - ((x1 - x0) * (float) (1.0 - curvature));
float y2 = y0 - ((y0 - y1) * (float) (1.0 - curvature));
nodePath.lineTo(x0, y2);
nodePath.quadTo(x0, y1, x2, y1);
nodePath.lineTo((float)maxXPosition, y1);
final float y3 = (float) (branchBounds2.getY() + branchBounds2.getHeight());
nodePath.lineTo((float)maxXPosition, y3);
final float x3 = (float) (branchBounds2.getX() + branchBounds2.getWidth());
final float x4 = x3 - ((x3 - x0) * (float) (1.0 - curvature));
final float y4 = y0 + ((y3 - y0) * (float) (1.0 - curvature));
nodePath.lineTo(x4, y3);
nodePath.quadTo(x0, y3, x0, y4);
}
nodePath.lineTo(x0, y0);
nodePath.closePath();
Area nodeArea = new Area(nodePath);
parentNodeArea.add(nodeArea);
parentNodeArea.add(childArea1);
parentNodeArea.add(childArea2);
nodeArea.subtract(childArea1);
nodeArea.subtract(childArea2);
cache.nodeAreas.put(node, nodeArea);
}
}
private Point2D constructCartoonNode(RootedTree tree, Node node, double xPosition, TreeLayoutCache cache) {
Point2D nodePoint;
Object[] values = (Object[])node.getAttribute(cartoonAttributeName);
int tipCount = (Integer)values[0];
double tipHeight = (Double)values[1];
double height = tree.getHeight(node);
double maxXPos = xPosition + height - tipHeight;
double minYPos = yPosition;
yPosition += yIncrement * (tipCount - 1);
double maxYPos = yPosition;
yPosition += yIncrement;
// the y-position of the node is the average of the child nodes
double yPos = (maxYPos + minYPos) / 2;
nodePoint = new Point2D.Double(xPosition, yPos);
GeneralPath collapsedShape = new GeneralPath();
// start point
float x0 = (float)nodePoint.getX();
float y0 = (float)transformY(nodePoint.getY());
// end point
float x1 = (float)maxXPos;
float y1 = (float)transformY(minYPos);
float y2 = (float)transformY(maxYPos);
collapsedShape.moveTo(x0, y0);
collapsedShape.lineTo(x1, y1);
collapsedShape.lineTo(x1, y2);
collapsedShape.closePath();
// add the collapsedShape to the map of branch paths
cache.collapsedShapes.put(node, collapsedShape);
Line2D nodeLabelPath = new Line2D.Double(
nodePoint.getX(), y0,
nodePoint.getX() + 1.0, y0);
cache.nodeLabelPaths.put(node, nodeLabelPath);
Line2D nodeBarPath = new Line2D.Double(
nodePoint.getX(), y0,
nodePoint.getX() - 1.0, y0);
cache.nodeShapePaths.put(node, nodeBarPath);
if (showingCartoonTipLabels) {
constructCartoonTipLabelPaths(tree, node, maxXPos, new double[] { minYPos }, cache);
}
return nodePoint;
}
private void constructCartoonTipLabelPaths(RootedTree tree, Node node,
double xPosition, double[] yPosition,
TreeLayoutCache cache) {
if (!tree.isExternal(node)) {
for (Node child : tree.getChildren(node)) {
constructCartoonTipLabelPaths(tree, child, xPosition, yPosition, cache);
}
} else {
Point2D nodePoint = new Point2D.Double(xPosition, yPosition[0]);
double x0 = nodePoint.getX();
double y0 = transformY(nodePoint.getY());
Line2D tipLabelPath;
if (alignTipLabels) {
tipLabelPath = new Line2D.Double(maxXPosition, y0, maxXPosition + 1.0, y0);
Line2D calloutPath = new Line2D.Double(x0, y0, maxXPosition, y0);
cache.calloutPaths.put(node, calloutPath);
} else {
tipLabelPath = new Line2D.Double(x0, y0, x0 + 1.0, y0);
}
cache.tipLabelPaths.put(node, tipLabelPath);
yPosition[0] += yIncrement;
}
}
private Point2D constructCollapsedNode(RootedTree tree, Node node, double xPosition, TreeLayoutCache cache) {
Point2D nodePoint;
Object[] values = (Object[])node.getAttribute(collapsedAttributeName);
double tipHeight = (Double)values[1];
double height = tree.getHeight(node);
double maxXPos = xPosition + height - tipHeight;
double minYPos = yPosition - (yIncrement * 0.5);
double maxYPos = minYPos + yIncrement;
yPosition += yIncrement;
// the y-position of the node is the average of the child nodes
double yPos = (maxYPos + minYPos) / 2;
nodePoint = new Point2D.Double(xPosition, yPos);
double ty = transformY(yPos);
GeneralPath collapsedShape = new GeneralPath();
// start point
float x0 = (float)nodePoint.getX();
float y0 = (float)ty;
// end point
float x1 = (float)maxXPos;
float y1 = (float)transformY(minYPos);
float y2 = (float)transformY(maxYPos);
collapsedShape.moveTo(x0, y0);
collapsedShape.lineTo(x1, y1);
collapsedShape.lineTo(x1, y2);
collapsedShape.closePath();
// add the collapsedShape to the map of branch paths
cache.collapsedShapes.put(node, collapsedShape);
Line2D nodeLabelPath = new Line2D.Double(xPosition, ty, xPosition + 1.0, ty);
cache.nodeLabelPaths.put(node, nodeLabelPath);
Line2D nodeBarPath = new Line2D.Double(xPosition, ty, xPosition - 1.0, ty);
cache.nodeShapePaths.put(node, nodeBarPath);
Line2D tipLabelPath;
if (alignTipLabels) {
tipLabelPath = new Line2D.Double(
maxXPosition, ty,
maxXPosition + 1.0, ty);
Line2D calloutPath = new Line2D.Double(
maxXPos, ty,
maxXPosition, ty);
cache.calloutPaths.put(node, calloutPath);
} else {
tipLabelPath = new Line2D.Double(maxXPos, ty, maxXPos + 1.0, ty);
}
cache.tipLabelPaths.put(node, tipLabelPath);
return nodePoint;
}
private void constructHilight(RootedTree tree, Node node, double xParent, double xPosition, TreeLayoutCache cache) {
Object[] values = (Object[])node.getAttribute(hilightAttributeName);
int tipCount = (Integer)values[0];
double tipHeight = (Double)values[1];
double height = tree.getHeight(node);
GeneralPath hilightShape = new GeneralPath();
float x0 = (float)((xPosition + xParent) / 2.0);
float x1 = (float)(xPosition + height /*- tipHeight*/);
double tmp = yPosition - (yIncrement / 2);
float y0 = (float)transformY(tmp);
float y1 = (float)transformY(tmp + (yIncrement * tipCount));
hilightShape.moveTo(x0, y0);
hilightShape.lineTo(x1, y0);
hilightShape.lineTo(x1, y1);
hilightShape.lineTo(x0, y1);
hilightShape.closePath();
// add the collapsedShape to the map of branch paths
cache.hilightNodes.add(node);
cache.hilightShapes.put(node, hilightShape);
}
private void getMaxXPosition(RootedTree tree, Node node, double xPosition) {
if (!tree.isExternal(node)) {
List children = tree.getChildren(node);
for (Node child : children) {
double length = tree.getLength(child);
getMaxXPosition(tree, child, xPosition + length);
}
} else {
if (xPosition > maxXPosition) {
maxXPosition = xPosition;
}
}
}
private double transformY(double y) {
if (fishEye == 0.0) {
return y;
}
double scale = 1.0 / (fishEye * tipCount);
double dist = pointOfInterest - y;
double min = 1.0 - (pointOfInterest / (scale + pointOfInterest));
double max = 1.0 - ((pointOfInterest - 1.0) / (scale - (pointOfInterest - 1.0)));
double c = 1.0 - (dist < 0 ? (dist / (scale - dist)) : (dist / (scale + dist)));
return (c - min) / (max - min);
}
} figtree-1.4/src/figtree/treeviewer/treelayouts/TreeLayout.java 0000644 0001750 0001750 00000005274 11240015063 024636 0 ustar osallou osallou package figtree.treeviewer.treelayouts;
import jebl.evolution.trees.RootedTree;
import java.awt.*;
import java.awt.geom.Point2D;
/**
* @author Andrew Rambaut
* @version $Id: TreeLayout.java 819 2007-10-22 14:42:58Z rambaut $
*/
public interface TreeLayout {
public enum AxisType {
CONTINUOUS,
DISCRETE
}
void layout(RootedTree tree, TreeLayoutCache cache);
/**
* Add a listener for this layout
*
* @param listener
*/
void addTreeLayoutListener(TreeLayoutListener listener);
/**
* Remove a listener from this layout
*
* @param listener
*/
void removeTreeLayoutListener(TreeLayoutListener listener);
/**
* Return whether the x axis is continuous or discrete
*
* @return the axis type
*/
AxisType getXAxisType();
/**
* Return whether the y axis is continuous or discrete
*
* @return the axis type
*/
AxisType getYAxisType();
/**
* Return whether this layout displays a root branch
* @return showing root branch?
*/
boolean isShowingRootBranch();
double getRootLength();
void setRootLength(double rootLength);
boolean isAxisReversed();
void setAxisReversed(final boolean axisReversed);
/**
* Return whether this layout is showing a branch colouring
* @return showing colouring?
*/
boolean isShowingColouring();
void setFishEye(double fishEye);
void setPointOfInterest(double x, double y);
/**
* Return whether the two axis scales should be maintained
* relative to each other
*
* @return a boolean
*/
boolean maintainAspectRatio();
double getHeightOfPoint(Point2D point);
/**
* Return a line that defines a particular height. Some layouts
* won't be able to produce this and may throw an UnsupportedOperationException.
*
* @param height
* @return the line
*/
Shape getAxisLine(double height);
/**
* Return a shape that defines a particular height interval. Some layouts
* won't be able to produce this and may throw an UnsupportedOperationException.
*
* @param height1
* @param height2
* @return the area
*/
Shape getHeightArea(double height1, double height2);
String getBranchColouringAttributeName();
void setBranchColouringAttributeName(String colouringAttributeName);
String getCartoonAttributeName();
void setCartoonAttributeName(String cartoonAttributeName);
String getCollapsedAttributeName();
void setCollapsedAttributeName(String collapsedAttributeName);
String getHilightAttributeName();
void setHilightAttributeName(String hilightAttributeName);
}
figtree-1.4/src/figtree/treeviewer/treelayouts/PolarTreeLayout.java 0000644 0001750 0001750 00000065675 12025066670 025663 0 ustar osallou osallou package figtree.treeviewer.treelayouts;
import jebl.evolution.graphs.Node;
import jebl.evolution.trees.RootedTree;
import java.awt.*;
import java.awt.geom.*;
import java.util.List;
/**
* @author Andrew Rambaut
* @version $Id: PolarTreeLayout.java 780 2007-09-09 09:46:01Z rambaut $
*/
public class PolarTreeLayout extends AbstractTreeLayout {
private double rootAngle = 180.0;
private double rootLengthProportion = 0.01;
private double angularRange = 360.0;
private double fishEye = 0.0;
private double pointOfInterest = 0.5;
private int tipCount = 0;
private double totalRootLength = 0.0;
private boolean showingRootBranch = true;
private TipLabelPosition tipLabelPosition = TipLabelPosition.FLUSH;
private double yPosition;
private double yIncrement;
private double maxXPosition;
public enum TipLabelPosition {
FLUSH,
RADIAL,
HORIZONTAL
}
public AxisType getXAxisType() {
return AxisType.CONTINUOUS;
}
public AxisType getYAxisType() {
return AxisType.CONTINUOUS;
}
public boolean maintainAspectRatio() {
return true;
}
public void setFishEye(double fishEye) {
this.fishEye = fishEye;
fireTreeLayoutChanged();
}
public void setPointOfInterest(double x, double y) {
this.pointOfInterest = getPolarAngle(x, y);
fireTreeLayoutChanged();
}
public double getHeightOfPoint(Point2D point) {
throw new UnsupportedOperationException("Method getHeightOfPoint() is not supported in this TreeLayout");
}
public Shape getAxisLine(double height) {
double x = height;
if (isAxisReversed()) {
x = maxXPosition - x;
}
return new Ellipse2D.Double(-x, -x, x * 2.0, x * 2.0);
}
public Shape getHeightArea(double height1, double height2) {
Area area1 = new Area(new Ellipse2D.Double(0.0, 0.0, height2 * 2.0, height2 * 2.0));
Area area2 = new Area(new Ellipse2D.Double(0.0, 0.0, height1 * 2.0, height1 * 2.0));
area1.subtract(area2);
return area1;
}
public double getRootAngle() {
return rootAngle;
}
public double getAngularRange() {
return angularRange;
}
public boolean isShowingRootBranch() {
return showingRootBranch;
}
public double getTotalRootLength() {
return totalRootLength;
}
public double getRootLengthProportion() {
return rootLengthProportion;
}
public TipLabelPosition getTipLabelPosition() {
return tipLabelPosition;
}
public void setRootAngle(double rootAngle) {
this.rootAngle = rootAngle;
constant = rootAngle - ((360.0 - angularRange) * 0.5);
fireTreeLayoutChanged();
}
public void setAngularRange(double angularRange) {
this.angularRange = angularRange;
constant = rootAngle - ((360.0 - angularRange) * 0.5);
fireTreeLayoutChanged();
}
public void setShowingRootBranch(boolean showingRootBranch) {
this.showingRootBranch = showingRootBranch;
fireTreeLayoutChanged();
}
public void setRootLengthProportion(double rootLengthProportion) {
this.rootLengthProportion = rootLengthProportion;
fireTreeLayoutChanged();
}
public void setTipLabelPosition(TipLabelPosition tipLabelPosition) {
this.tipLabelPosition = tipLabelPosition;
fireTreeLayoutChanged();
}
public boolean isShowingColouring() {
return (branchColouringAttribute != null);
}
public void layout(RootedTree tree, TreeLayoutCache cache) {
cache.clear();
Node root = tree.getRootNode();
double totalRootLength = (rootLengthProportion * tree.getHeight(root)) * 10.0;
maxXPosition = 0.0;
getMaxXPosition(tree, root, totalRootLength);
yPosition = 0.0;
tipCount = tree.getExternalNodes().size();
yIncrement = 1.0 / tipCount;
final Point2D rootPoint = constructNode(tree, root, 0.0, totalRootLength, /*new Area(),*/ cache);
// constructNodeAreas(tree, root, new Area(), cache);
if (showingRootBranch) {
// construct a root branch line
final double y = rootPoint.getY();
Line2D line = new Line2D.Double(transform(0.0, y), transform(rootPoint.getX(), y));
// add the line to the map of branch paths
cache.branchPaths.put(root, line);
}
}
private Point2D constructNode(RootedTree tree, Node node, double xParent, double xPosition, /*final Area parentNodeArea,*/ TreeLayoutCache cache) {
Point2D nodePoint;
if (!tree.isExternal(node)) {
if (hilightAttributeName != null && node.getAttribute(hilightAttributeName) != null) {
constructHilight(tree, node, xParent, xPosition, cache);
}
if (collapsedAttributeName != null && node.getAttribute(collapsedAttributeName) != null) {
nodePoint = constructCollapsedNode(tree, node, xPosition, cache);
} else if (cartoonAttributeName != null && node.getAttribute(cartoonAttributeName) != null) {
nodePoint = constructCartoonNode(tree, node, xPosition, cache);
} else {
double yPos = 0.0;
List childList = tree.getChildren(node);
Node[] children = new Node[childList.size()];
Point2D[] childPoints = new Point2D[childList.size()];
boolean rotate = false;
if (node.getAttribute("!rotate") != null &&
((Boolean)node.getAttribute("!rotate"))) {
rotate = true;
}
// Area[] childAreas = new Area[childList.size()];
for (int i = 0; i < childList.size(); i++) {
int index = i;
if (rotate) {
index = childList.size() - i - 1;
}
children[i] = childList.get(index);
final double length = tree.getLength(children[i]);
// childAreas[i] = new Area();
childPoints[i] = constructNode(tree, children[i], xPosition, xPosition + length, cache);
// parentNodeArea.add(childAreas[i]);
yPos += childPoints[i].getY();
}
// the y-position of the node is the average of the child nodes
yPos /= childList.size();
nodePoint = new Point2D.Double(xPosition, yPos);
Point2D transformedNodePoint = transform(nodePoint);
final double start = getAngle(yPos);
// GeneralPath nodeAreaPath = new GeneralPath();
double firstChildAngle = 0;
for (int i = 0; i < childList.size(); i++) {
int index = i;
if (rotate) {
index = childList.size() - i - 1;
}
GeneralPath branchPath = new GeneralPath();
final Point2D transformedChildPoint = transform(childPoints[i]);
final Point2D transformedShoulderPoint = transform(
nodePoint.getX(), childPoints[i].getY());
// if (i == 0) {
// nodeAreaPath.moveTo(
// (float) transformedShoulderPoint.getX(),
// (float) transformedShoulderPoint.getY());
// final Point2D transformedPoint2 = transform(
// maxXPosition, childPoints[i].getY());
// nodeAreaPath.lineTo(
// (float) transformedPoint2.getX(),
// (float) transformedPoint2.getY());
// firstChildAngle = getAngle(childPoints[i].getY());
// }
Object[] colouring = null;
if (branchColouringAttribute != null) {
colouring = (Object[])children[i].getAttribute(branchColouringAttribute);
}
if (colouring != null) {
// If there is a colouring, then we break the path up into
// segments. This should allow use to iterate along the segments
// and colour them as we draw them.
float nodeHeight = (float) tree.getHeight(node);
float childHeight = (float) tree.getHeight(children[i]);
double x1 = childPoints[i].getX();
double x0 = nodePoint.getX();
branchPath.moveTo(
(float) transformedChildPoint.getX(),
(float) transformedChildPoint.getY());
float x = (float)x1;
for (int j = 0; j < colouring.length - 1; j+=2) {
// double height = ((Number)colouring[j+1]).doubleValue();
// double p = (height - childHeight) / (nodeHeight - childHeight);
float interval = ((Number)colouring[j+1]).floatValue();
float p = interval / (nodeHeight - childHeight);
x -= ((x1 - x0) * p);
final Point2D transformedPoint = transform(x, childPoints[index].getY());
branchPath.lineTo(
(float) transformedPoint.getX(),
(float) transformedPoint.getY());
}
branchPath.lineTo(
(float) transformedShoulderPoint.getX(),
(float) transformedShoulderPoint.getY());
} else {
branchPath.moveTo(
(float) transformedChildPoint.getX(),
(float) transformedChildPoint.getY());
branchPath.lineTo(
(float) transformedShoulderPoint.getX(),
(float) transformedShoulderPoint.getY());
}
final double finish = getAngle(childPoints[index].getY());
Arc2D arc = new Arc2D.Double();
arc.setArcByCenter(0.0, 0.0, nodePoint.getX(), finish, start - finish, Arc2D.OPEN);
branchPath.append(arc, true);
// if (i == childList.size() - 1) {
// Arc2D arc2 = new Arc2D.Double();
// arc2.setArcByCenter(0.0, 0.0, maxXPosition, firstChildAngle, finish - firstChildAngle, Arc2D.OPEN);
// nodeAreaPath.append(arc2, true);
//
// nodeAreaPath.lineTo(
// (float) transformedShoulderPoint.getX(),
// (float) transformedShoulderPoint.getY());
//
// Arc2D arc3 = new Arc2D.Double();
// arc3.setArcByCenter(0.0, 0.0, nodePoint.getX(), finish, firstChildAngle - finish, Arc2D.OPEN);
// nodeAreaPath.append(arc3, true);
// }
// add the branchPath to the map of branch paths
cache.branchPaths.put(children[i], branchPath);
final double x3 = (nodePoint.getX() + childPoints[index].getX()) / 2;
Line2D branchLabelPath = new Line2D.Double(
transform(x3 - 1.0, childPoints[index].getY()),
transform(x3 + 1.0, childPoints[index].getY()));
cache.branchLabelPaths.put(children[i], branchLabelPath);
}
// nodeAreaPath.closePath();
//
// Area nodeArea = new Area(nodeAreaPath);
// parentNodeArea.add(nodeArea);
//
// for (Area childArea : childAreas) {
// nodeArea.subtract(childArea);
// }
//
// cache.nodeAreas.put(node, nodeArea);
Line2D nodeLabelPath = new Line2D.Double(
transform(nodePoint.getX(), yPos),
transform(nodePoint.getX() + 1.0, yPos));
cache.nodeLabelPaths.put(node, nodeLabelPath);
Line2D nodeShapePath = new Line2D.Double(
transform(nodePoint.getX(), yPos),
transform(nodePoint.getX() - 1.0, yPos));
cache.nodeShapePaths.put(node, nodeShapePath);
// add the node point to the map of node points
cache.nodePoints.put(node, transformedNodePoint);
}
} else {
nodePoint = new Point2D.Double(xPosition, yPosition);
Point2D transformedNodePoint = transform(nodePoint);
Line2D tipLabelPath;
if (tipLabelPosition == TipLabelPosition.FLUSH) {
tipLabelPath = new Line2D.Double(transformedNodePoint, transform(xPosition + 1.0, yPosition));
} else if (tipLabelPosition == TipLabelPosition.RADIAL) {
tipLabelPath = new Line2D.Double(transform(maxXPosition, yPosition),
transform(maxXPosition + 1.0, yPosition));
Line2D calloutPath = new Line2D.Double(transformedNodePoint, transform(maxXPosition, yPosition));
cache.calloutPaths.put(node, calloutPath);
} else if (tipLabelPosition == TipLabelPosition.HORIZONTAL) {
// this option disabled in getControls (JH)
throw new UnsupportedOperationException("Not implemented yet");
} else {
// this is a bug
throw new IllegalArgumentException("Unrecognized enum value");
}
cache.tipLabelPaths.put(node, tipLabelPath);
Line2D nodeShapePath = new Line2D.Double(
transform(nodePoint.getX(), yPosition),
transform(nodePoint.getX() - 1.0, yPosition));
cache.nodeShapePaths.put(node, nodeShapePath);
yPosition += yIncrement;
// add the node point to the map of node points
cache.nodePoints.put(node, transformedNodePoint);
}
return nodePoint;
}
private void constructNodeAreas(final RootedTree tree, final Node node, final Area parentNodeArea, TreeLayoutCache cache) {
if (!tree.isExternal(node)) {
List children = tree.getChildren(node);
boolean rotate = false;
if (node.getAttribute("!rotate") != null &&
((Boolean)node.getAttribute("!rotate"))) {
rotate = true;
}
int index = (rotate ? children.size() - 1 : 0);
Node child1 = children.get(index);
Area childArea1 = new Area();
constructNodeAreas(tree, child1, childArea1, cache);
index = (rotate ? 0 : children.size() - 1);
Node child2 = children.get(index);
Area childArea2 = new Area();
constructNodeAreas(tree, child2, childArea2, cache);
GeneralPath nodePath = new GeneralPath();
PathIterator pi1 = cache.getBranchPath(child1).getPathIterator(null);
nodePath.append(pi1, false);
// start point
// final float x0 = (float) branchBounds1.getX();
// final float y0 = (float) (branchBounds1.getY() + branchBounds1.getHeight());
// nodePath.moveTo(x0, y0);
//
// final float y1 = (float) branchBounds1.getY();
// nodePath.lineTo(x0, y1);
//
// nodePath.lineTo(maxXPosition, y1);
//
// final float y2 = (float) (branchBounds2.getY() + branchBounds2.getHeight());
// nodePath.lineTo(maxXPosition, y2);
//
// nodePath.lineTo(x0, y2);
//
// nodePath.lineTo(x0, y0);
// nodePath.closePath();
//
// Area nodeArea = new Area(nodePath);
//
// parentNodeArea.add(nodeArea);
// parentNodeArea.add(childArea1);
// parentNodeArea.add(childArea2);
//
// nodeArea.subtract(childArea1);
// nodeArea.subtract(childArea2);
//
// cache.nodeAreas.put(node, nodeArea);
}
}
private Point2D constructCartoonNode(RootedTree tree, Node node, double xPosition, TreeLayoutCache cache) {
Point2D nodePoint;
Object[] values = (Object[])node.getAttribute(cartoonAttributeName);
int tipCount = (Integer)values[0];
double tipHeight = (Double)values[1];
double height = tree.getHeight(node);
double maxXPos = xPosition + height - tipHeight;
double minYPos = yPosition;
yPosition += yIncrement * (tipCount - 1);
double maxYPos = yPosition;
yPosition += yIncrement;
// the y-position of the node is the average of the child nodes
double yPos = (maxYPos + minYPos) / 2;
nodePoint = new Point2D.Double(xPosition, yPos);
Point2D transformedNodePoint0 = transform(nodePoint);
Point2D transformedNodePoint1 = transform(new Point2D.Double(maxXPos, minYPos));
Point2D transformedNodePoint2 = transform(new Point2D.Double(maxXPos, maxYPos));
GeneralPath collapsedShape = new GeneralPath();
collapsedShape.moveTo((float)transformedNodePoint0.getX(), (float)transformedNodePoint0.getY());
collapsedShape.lineTo((float)transformedNodePoint1.getX(), (float)transformedNodePoint1.getY());
final double start = getAngle(maxYPos);
final double finish = getAngle(minYPos);
Arc2D arc = new Arc2D.Double();
arc.setArcByCenter(0.0, 0.0, maxXPos, finish, start - finish, Arc2D.OPEN);
collapsedShape.append(arc, true);
collapsedShape.closePath();
// add the collapsedShape to the map of branch paths
cache.collapsedShapes.put(node, collapsedShape);
Line2D nodeLabelPath = new Line2D.Double(
transform(nodePoint.getX(), yPos),
transform(nodePoint.getX() + 1.0, yPos));
cache.nodeLabelPaths.put(node, nodeLabelPath);
Line2D nodeBarPath = new Line2D.Double(
transform(nodePoint.getX(), yPos),
transform(nodePoint.getX() - 1.0, yPos));
cache.nodeShapePaths.put(node, nodeBarPath);
if (showingCartoonTipLabels) {
constructCartoonTipLabelPaths(tree, node, maxXPos, new double[] { minYPos }, cache);
}
// add the node point to the map of node points
cache.nodePoints.put(node, transformedNodePoint0);
return nodePoint;
}
private void constructCartoonTipLabelPaths(RootedTree tree, Node node, double xPosition, double[] yPosition, TreeLayoutCache cache) {
if (!tree.isExternal(node)) {
for (Node child : tree.getChildren(node)) {
constructCartoonTipLabelPaths(tree, child, xPosition, yPosition, cache);
}
} else {
Point2D nodePoint = new Point2D.Double(xPosition, yPosition[0]);
Point2D transformedNodePoint = transform(nodePoint);
Line2D tipLabelPath;
if (tipLabelPosition == TipLabelPosition.FLUSH) {
tipLabelPath = new Line2D.Double(transformedNodePoint, transform(xPosition + 1.0, yPosition[0]));
} else if (tipLabelPosition == TipLabelPosition.RADIAL) {
tipLabelPath = new Line2D.Double(transform(maxXPosition, yPosition[0]),
transform(maxXPosition + 1.0, yPosition[0]));
Line2D calloutPath = new Line2D.Double(transformedNodePoint, transform(maxXPosition, yPosition[0]));
cache.calloutPaths.put(node, calloutPath);
} else if (tipLabelPosition == TipLabelPosition.HORIZONTAL) {
// this option disabled in getControls (JH)
throw new UnsupportedOperationException("Not implemented yet");
} else {
// this is a bug
throw new IllegalArgumentException("Unrecognized enum value");
}
cache.tipLabelPaths.put(node, tipLabelPath);
yPosition[0] += yIncrement;
}
}
private Point2D constructCollapsedNode(RootedTree tree, Node node, double xPosition, TreeLayoutCache cache) {
Point2D nodePoint;
Object[] values = (Object[])node.getAttribute(collapsedAttributeName);
//String tipName = (String)values[0];
double tipHeight = (Double)values[1];
double height = tree.getHeight(node);
double maxXPos = xPosition + height - tipHeight;
double minYPos = yPosition - (yIncrement * 0.5);
double maxYPos = minYPos + yIncrement;
yPosition += yIncrement;
// the y-position of the node is the average of the child nodes
double yPos = (maxYPos + minYPos) / 2;
nodePoint = new Point2D.Double(xPosition, yPos);
Point2D transformedNodePoint0 = transform(nodePoint);
Point2D transformedNodePoint1 = transform(new Point2D.Double(maxXPos, minYPos));
GeneralPath collapsedShape = new GeneralPath();
collapsedShape.moveTo((float)transformedNodePoint0.getX(), (float)transformedNodePoint0.getY());
collapsedShape.lineTo((float)transformedNodePoint1.getX(), (float)transformedNodePoint1.getY());
final double start = getAngle(maxYPos);
final double finish = getAngle(minYPos);
Arc2D arc = new Arc2D.Double();
arc.setArcByCenter(0.0, 0.0, maxXPos, finish, start - finish, Arc2D.OPEN);
collapsedShape.append(arc, true);
collapsedShape.closePath();
// add the collapsedShape to the map of branch paths
cache.collapsedShapes.put(node, collapsedShape);
Line2D nodeLabelPath = new Line2D.Double(
transform(nodePoint.getX(), yPos),
transform(nodePoint.getX() + 1.0, yPos));
cache.nodeLabelPaths.put(node, nodeLabelPath);
Line2D nodeBarPath = new Line2D.Double(
transform(nodePoint.getX(), yPos),
transform(nodePoint.getX() - 1.0, yPos));
cache.nodeShapePaths.put(node, nodeBarPath);
Point2D transformedNodePoint = transform(maxXPos, yPos);
Line2D tipLabelPath;
if (tipLabelPosition == TipLabelPosition.FLUSH) {
tipLabelPath = new Line2D.Double(transformedNodePoint, transform(maxXPos + 1.0, yPos));
} else if (tipLabelPosition == TipLabelPosition.RADIAL) {
tipLabelPath = new Line2D.Double(transform(maxXPosition, yPos),
transform(maxXPosition + 1.0, yPos));
Line2D calloutPath = new Line2D.Double(transformedNodePoint, transform(maxXPosition, yPos));
cache.calloutPaths.put(node, calloutPath);
} else if (tipLabelPosition == TipLabelPosition.HORIZONTAL) {
// this option disabled in getControls (JH)
throw new UnsupportedOperationException("Not implemented yet");
} else {
// this is a bug
throw new IllegalArgumentException("Unrecognized enum value");
}
cache.tipLabelPaths.put(node, tipLabelPath);
// add the node point to the map of node points
cache.nodePoints.put(node, transformedNodePoint0);
return nodePoint;
}
private void constructHilight(RootedTree tree, Node node, double xParent, double xPosition, TreeLayoutCache cache) {
Object[] values = (Object[])node.getAttribute(hilightAttributeName);
int tipCount = (Integer)values[0];
double tipHeight = (Double)values[1];
double height = tree.getHeight(node);
GeneralPath hilightShape = new GeneralPath();
double x0 = ((xPosition + xParent) / 2.0);
double x1 = (xPosition + height /*- tipHeight*/);
double y0 = yPosition - (yIncrement / 2);
double y1 = yPosition + (yIncrement * tipCount) - (yIncrement / 2);
Point2D p1 = transform(new Point2D.Double(x0, y0));
Point2D p2 = transform(new Point2D.Double(x1, y0));
Point2D p3 = transform(new Point2D.Double(x1, y1));
Point2D p4 = transform(new Point2D.Double(x0, y1));
final double start = getAngle(y0);
final double finish = getAngle(y1);
hilightShape.moveTo((float)p1.getX(), (float)p1.getY());
hilightShape.lineTo((float)p2.getX(), (float)p2.getY());
Arc2D arc = new Arc2D.Double();
arc.setArcByCenter(0.0, 0.0, x1, start, finish - start, Arc2D.OPEN);
hilightShape.append(arc, true);
hilightShape.lineTo((float)p3.getX(), (float)p3.getY());
arc = new Arc2D.Double();
arc.setArcByCenter(0.0, 0.0, x0, finish, start - finish, Arc2D.OPEN);
hilightShape.append(arc, true);
hilightShape.closePath();
// add the collapsedShape to the map of branch paths
cache.hilightNodes.add(node);
cache.hilightShapes.put(node, hilightShape);
}
private void getMaxXPosition(RootedTree tree, Node node, double xPosition) {
if (!tree.isExternal(node)) {
List