import jalview.api.AlignViewportI;
import jalview.commands.CommandI;
import jalview.commands.OrderCommand;
+import jalview.datamodel.AlignmentI;
import jalview.datamodel.ColumnSelection;
import jalview.datamodel.HiddenColumns;
import jalview.datamodel.SequenceGroup;
import jalview.datamodel.SequenceI;
-import jalview.ext.treeviewer.ExternalTreeFrame;
-import jalview.ext.treeviewer.ExternalTreeI;
-import jalview.ext.treeviewer.ExternalTreeNodeI;
-import jalview.ext.treeviewer.ExternalTreePanel;
-import jalview.ext.treeviewer.ExternalTreeViewerBindingI;
+import jalview.ext.treeviewer.LoadedTreeSequenceAssociation;
+import jalview.ext.treeviewer.TreeFrameI;
+import jalview.ext.treeviewer.TreeI;
+import jalview.ext.treeviewer.TreeNodeI;
+import jalview.ext.treeviewer.TreePanelI;
+import jalview.ext.treeviewer.TreeViewerBindingI;
+import jalview.ext.treeviewer.TreeViewerUtils;
import jalview.gui.AlignViewport;
import jalview.gui.AlignmentPanel;
import jalview.gui.Desktop;
import jalview.viewmodel.AlignmentViewport;
import java.awt.Color;
+import java.awt.Rectangle;
import java.awt.event.ActionEvent;
import java.awt.event.InputEvent;
import java.awt.event.MouseEvent;
*
*/
public final class JalviewBinding
- implements ExternalTreeViewerBindingI
+ implements TreeViewerBindingI
{
- private final ExternalTreeFrame aptxFrame;
+ private final TreeFrameI aptxFrame;
- private ExternalTreePanel treeView;
+ private TreePanelI treeView;
private AlignmentViewport parentAvport;
private final StructureSelectionManager ssm;
- private AlignmentPanel[] associatedPanels;
+ private Map<SequenceI, TreeNodeI> sequencesBoundToNodes;
- private Map<SequenceI, ExternalTreeNodeI> sequencesBoundToNodes;
-
- private Map<ExternalTreeNodeI, SequenceI> nodesBoundToSequences;
+ private Map<TreeNodeI, SequenceI> nodesBoundToSequences;
private float rootX;
* map with tree nodes and matching sequences used to calculate the
* tree as key, value pair respectively.
*/
- public JalviewBinding(final ExternalTreeFrame archaeopteryx,
+ public JalviewBinding(final TreeFrameI archaeopteryx,
final AlignmentViewport jalviewAlignmentViewport,
- final Map<SequenceI, ExternalTreeNodeI> alignMappedToNodes,
- final Map<ExternalTreeNodeI, SequenceI> nodesMappedToAlign)
+ final Map<SequenceI, TreeNodeI> alignMappedToNodes,
+ final Map<TreeNodeI, SequenceI> nodesMappedToAlign)
{
if (archaeopteryx.getNumberOfTrees() > 1)
treeView = archaeopteryx.getTreePanel();
ssm = parentAvport.getStructureSelectionManager();
+ aptxFrame.setViewBinding(this);
ssm.addSelectionListener(this);
treeView.addMouseListener(this);
+ treeView.registerWithPaintRefresher(
+ parentAvport.getSequenceSetId());
- PaintRefresher.Register(treeView, parentAvport.getSequenceSetId());
- associatedPanels = PaintRefresher
- .getAssociatedPanels(parentAvport.getSequenceSetId());
-
- aptxFrame.addInternalFrameListener(new InternalFrameAdapter()
+ aptxFrame.addFrameListener(new InternalFrameAdapter()
{
@Override
public void internalFrameClosed(InternalFrameEvent e)
{
- AptxInit.getAllAptxFrames().remove(aptxFrame);
+ TreeViewerUtils.getActiveTreeViews().remove(aptxFrame);
ssm.removeSelectionListener(JalviewBinding.this);
}
@Override
public void actionPerformed(ActionEvent e)
{
- // aptxFrame.actionPerformed(e);
+ // reset hidden sequences first
+ parentAvport.showAllHiddenSeqs();
+
+ if (treeView.showingSubTree())
+ {
+ LoadedTreeSequenceAssociation bindAptxNodes = new LoadedTreeSequenceAssociation(
+ parentAvport.getAlignment().getSequencesArray(),
+ treeView.getTree());
+ bindAptxNodes.associateNodesToSequences();
+ sequencesBoundToNodes = bindAptxNodes.getAlignmentWithNodes();
+ nodesBoundToSequences = bindAptxNodes.getNodesWithAlignment();
+ TreeViewerUtils.associateNodesWithJalviewSequences(aptxFrame,
+ parentAvport, sequencesBoundToNodes, nodesBoundToSequences);
+
+ for (SequenceI seq : parentAvport.getAlignment().getSequencesArray())
+ {
+ if (!sequencesBoundToNodes.containsKey(seq))
+ {
+ parentAvport.hideSequence(new SequenceI[] { seq });
+ }
+ }
+ }
+
+ else
+ {
+
+ Rectangle visibleView = treeView.getVisibleArea();
+
+ for (TreeNodeI node : treeView.getTree().getRoot()
+ .getAllDescendants())
+ {
+ if (!(node.getXcoord() > visibleView.getMinX()
+ && node.getXcoord() < visibleView.getMaxX()
+ && node.getYcoord() > visibleView.getMinY()
+ && node.getYcoord() < visibleView.getMaxY()))
+ {
+ parentAvport
+ .hideSequence(new SequenceI[]
+ { nodesBoundToSequences.get(node) });
+ }
+ }
+
+ }
+
+
}
*/
public void run()
{
- final ExternalTreeNodeI node = treeView.findNode(e.getX(),
+ final TreeNodeI node = treeView.findNode(e.getX(),
e.getY());
if (node != null)
{
partitionTree(e.getX());
}
- PaintRefresher.Refresh(treeView, parentAvport.getSequenceSetId());
+ treeView.notifyPaintRefresher(parentAvport.getSequenceSetId(),
+ false, false);
treeView.repaint();
for (SequenceI selectedSequence : seqsel.getSequences())
{
- ExternalTreeNodeI matchingNode = sequencesBoundToNodes
+ TreeNodeI matchingNode = sequencesBoundToNodes
.get(selectedSequence);
if (matchingNode != null)
{
*/
public void partitionTree(final int x)
{
- ExternalTreeI tree = treeView.getTree();
+ TreeI tree = treeView.getTree();
if (!tree.isEmpty())
{
// should be calculated on each partition as the tree can theoretically
// change in the meantime
- ExternalTreeNodeI furthestNode = tree.getFurthestNode();
+ TreeNodeI furthestNode = tree.getFurthestNode();
furthestNodeX = furthestNode.getXcoord();
rootX = tree.getRoot().getXcoord();
// don't bother if 0 distance tree or clicked x lies outside of tree
- if (furthestNodeX != rootX && !(x > furthestNodeX))
- {
+ // if (furthestNodeX != rootX && !(x > furthestNodeX))
+
float threshold = (x - rootX) / (furthestNodeX - rootX);
- List<ExternalTreeNodeI> foundNodes = getNodesAboveThreshold(
+ List<TreeNodeI> foundNodes = getNodesAboveThreshold(
threshold,
tree.getRoot());
- }
+
}
}
- public List<ExternalTreeNodeI> getNodesAboveThreshold(double threshold,
- ExternalTreeNodeI node)
+ public List<TreeNodeI> getNodesAboveThreshold(float threshold,
+ TreeNodeI node)
{
- List<ExternalTreeNodeI> nodesAboveThreshold = new ArrayList<>();
+ List<TreeNodeI> nodesAboveThreshold = new ArrayList<>();
parentAvport.setSelectionGroup(null);
parentAvport.getAlignment().deleteAllGroups();
* @param node
* @return
*/
- private List<ExternalTreeNodeI> colourNodesAboveThreshold(
- List<ExternalTreeNodeI> nodeList, double threshold,
- ExternalTreeNodeI node)
+ private List<TreeNodeI> colourNodesAboveThreshold(
+ List<TreeNodeI> nodeList, float threshold,
+ TreeNodeI node)
{
- for (ExternalTreeNodeI childNode : node.getDirectChildren())
+ for (TreeNodeI childNode : node.getDirectChildren())
{
childNode.setBranchColor(Color.black);
float nodeCutoff = (childNode.getXcoord() - rootX)
parentAvport.setSequenceColour(seq, randomColour);
}
- List<ExternalTreeNodeI> descendantNodes = childNode
+ List<TreeNodeI> descendantNodes = childNode
.getAllDescendants();
// .forEach instead?
- for (ExternalTreeNodeI descNode : descendantNodes)
+ for (TreeNodeI descNode : descendantNodes)
{
seq = nodesBoundToSequences.get(descNode);
if (seq != null)
}
}
-
- for (AlignmentPanel associatedPanel : associatedPanels) {
+ for (AlignmentPanel associatedPanel : getAssociatedPanels())
+ {
associatedPanel.updateAnnotation();
treeGroup.setName("Tree Group " + nrTreeGroups);
treeGroup.setIdColour(groupColour);
- for (AlignmentPanel associatedPanel : associatedPanels)
+ for (AlignmentPanel associatedPanel : getAssociatedPanels())
{
AlignViewportI altViewport = associatedPanel
.getAlignViewport();
}
- /**
- * may or may not need an extra repaint on the alignment view (check what kira
- * does)
- */
+
@Override
- public void showNodeSelectionOnAlign(final ExternalTreeNodeI node)
+ public void showNodeSelectionOnAlign(final TreeNodeI node)
{
if (node.isInternal())
@Override
- public void showMatchingSequence(final ExternalTreeNodeI nodeToMatch)
+ public void showMatchingSequence(final TreeNodeI nodeToMatch)
{
SequenceI matchingSequence = nodesBoundToSequences.get(nodeToMatch);
if (matchingSequence != null)
}
@Override
- public void showMatchingChildSequences(final ExternalTreeNodeI parentNode)
+ public void showMatchingChildSequences(final TreeNodeI parentNode)
{
// redundancy here, Forester already iterates through tree to get all
// descendants
- List<ExternalTreeNodeI> childNodes = parentNode.getAllDescendants();
+ List<TreeNodeI> childNodes = parentNode.getAllDescendants();
- for (ExternalTreeNodeI childNode : childNodes)
+ for (TreeNodeI childNode : childNodes)
{
- // childNode.getBranchData().setBranchColor(new BranchColor(Color.BLUE));
-
SequenceI matchingSequence = nodesBoundToSequences.get(childNode);
if (matchingSequence != null)
{
}
- /**
- * Refactored from TreeCanvas.
- *
- * @param sequence
- * of the node selected in the tree viewer.
- */
+
@Override
public void treeSelectionChanged(final SequenceI sequence)
{
}
@Override
- public void sortByTree_actionPerformed()// modify for Aptx
+ public void sortByTree_actionPerformed()
{
- // if (treeCanvas.applyToAllViews)
- // {
- // final ArrayList<CommandI> commands = new ArrayList<>();
- // for (AlignmentPanel ap : PaintRefresher
- // .getAssociatedPanels(parentAvport.getSequenceSetId()))
- // {
- // commands.add(sortAlignmentIn(ap.av.getAlignPanel()));
- // }
- // parentAvport.getAlignPanel().alignFrame.addHistoryItem(new CommandI()
- // {
- //
- // @Override
- // public void undoCommand(AlignmentI[] views)
- // {
- // for (CommandI tsort : commands)
- // {
- // tsort.undoCommand(views);
- // }
- // }
- //
- // @Override
- // public int getSize()
- // {
- // return commands.size();
- // }
- //
- // @Override
- // public String getDescription()
- // {
- // return "Tree Sort (many views)";
- // }
- //
- // @Override
- // public void doCommand(AlignmentI[] views)
- // {
- //
- // for (CommandI tsort : commands)
- // {
- // tsort.doCommand(views);
- // }
- // }
- // });
- // for (AlignmentPanel ap : PaintRefresher
- // .getAssociatedPanels(av.getSequenceSetId()))
- // {
- // // ensure all the alignFrames refresh their GI after adding an undo item
- // ap.alignFrame.updateEditMenuBar();
- // }
- // }
- // else
- // {
- // treeCanvas.ap.alignFrame
- // .addHistoryItem(sortAlignmentIn(treeCanvas.ap));
- // }
+ // if (applyToAllViews)
+
+ final ArrayList<CommandI> commands = new ArrayList<>();
+ for (AlignmentPanel ap : PaintRefresher
+ .getAssociatedPanels(parentAvport.getSequenceSetId()))
+ {
+ commands.add(sortAlignmentIn(ap.av.getAlignPanel()));
+ ap.alignFrame.addHistoryItem(new CommandI()
+ {
+
+ @Override
+ public void undoCommand(AlignmentI[] views)
+ {
+ for (CommandI tsort : commands)
+ {
+ tsort.undoCommand(views);
+ }
+ }
+
+ @Override
+ public int getSize()
+ {
+ return commands.size();
+ }
+
+ @Override
+ public String getDescription()
+ {
+ return "Tree Sort (many views)";
+ }
+
+ @Override
+ public void doCommand(AlignmentI[] views)
+ {
+
+ for (CommandI tsort : commands)
+ {
+ tsort.doCommand(views);
+ }
+ }
+ });
+
+ ap.alignFrame.updateEditMenuBar();
+ }
+ }
+ // else
+ // {
+ // alignPanel.alignFrame.addHistoryItem(sortAlignmentIn(alignPanel));
+ // }
+
- }
@Override
public CommandI sortAlignmentIn(AlignmentPanel ap)
{
- // TODO: move to alignment view controller
-
AlignmentViewport viewport = ap.av;
SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
try
public AlignmentPanel[] getAssociatedPanels()
{
- return associatedPanels;
+ return PaintRefresher
+ .getAssociatedPanels(parentAvport.getSequenceSetId());
+ }
+
+ @Override
+ public Map<SequenceI, TreeNodeI> getAlignmentWithNodes()
+ {
+ return sequencesBoundToNodes;
}
- public void setAssociatedPanels(AlignmentPanel[] associatedPanels)
+ @Override
+ public Map<TreeNodeI, SequenceI> getNodesWithAlignment()
{
- this.associatedPanels = associatedPanels;
+ return nodesBoundToSequences;
}
+
}
git://source.jalview.org / jalview.git / blobdiff