Styled square tree

.gitignore

@@ -1,4 +1,8 @@
 Mesquite_Folder/
+# Workspace files #
+###################
+*.iml
+
 # Compiled source #
 ###################
 *.com
@@ -36,3 +40,7 @@ Mesquite_Folder/
 .Trashes
 ehthumbs.db
 Thumbs.db
+
+# Build products #
+##################
+Resources/Mesquite*

Source/mesquite/lib/MesquiteTree.java

@@ -1743,6 +1743,25 @@ public  int numberOfNodesInClade(int node) {
 		count++; //count node itself
 		return count;
 	}
+
+    public Vector<Integer> nodesInClade(int node) {
+        Vector<Integer> nodes = new Vector();
+        String[] parsedNodes = nodesInCladeAsString(node,null).split(",");
+        for (String nodeString : parsedNodes) {
+            nodes.add(Integer.parseInt(nodeString));
+        }
+        return nodes;
+    }
+
+    private String nodesInCladeAsString(int node, String nodes) {
+        if (nodes == null) {
+            nodes = String.valueOf(node);
+        }
+        for (int d = firstDaughterOfNode(node); nodeExists(d); d = nextSisterOfNode(d)) {
+            nodes = nodesInCladeAsString(d, nodes) + "," + d;
+        }
+        return nodes;
+    }
 	/*-----------------------------------------*/
 	/** Returns number of terminal taxa in clade.*/
 	public  int numberOfTerminalsInClade(int node) {
@@ -5583,7 +5602,16 @@ public String getNodeLabel(int node){
 		return label[node];
 	}
 	/*-----------------------------------------*/
-	/** Returns whether the node has a label */
+    public void setStringPropertyOnNode(String propName, String propVal, int node){
+        this.setAssociatedObject(new NameReference(propName),node, propVal);
+    }
+    /*-----------------------------------------*/
+    /** Gets the node label of the node */
+    public String getStringPropertyOnNode(String prop, int node){
+        ObjectArray props = this.getAssociatedObjects(node);
+        return "";
+    }
+    /** Returns whether the node has a label */
 	public boolean nodeHasLabel(int node){
 		return (label!=null && nodeExists(node) && label[node]!=null) || (nodeIsTerminal(node));
 	}

Source/mesquite/lib/TreeDisplay.java

@@ -146,7 +146,17 @@ public Color getBranchColor(int N){
 		}
 	}
 
-	public Composite setBranchTransparency(Graphics g, int N){
+    public int getBranchWidth(int node){
+        long result = tree.getAssociatedLong(NameReference.getNameReference("width"), node);
+
+        if (result == MesquiteLong.unassigned) {
+            return 0;
+        }
+        return (int) result;
+    }
+
+
+    public Composite setBranchTransparency(Graphics g, int N){
 		if (!showBranchColors)
 			return null;
 		if (tree.anySelected() && !tree.getSelected(N)) {

Source/mesquite/lib/TreeDrawing.java

@@ -14,6 +14,7 @@
 package mesquite.lib;
 
 import java.awt.*;
+import java.awt.geom.Line2D;
 
 import mesquite.lib.duties.*;
 import mesquite.trees.lib.TaxonPolygon;
@@ -37,7 +38,13 @@ public abstract class TreeDrawing  {
 	public final static int MINNODEWIDTH = 6;
 	public final static int ACCEPTABLETOUCHWIDTH = 10;
 	public final static boolean SHOWTOUCHPOLYS = false;
-	public int[] x; //x positions of nodes
+    public final static int UP = 0;
+    public final static int DOWN = 1;
+    public final static int RIGHT = 2;
+    public final static int LEFT = 3;
+    public final static int ALLNODES = -1;
+
+    public int[] x; //x positions of nodes
 	public int[] y; //y positions of nodes
 	public double[] z; //z positions of nodes (closeness to viewer, smaller numbers closer)
 	public int[] lineBaseX; //base of line on which to draw labels etc.
@@ -94,6 +101,10 @@ public void resetNumNodes(int numNodes){
 		}
 	}
 
+    public void setProperty(int node, String property, String value) {
+        MesquiteModule.mesquiteTrunk.logln("setProperty called on "+property+", but this property does not exist in "+this.getClass().toString());
+    }
+
 	public int getDrawnRoot(){
 		return drawnRoot;
 	}
@@ -139,7 +150,136 @@ public int getNodeValueTextBaseY(int node, int edgewidth, int stringwidth, int f
 	public abstract void fillBranch(Tree tree, int N, Graphics g);
 
 
-	/*_________________________________________________*/
+    public void rotateFromUp(Polygon poly, Point origin, int to_orientation) {
+        poly.translate(-origin.x,-origin.y);
+        for(int i=0;i<poly.npoints;i++) {
+            int old_x = poly.xpoints[i];
+            int old_y = poly.ypoints[i];
+            if (to_orientation == RIGHT) {
+                poly.xpoints[i] = -old_y;
+                poly.ypoints[i] = old_x;
+            } else if (to_orientation == DOWN) {
+                poly.xpoints[i] = -old_x;
+                poly.ypoints[i] = -old_y;
+            } else if (to_orientation == LEFT) {
+                poly.xpoints[i] = old_y;
+                poly.ypoints[i] = -old_x;
+            }
+        }
+        poly.translate(origin.x,origin.y);
+        poly.invalidate();
+    }
+
+    public void rotatePoly(Polygon poly, Point origin, double angle) {
+        poly.translate(-origin.x,-origin.y);
+        for(int i=0;i<poly.npoints;i++) {
+            double old_x = poly.xpoints[i];
+            double old_y = poly.ypoints[i];
+            double radius = 0;
+            double old_angle = 0;
+            if (old_x == 0) {
+                if (old_y > 0) {
+                    old_angle = Math.PI * 0.5;
+                    radius = old_y;
+                } else if (old_y < 0) {
+                    old_angle = Math.PI * 1.5;
+                    radius = -old_y;
+                }
+            } else if (old_y == 0) {
+                if (old_x >= 0) {
+                    radius = old_x;
+                } else {
+                    radius = -old_x;
+                    old_angle = Math.PI;
+                }
+            } else {
+                double t = old_y/old_x;
+                old_angle = Math.atan(t);
+                radius = Math.sqrt((old_x*old_x)+(old_y*old_y));
+            }
+            double new_angle = angle - old_angle;
+            poly.xpoints[i] = (int)(radius * (Math.cos(new_angle)));
+            poly.ypoints[i] = (int)(radius * (Math.sin(new_angle)));
+        }
+        poly.translate(origin.x,origin.y);
+        poly.invalidate();
+    }
+
+    public void rotateLine2D(Line2D.Double line, Point origin, double angle) {
+
+        Polygon poly = new Polygon();
+        poly.addPoint((int)line.x1,(int)line.y1);
+        poly.addPoint((int)line.x2,(int)line.y2);
+        poly.translate(-origin.x,-origin.y);
+        for(int i=0;i<poly.npoints;i++) {
+            double old_x = poly.xpoints[i];
+            double old_y = poly.ypoints[i];
+            double radius = 0;
+            double old_angle = 0;
+            if (old_x == 0) {
+                if (old_y > 0) {
+                    old_angle = Math.PI * 0.5;
+                    radius = old_y;
+                } else if (old_y < 0) {
+                    old_angle = Math.PI * 1.5;
+                    radius = -old_y;
+                }
+            } else if (old_y == 0) {
+                if (old_x >= 0) {
+                    radius = old_x;
+                } else {
+                    radius = -old_x;
+                    old_angle = Math.PI;
+                }
+            } else {
+                double t = old_y/old_x;
+                old_angle = Math.atan(t);
+                radius = Math.sqrt((old_x*old_x)+(old_y*old_y));
+            }
+            double new_angle = angle - old_angle;
+            poly.xpoints[i] = (int)(radius * (Math.cos(new_angle)));
+            poly.ypoints[i] = (int)(radius * (Math.sin(new_angle)));
+        }
+        poly.translate(origin.x,origin.y);
+        poly.invalidate();
+        line.x1 = poly.xpoints[0];
+        line.x2 = poly.xpoints[1];
+        line.y1 = poly.ypoints[0];
+        line.y2 = poly.ypoints[1];
+    }
+
+
+    public Point pointRotatedFromUp(int to_orientation, Point origin, Point point) {
+        int old_x = point.x-origin.x;
+        int old_y = point.y-origin.y;
+        Point result = new Point(old_x,old_y);
+        if (to_orientation == RIGHT) {
+            result.move(-old_y,old_x);
+        } else if (to_orientation == DOWN) {
+            result.move(-old_x, -old_y);
+        } else if (to_orientation == LEFT) {
+            result.move(old_y, -old_x);
+        }
+        result.translate(origin.x, origin.y);
+        return result;
+    }
+
+    public Point pointRotatedToUp(int from_orientation, Point origin, Point point) {
+        int old_x = point.x-origin.x;
+        int old_y = point.y-origin.y;
+        Point result = new Point(old_x,old_y);
+        if (from_orientation == RIGHT) {
+            result.move(old_y, -old_x);
+        } else if (from_orientation == DOWN) {
+            result.move(-old_x, -old_y);
+        } else if (from_orientation == LEFT) {
+            result.move(-old_y, old_x);
+        }
+        result.translate(origin.x, origin.y);
+        return result;
+    }
+
+    /*_________________________________________________*/
 	/** Does the basic inverting of the color of a branch **/
 	public  void fillBranchInverted (Tree tree, int N, Graphics g) {
 		if (GraphicsUtil.useXORMode(g, true))  {

Source/mesquite/trees/BasicDrawTaxonNames/BasicDrawTaxonNames.java

@@ -439,11 +439,16 @@ else if (taxonNumber>=taxa.getNumTaxa()) {
 			//check all extras to see if they want to add anything
 			boolean underlined = false;
 			Color taxonColor;
-			if (!tree.anySelected() || tree.getSelected(N))
-				taxonColor = fontColor;
-			else
+			if (!tree.anySelected() || tree.getSelected(N)) {
+                long result = tree.getAssociatedLong(NameReference.getNameReference("taxoncolor"), N);
+                if (result == MesquiteLong.unassigned) {
+                    taxonColor = fontColor;
+                } else {
+                    taxonColor = ColorDistribution.getStandardColor((int) result);
+                }
+            } else {
 				taxonColor = fontColorLight;
-
+            }
 			if (partitions!=null && (colorPartition.getValue() || shadePartition.getValue())){
 				TaxaGroup mi = (TaxaGroup)partitions.getProperty(taxonNumber);
 				if (mi!=null) {

Source/mesquite/trees/BasicTreeDrawCoordinator/BasicTreeDrawCoordinator.java

@@ -674,7 +674,8 @@ public void paint(Graphics g) {
 		if (ownerModule == null || ownerModule.isDoomed())
 			return;
 		setShowBranchColors(ownerDrawModule.showBranchColors.getValue());
-		if (MesquiteWindow.checkDoomed(this)) 
+        ((Graphics2D) g).setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+        if (MesquiteWindow.checkDoomed(this))
 			return;
 		setDrawingInProcess(true);
 		int initialPending = repaintsPending;

Source/mesquite/trees/BasicTreeWindowMaker/BasicTreeWindowMaker.java

@@ -2359,7 +2359,10 @@ public Object doCommand(String commandName, String arguments, CommandChecker che
 		else if (checker.compare(this.getClass(), "Returns the tree info panel", null, commandName, "getInfoPanel")) {
 			return treeInfoPanel;
 		}
-		else if (checker.compare(this.getClass(), "Returns analyses at nodes as a table", null, commandName, "getAsTable")) {
+        else if (checker.compare(this.getClass(), "Returns the tree pane size", null, commandName, "getTreePaneSize")) {
+            return new Dimension(getTreePaneWidth(),getTreePaneHeight());
+        }
+        else if (checker.compare(this.getClass(), "Returns analyses at nodes as a table", null, commandName, "getAsTable")) {
 			if (treeDisplay == null)
 				return null;
 			String s = treeDisplay.getTableVersion();