+ final void setControlPanel( final ControlPanel atv_control ) {
+ _control_panel = atv_control;
+ }
+
+ void setCurrentExternalNodesDataBuffer( final StringBuilder sb ) {
+ increaseCurrentExternalNodesDataBufferChangeCounter();
+ _current_external_nodes_data_buffer = sb;
+ }
+
+ final void setFoundNodes0( final Set<Long> found_nodes ) {
+ _found_nodes_0 = found_nodes;
+ }
+
+ final void setFoundNodes1( final Set<Long> found_nodes ) {
+ _found_nodes_1 = found_nodes;
+ }
+
+ final void setInOvRect( final boolean in_ov_rect ) {
+ _in_ov_rect = in_ov_rect;
+ }
+
+ final void setLargeFonts() {
+ getTreeFontSet().largeFonts();
+ }
+
+ final void setLastMouseDragPointX( final float x ) {
+ _last_drag_point_x = x;
+ }
+
+ final void setLastMouseDragPointY( final float y ) {
+ _last_drag_point_y = y;
+ }
+
+ final void setLongestExtNodeInfo( final int i ) {
+ _longest_ext_node_info = i;
+ }
+
+ final void setMediumFonts() {
+ getTreeFontSet().mediumFonts();
+ }
+
+ final void setNodeInPreorderToNull() {
+ _nodes_in_preorder = null;
+ }
+
+ final void setOvOn( final boolean ov_on ) {
+ _ov_on = ov_on;
+ }
+
+ final void setPhylogenyGraphicsType( final PHYLOGENY_GRAPHICS_TYPE graphics_type ) {
+ _graphics_type = graphics_type;
+ setTextAntialias();
+ }
+
+ final void setSmallFonts() {
+ getTreeFontSet().smallFonts();
+ }
+
+ final void setStartingAngle( final double starting_angle ) {
+ _urt_starting_angle = starting_angle;
+ }
+
+ void setStatisticsForExpressionValues( final DescriptiveStatistics statistics_for_expression_values ) {
+ _statistics_for_vector_data = statistics_for_expression_values;
+ }
+
+ final void setSuperTinyFonts() {
+ getTreeFontSet().superTinyFonts();
+ }
+
+ final void setTextAntialias() {
+ if ( ( _phylogeny != null ) && !_phylogeny.isEmpty() ) {
+ if ( _phylogeny.getNumberOfExternalNodes() <= LIMIT_FOR_HQ_RENDERING ) {
+ _rendering_hints.put( RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY );
+ }
+ else {
+ _rendering_hints.put( RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_SPEED );
+ }
+ }
+ if ( getMainPanel().getOptions().isAntialiasScreen() ) {
+ _rendering_hints.put( RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON );
+ // try {
+ _rendering_hints.put( RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_LCD_HRGB );
+ // }
+ // catch ( final Throwable e ) {
+ // _rendering_hints.put( RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON );
+ //}
+ }
+ else {
+ _rendering_hints.put( RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_OFF );
+ _rendering_hints.put( RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF );
+ }
+ }
+
+ final void setTinyFonts() {
+ getTreeFontSet().tinyFonts();
+ }
+
+ final void setTreeFile( final File treefile ) {
+ _treefile = treefile;
+ }
+
+ final void setXcorrectionFactor( final float f ) {
+ _x_correction_factor = f;
+ }
+
+ final void setXdistance( final float x ) {
+ _x_distance = x;
+ }
+
+ final void setYdistance( final float y ) {
+ _y_distance = y;
+ }
+
+ final void sortDescendants( final PhylogenyNode node ) {
+ if ( !node.isExternal() ) {
+ DESCENDANT_SORT_PRIORITY pri = DESCENDANT_SORT_PRIORITY.TAXONOMY;
+ if ( ( !getControlPanel().isShowTaxonomyScientificNames() && !getControlPanel().isShowTaxonomyCode() && !getControlPanel()
+ .isShowTaxonomyCommonNames() ) ) {
+ if ( ( getControlPanel().isShowSequenceAcc() || getControlPanel().isShowSeqNames() || getControlPanel()
+ .isShowSeqSymbols() ) ) {
+ pri = DESCENDANT_SORT_PRIORITY.SEQUENCE;
+ }
+ else if ( getControlPanel().isShowNodeNames() ) {
+ pri = DESCENDANT_SORT_PRIORITY.NODE_NAME;
+ }
+ }
+ PhylogenyMethods.sortNodeDescendents( node, pri );
+ setNodeInPreorderToNull();
+ _phylogeny.externalNodesHaveChanged();
+ _phylogeny.clearHashIdToNodeMap();
+ _phylogeny.recalculateNumberOfExternalDescendants( true );
+ resetNodeIdToDistToLeafMap();
+ setEdited( true );
+ }
+ repaint();
+ }
+
+ final void subTree( final PhylogenyNode node ) {
+ if ( getPhylogenyGraphicsType() == PHYLOGENY_GRAPHICS_TYPE.UNROOTED ) {
+ JOptionPane.showMessageDialog( this,
+ "Cannot get a sub/super tree in unrooted display",
+ "Attempt to get sub/super tree in unrooted display",
+ JOptionPane.WARNING_MESSAGE );
+ return;
+ }
+ if ( node.isExternal() ) {
+ JOptionPane.showMessageDialog( this,
+ "Cannot get a subtree of a external node",
+ "Attempt to get subtree of external node",
+ JOptionPane.WARNING_MESSAGE );
+ return;
+ }
+ if ( node.isRoot() && !isCurrentTreeIsSubtree() ) {
+ JOptionPane.showMessageDialog( this,
+ "Cannot get a subtree of the root node",
+ "Attempt to get subtree of root node",
+ JOptionPane.WARNING_MESSAGE );
+ return;
+ }
+ setNodeInPreorderToNull();
+ if ( !node.isExternal() && !node.isRoot() && ( _subtree_index <= ( TreePanel.MAX_SUBTREES - 1 ) ) ) {
+ _sub_phylogenies[ _subtree_index ] = _phylogeny;
+ _sub_phylogenies_temp_roots[ _subtree_index ] = node;
+ ++_subtree_index;
+ _phylogeny = TreePanelUtil.subTree( node, _phylogeny );
+ updateSubSuperTreeButton();
+ }
+ else if ( node.isRoot() && isCurrentTreeIsSubtree() ) {
+ superTree();
+ }
+ _main_panel.getControlPanel().showWhole();
+ repaint();
+ }
+
+ final void superTree() {
+ setNodeInPreorderToNull();
+ final PhylogenyNode temp_root = _sub_phylogenies_temp_roots[ _subtree_index - 1 ];
+ for( final PhylogenyNode n : temp_root.getDescendants() ) {
+ n.setParent( temp_root );
+ }
+ _sub_phylogenies[ _subtree_index ] = null;
+ _sub_phylogenies_temp_roots[ _subtree_index ] = null;
+ _phylogeny = _sub_phylogenies[ --_subtree_index ];
+ updateSubSuperTreeButton();
+ }
+
+ final void swap( final PhylogenyNode node ) {
+ if ( node.isExternal() || ( node.getNumberOfDescendants() < 2 ) ) {
+ return;
+ }
+ if ( node.getNumberOfDescendants() > 2 ) {
+ JOptionPane.showMessageDialog( this,
+ "Cannot swap descendants of nodes with more than 2 descendants",
+ "Cannot swap descendants",
+ JOptionPane.ERROR_MESSAGE );
+ return;
+ }
+ if ( !node.isExternal() ) {
+ node.swapChildren();
+ setNodeInPreorderToNull();
+ _phylogeny.externalNodesHaveChanged();
+ _phylogeny.clearHashIdToNodeMap();
+ _phylogeny.recalculateNumberOfExternalDescendants( true );
+ resetNodeIdToDistToLeafMap();
+ setEdited( true );
+ }
+ repaint();
+ }
+
+ final void taxColor() {
+ if ( ( _phylogeny == null ) || ( _phylogeny.getNumberOfExternalNodes() < 2 ) ) {
+ return;
+ }
+ setWaitCursor();
+ TreePanelUtil.colorPhylogenyAccordingToExternalTaxonomy( _phylogeny, this );
+ _control_panel.setColorBranches( true );
+ if ( _control_panel.getColorBranchesCb() != null ) {
+ _control_panel.getColorBranchesCb().setSelected( true );
+ }
+ setEdited( true );
+ setArrowCursor();
+ repaint();
+ }
+
+ final void updateOvSettings() {
+ switch ( getOptions().getOvPlacement() ) {
+ case LOWER_LEFT:
+ setOvXPosition( OV_BORDER );
+ setOvYPosition( ForesterUtil.roundToInt( getVisibleRect().height - OV_BORDER - getOvMaxHeight() ) );
+ setOvYStart( ForesterUtil.roundToInt( getOvYPosition() + ( getOvMaxHeight() / 2 ) ) );
+ break;
+ case LOWER_RIGHT:
+ setOvXPosition( ForesterUtil.roundToInt( getVisibleRect().width - OV_BORDER - getOvMaxWidth() ) );
+ setOvYPosition( ForesterUtil.roundToInt( getVisibleRect().height - OV_BORDER - getOvMaxHeight() ) );
+ setOvYStart( ForesterUtil.roundToInt( getOvYPosition() + ( getOvMaxHeight() / 2 ) ) );
+ break;
+ case UPPER_RIGHT:
+ setOvXPosition( ForesterUtil.roundToInt( getVisibleRect().width - OV_BORDER - getOvMaxWidth() ) );
+ setOvYPosition( OV_BORDER );
+ setOvYStart( ForesterUtil.roundToInt( OV_BORDER + ( getOvMaxHeight() / 2 ) ) );
+ break;
+ default:
+ setOvXPosition( OV_BORDER );
+ setOvYPosition( OV_BORDER );
+ setOvYStart( ForesterUtil.roundToInt( OV_BORDER + ( getOvMaxHeight() / 2 ) ) );
+ break;
+ }
+ }
+
+ final void updateOvSizes() {
+ if ( ( getWidth() > ( 1.05 * getVisibleRect().width ) ) || ( getHeight() > ( 1.05 * getVisibleRect().height ) ) ) {
+ setOvOn( true );
+ float l = getLongestExtNodeInfo();
+ final float w_ratio = getOvMaxWidth() / getWidth();
+ l *= w_ratio;
+ final int ext_nodes = _phylogeny.getRoot().getNumberOfExternalNodes();
+ setOvYDistance( getOvMaxHeight() / ( 2 * ext_nodes ) );
+ float ov_xdist = 0;
+ if ( !isNonLinedUpCladogram() && !isUniformBranchLengthsForCladogram() ) {
+ ov_xdist = ( ( getOvMaxWidth() - l ) / ( ext_nodes ) );
+ }
+ else {
+ ov_xdist = ( ( getOvMaxWidth() - l ) / ( PhylogenyMethods.calculateMaxDepth( _phylogeny ) ) );
+ }
+ float ydist = ( float ) ( ( getOvMaxWidth() / ( ext_nodes * 2.0 ) ) );
+ if ( ov_xdist < 0.0 ) {
+ ov_xdist = 0.0f;
+ }
+ if ( ydist < 0.0 ) {
+ ydist = 0.0f;
+ }
+ setOvXDistance( ov_xdist );
+ final double height = _phylogeny.getHeight();
+ if ( height > 0 ) {
+ final float ov_corr = ( float ) ( ( ( getOvMaxWidth() - l ) - getOvXDistance() ) / height );
+ setOvXcorrectionFactor( ov_corr > 0 ? ov_corr : 0 );
+ }
+ else {
+ setOvXcorrectionFactor( 0 );
+ }
+ }
+ else {
+ setOvOn( false );
+ }
+ }
+
+ void updateSetOfCollapsedExternalNodes() {
+ final Phylogeny phy = getPhylogeny();
+ _collapsed_external_nodeid_set.clear();
+ if ( phy != null ) {
+ E: for( final PhylogenyNodeIterator it = phy.iteratorExternalForward(); it.hasNext(); ) {
+ final PhylogenyNode ext_node = it.next();
+ PhylogenyNode n = ext_node;
+ while ( !n.isRoot() ) {
+ if ( n.isCollapse() ) {
+ _collapsed_external_nodeid_set.add( ext_node.getId() );
+ ext_node.setCollapse( true );
+ continue E;
+ }
+ n = n.getParent();
+ }
+ }
+ }
+ }
+
+ final void updateSubSuperTreeButton() {
+ if ( _subtree_index < 1 ) {
+ getControlPanel().deactivateButtonToReturnToSuperTree();
+ }
+ else {
+ getControlPanel().activateButtonToReturnToSuperTree( _subtree_index );
+ }
+ }
+
+ final void zoomInDomainStructure() {
+ if ( _domain_structure_width < 2000 ) {
+ _domain_structure_width *= 1.2;
+ }
+ }
+
+ final void zoomOutDomainStructure() {
+ if ( _domain_structure_width > 20 ) {
+ _domain_structure_width *= 0.8;
+ }
+ }
+
+ private void abbreviateScientificName( final String sn ) {
+ final String[] a = sn.split( "\\s+" );
+ _sb.append( a[ 0 ].substring( 0, 1 ) );
+ _sb.append( a[ 1 ].substring( 0, 2 ) );
+ if ( a.length > 2 ) {
+ for( int i = 2; i < a.length; i++ ) {
+ _sb.append( " " );
+ _sb.append( a[ i ] );
+ }
+ }
+ }
+
+ final private void addEmptyNode( final PhylogenyNode node ) {
+ if ( getPhylogenyGraphicsType() == PHYLOGENY_GRAPHICS_TYPE.UNROOTED ) {
+ errorMessageNoCutCopyPasteInUnrootedDisplay();
+ return;
+ }
+ final String label = createASimpleTextRepresentationOfANode( node );
+ String msg = "";
+ if ( ForesterUtil.isEmpty( label ) ) {
+ msg = "How to add the new, empty node?";
+ }
+ else {
+ msg = "How to add the new, empty node to node" + label + "?";
+ }
+ final Object[] options = { "As sibling", "As descendant", "Cancel" };
+ final int r = JOptionPane.showOptionDialog( this,
+ msg,
+ "Addition of Empty New Node",
+ JOptionPane.CLOSED_OPTION,
+ JOptionPane.QUESTION_MESSAGE,
+ null,
+ options,
+ options[ 2 ] );
+ boolean add_as_sibling = true;
+ if ( r == 1 ) {
+ add_as_sibling = false;
+ }
+ else if ( r != 0 ) {
+ return;
+ }
+ final Phylogeny phy = new Phylogeny();
+ phy.setRoot( new PhylogenyNode() );
+ phy.setRooted( true );
+ if ( add_as_sibling ) {
+ if ( node.isRoot() ) {
+ JOptionPane.showMessageDialog( this,
+ "Cannot add sibling to root",
+ "Attempt to add sibling to root",
+ JOptionPane.ERROR_MESSAGE );
+ return;
+ }
+ phy.addAsSibling( node );
+ }
+ else {
+ phy.addAsChild( node );
+ }
+ setNodeInPreorderToNull();
+ _phylogeny.externalNodesHaveChanged();
+ _phylogeny.clearHashIdToNodeMap();
+ _phylogeny.recalculateNumberOfExternalDescendants( true );
+ resetNodeIdToDistToLeafMap();
+ setEdited( true );
+ repaint();
+ }
+
+ final private void addToCurrentExternalNodes( final long i ) {
+ if ( _current_external_nodes == null ) {
+ _current_external_nodes = new HashSet<Long>();
+ }
+ _current_external_nodes.add( i );
+ }
+
+ final private void assignGraphicsForBranchWithColorForParentBranch( final PhylogenyNode node,
+ final boolean is_vertical,
+ final Graphics g,
+ final boolean to_pdf,
+ final boolean to_graphics_file ) {
+ final NodeClickAction action = _control_panel.getActionWhenNodeClicked();
+ if ( ( to_pdf || to_graphics_file ) && getOptions().isPrintBlackAndWhite() ) {
+ g.setColor( Color.BLACK );
+ }
+ else if ( ( ( action == NodeClickAction.COPY_SUBTREE ) || ( action == NodeClickAction.CUT_SUBTREE )
+ || ( action == NodeClickAction.DELETE_NODE_OR_SUBTREE ) || ( action == NodeClickAction.PASTE_SUBTREE ) || ( action == NodeClickAction.ADD_NEW_NODE ) )
+ && ( getCutOrCopiedTree() != null )
+ && ( getCopiedAndPastedNodes() != null )
+ && !to_pdf
+ && !to_graphics_file && getCopiedAndPastedNodes().contains( node.getId() ) ) {
+ g.setColor( getTreeColorSet().getFoundColor0() );
+ }
+ else if ( getControlPanel().isColorBranches() && ( PhylogenyMethods.getBranchColorValue( node ) != null ) ) {
+ g.setColor( PhylogenyMethods.getBranchColorValue( node ) );
+ }
+ else if ( to_pdf ) {
+ g.setColor( getTreeColorSet().getBranchColorForPdf() );
+ }
+ else {
+ g.setColor( getTreeColorSet().getBranchColor() );
+ }
+ }
+
+ final private void blast( final PhylogenyNode node ) {
+ if ( !isCanBlast( node ) ) {
+ JOptionPane.showMessageDialog( this,
+ "Insufficient information present",
+ "Cannot Blast",
+ JOptionPane.INFORMATION_MESSAGE );
+ return;
+ }
+ else {
+ final String query = Blast.obtainQueryForBlast( node );
+ System.out.println( "query for BLAST is: " + query );
+ char type = '?';
+ if ( !ForesterUtil.isEmpty( query ) ) {
+ if ( node.getNodeData().isHasSequence() ) {
+ if ( !ForesterUtil.isEmpty( node.getNodeData().getSequence().getType() ) ) {
+ if ( node.getNodeData().getSequence().getType().toLowerCase()
+ .equals( PhyloXmlUtil.SEQ_TYPE_PROTEIN ) ) {
+ type = 'p';
+ }
+ else {
+ type = 'n';
+ }
+ }
+ else if ( !ForesterUtil.isEmpty( node.getNodeData().getSequence().getMolecularSequence() ) ) {
+ if ( ForesterUtil.seqIsLikelyToBeAa( node.getNodeData().getSequence().getMolecularSequence() ) ) {
+ type = 'p';
+ }
+ else {
+ type = 'n';
+ }
+ }
+ }
+ if ( type == '?' ) {
+ if ( SequenceAccessionTools.isProteinDbQuery( query ) ) {
+ type = 'p';
+ }
+ else {
+ type = 'n';
+ }
+ }
+ JApplet applet = null;
+ if ( isApplet() ) {
+ applet = obtainApplet();
+ }
+ try {
+ Blast.openNcbiBlastWeb( query, type == 'n', applet, this );
+ }
+ catch ( final Exception e ) {
+ e.printStackTrace();
+ }
+ if ( Constants.ALLOW_DDBJ_BLAST ) {
+ try {
+ System.out.println( "trying: " + query );
+ final Blast s = new Blast();
+ s.ddbjBlast( query );
+ }
+ catch ( final Exception e ) {
+ e.printStackTrace();
+ }
+ }
+ }
+ }
+ }
+
+ private final int calcDynamicHidingFactor() {
+ return ( int ) ( 0.5 + ( getTreeFontSet()._fm_large.getHeight() / ( 1.5 * getYdistance() ) ) );
+ }
+
+ /**
+ * Calculate the length of the distance between the given node and its
+ * parent.
+ *
+ * @param node
+ * @param ext_node_x
+ * @factor
+ * @return the distance value
+ */
+ final private float calculateBranchLengthToParent( final PhylogenyNode node, final float factor ) {
+ if ( getControlPanel().isDrawPhylogram() ) {
+ if ( node.getDistanceToParent() < 0.0 ) {
+ return 0.0f;
+ }
+ return ( float ) ( getXcorrectionFactor() * node.getDistanceToParent() );
+ }
+ else {
+ if ( ( factor == 0 ) || isNonLinedUpCladogram() ) {
+ return getXdistance();
+ }
+ return getXdistance() * factor;
+ }
+ }
+
+ final private Color calculateColorForAnnotation( final SortedSet<Annotation> ann ) {
+ Color c = getTreeColorSet().getAnnotationColor();
+ if ( getControlPanel().isColorAccordingToAnnotation() && ( getControlPanel().getAnnotationColors() != null ) ) {
+ final StringBuilder sb = new StringBuilder();
+ for( final Annotation a : ann ) {
+ sb.append( !ForesterUtil.isEmpty( a.getRefValue() ) ? a.getRefValue() : a.getDesc() );
+ }
+ final String ann_str = sb.toString();
+ if ( !ForesterUtil.isEmpty( ann_str ) ) {
+ c = getControlPanel().getAnnotationColors().get( ann_str );
+ if ( c == null ) {
+ c = TreePanelUtil.calculateColorFromString( ann_str, false );
+ getControlPanel().getAnnotationColors().put( ann_str, c );
+ }
+ if ( c == null ) {
+ c = getTreeColorSet().getAnnotationColor();
+ }
+ }
+ }
+ return c;
+ }
+
+ final private float calculateOvBranchLengthToParent( final PhylogenyNode node, final int factor ) {
+ if ( getControlPanel().isDrawPhylogram() ) {
+ if ( node.getDistanceToParent() < 0.0 ) {
+ return 0.0f;
+ }
+ return ( float ) ( getOvXcorrectionFactor() * node.getDistanceToParent() );
+ }
+ else {
+ if ( ( factor == 0 ) || isNonLinedUpCladogram() ) {
+ return getOvXDistance();
+ }
+ return getOvXDistance() * factor;
+ }
+ }
+
+ final private void cannotOpenBrowserWarningMessage( final String type_type ) {
+ JOptionPane.showMessageDialog( this,
+ "Cannot launch web browser for " + type_type + " data of this node",
+ "Cannot launch web browser",
+ JOptionPane.WARNING_MESSAGE );
+ }
+
+ final private void colorizeSubtree( final Color c,
+ final PhylogenyNode node,
+ final List<PhylogenyNode> additional_nodes ) {
+ _control_panel.setColorBranches( true );
+ if ( _control_panel.getColorBranchesCb() != null ) {
+ _control_panel.getColorBranchesCb().setSelected( true );
+ }
+ if ( node != null ) {
+ for( final PreorderTreeIterator it = new PreorderTreeIterator( node ); it.hasNext(); ) {
+ it.next().getBranchData().setBranchColor( new BranchColor( c ) );
+ }
+ }
+ if ( additional_nodes != null ) {
+ for( final PhylogenyNode n : additional_nodes ) {
+ n.getBranchData().setBranchColor( new BranchColor( c ) );
+ }
+ }
+ repaint();
+ }
+
+ final private void colorSubtree( final PhylogenyNode node ) {
+ if ( getPhylogenyGraphicsType() == PHYLOGENY_GRAPHICS_TYPE.UNROOTED ) {
+ JOptionPane.showMessageDialog( this,
+ "Cannot colorize subtree in unrooted display type",
+ "Attempt to colorize subtree in unrooted display",
+ JOptionPane.WARNING_MESSAGE );
+ return;
+ }
+ _color_chooser.setPreviewPanel( new JPanel() );
+ SubtreeColorizationActionListener al;
+ if ( ( getFoundNodes0() != null ) && !getFoundNodes0().isEmpty() ) {
+ final List<PhylogenyNode> additional_nodes = getFoundNodes0AsListOfPhylogenyNodes();
+ al = new SubtreeColorizationActionListener( _color_chooser, node, additional_nodes );
+ }
+ else {
+ al = new SubtreeColorizationActionListener( _color_chooser, node );
+ }
+ final JDialog dialog = JColorChooser
+ .createDialog( this, "Subtree colorization", true, _color_chooser, al, null );
+ dialog.setVisible( true );
+ }
+
+ final private void copySubtree( final PhylogenyNode node ) {
+ if ( getPhylogenyGraphicsType() == PHYLOGENY_GRAPHICS_TYPE.UNROOTED ) {
+ errorMessageNoCutCopyPasteInUnrootedDisplay();
+ return;
+ }
+ setNodeInPreorderToNull();
+ setCutOrCopiedTree( _phylogeny.copy( node ) );
+ final List<PhylogenyNode> nodes = PhylogenyMethods.getAllDescendants( node );
+ final Set<Long> node_ids = new HashSet<Long>( nodes.size() );
+ for( final PhylogenyNode n : nodes ) {
+ node_ids.add( n.getId() );
+ }
+ node_ids.add( node.getId() );
+ setCopiedAndPastedNodes( node_ids );
+ repaint();
+ }
+
+ final private String createASimpleTextRepresentationOfANode( final PhylogenyNode node ) {
+ final String tax = PhylogenyMethods.getSpecies( node );
+ String label = node.getName();
+ if ( !ForesterUtil.isEmpty( label ) && !ForesterUtil.isEmpty( tax ) ) {
+ label = label + " " + tax;
+ }
+ else if ( !ForesterUtil.isEmpty( tax ) ) {
+ label = tax;
+ }
+ else {
+ label = "";
+ }
+ if ( !ForesterUtil.isEmpty( label ) ) {
+ label = " [" + label + "]";
+ }
+ return label;
+ }
+
+ final private void cutSubtree( final PhylogenyNode node ) {
+ if ( getPhylogenyGraphicsType() == PHYLOGENY_GRAPHICS_TYPE.UNROOTED ) {
+ errorMessageNoCutCopyPasteInUnrootedDisplay();
+ return;
+ }
+ if ( node.isRoot() ) {
+ JOptionPane.showMessageDialog( this,
+ "Cannot cut entire tree as subtree",
+ "Attempt to cut entire tree",
+ JOptionPane.ERROR_MESSAGE );
+ return;
+ }
+ final String label = createASimpleTextRepresentationOfANode( node );
+ final int r = JOptionPane.showConfirmDialog( null,
+ "Cut subtree" + label + "?",
+ "Confirm Cutting of Subtree",
+ JOptionPane.YES_NO_OPTION );
+ if ( r != JOptionPane.OK_OPTION ) {
+ return;
+ }
+ setNodeInPreorderToNull();
+ setCopiedAndPastedNodes( null );
+ setCutOrCopiedTree( _phylogeny.copy( node ) );
+ _phylogeny.deleteSubtree( node, true );
+ _phylogeny.clearHashIdToNodeMap();
+ _phylogeny.recalculateNumberOfExternalDescendants( true );
+ resetNodeIdToDistToLeafMap();
+ setEdited( true );
+ repaint();
+ }
+
+ final private void cycleColors() {
+ getMainPanel().getTreeColorSet().cycleColorScheme();
+ for( final TreePanel tree_panel : getMainPanel().getTreePanels() ) {
+ tree_panel.setBackground( getMainPanel().getTreeColorSet().getBackgroundColor() );
+ }
+ }
+
+ final private void decreaseOvSize() {
+ if ( ( getOvMaxWidth() > 20 ) && ( getOvMaxHeight() > 20 ) ) {
+ setOvMaxWidth( getOvMaxWidth() - 5 );
+ setOvMaxHeight( getOvMaxHeight() - 5 );
+ updateOvSettings();
+ getControlPanel().displayedPhylogenyMightHaveChanged( false );
+ }
+ }
+
+ final private void deleteNodeOrSubtree( final PhylogenyNode node ) {
+ if ( getPhylogenyGraphicsType() == PHYLOGENY_GRAPHICS_TYPE.UNROOTED ) {
+ errorMessageNoCutCopyPasteInUnrootedDisplay();
+ return;
+ }
+ if ( node.isRoot() && ( node.getNumberOfDescendants() != 1 ) ) {
+ JOptionPane.showMessageDialog( this,
+ "Cannot delete entire tree",
+ "Attempt to delete entire tree",
+ JOptionPane.ERROR_MESSAGE );
+ return;
+ }
+ final String label = createASimpleTextRepresentationOfANode( node );
+ final Object[] options = { "Node only", "Entire subtree", "Cancel" };
+ final int r = JOptionPane.showOptionDialog( this,
+ "Delete" + label + "?",
+ "Delete Node/Subtree",
+ JOptionPane.CLOSED_OPTION,
+ JOptionPane.QUESTION_MESSAGE,
+ null,
+ options,
+ options[ 2 ] );
+ setNodeInPreorderToNull();
+ boolean node_only = true;
+ if ( r == 1 ) {
+ node_only = false;
+ }
+ else if ( r != 0 ) {
+ return;
+ }
+ if ( node_only ) {
+ PhylogenyMethods.removeNode( node, _phylogeny );
+ }
+ else {
+ _phylogeny.deleteSubtree( node, true );
+ }
+ _phylogeny.externalNodesHaveChanged();
+ _phylogeny.clearHashIdToNodeMap();
+ _phylogeny.recalculateNumberOfExternalDescendants( true );
+ resetNodeIdToDistToLeafMap();
+ setEdited( true );
+ repaint();
+ }
+
+ final private void displayNodePopupMenu( final PhylogenyNode node, final int x, final int y ) {
+ makePopupMenus( node );
+ _node_popup_menu.putClientProperty( NODE_POPMENU_NODE_CLIENT_PROPERTY, node );
+ _node_popup_menu.show( this, x, y );
+ }
+
+ final private void drawArc( final double x,
+ final double y,
+ final double width,
+ final double heigth,
+ final double start_angle,
+ final double arc_angle,
+ final Graphics2D g ) {
+ _arc.setArc( x, y, width, heigth, _180_OVER_PI * start_angle, _180_OVER_PI * arc_angle, Arc2D.OPEN );
+ g.draw( _arc );
+ }
+
+ final private void drawLine( final double x1, final double y1, final double x2, final double y2, final Graphics2D g ) {
+ if ( ( x1 == x2 ) && ( y1 == y2 ) ) {
+ return;
+ }
+ _line.setLine( x1, y1, x2, y2 );
+ g.draw( _line );
+ }
+
+ final private void drawOval( final double x,
+ final double y,
+ final double width,
+ final double heigth,
+ final Graphics2D g ) {
+ _ellipse.setFrame( x, y, width, heigth );
+ g.draw( _ellipse );
+ }
+
+ final private void drawOvalFilled( final double x,
+ final double y,
+ final double width,
+ final double heigth,
+ final Graphics2D g ) {
+ _ellipse.setFrame( x, y, width, heigth );
+ g.fill( _ellipse );
+ }
+
+ final private void drawOvalGradient( final double x,
+ final double y,
+ final double width,
+ final double heigth,
+ final Graphics2D g,
+ final Color color_1,
+ final Color color_2,
+ final Color color_border ) {
+ _ellipse.setFrame( x, y, width, heigth );
+ g.setPaint( new GradientPaint( ( float ) x,
+ ( float ) y,
+ color_1,
+ ( float ) ( x + width ),
+ ( float ) ( y + heigth ),
+ color_2,
+ false ) );
+ g.fill( _ellipse );
+ if ( color_border != null ) {
+ g.setPaint( color_border );
+ g.draw( _ellipse );
+ }
+ }
+
+ final private void drawRect( final float x, final float y, final float width, final float heigth, final Graphics2D g ) {
+ _rectangle.setFrame( x, y, width, heigth );
+ g.draw( _rectangle );
+ }
+
+ final private void drawRectFilled( final double x,
+ final double y,
+ final double width,
+ final double heigth,
+ final Graphics2D g ) {
+ _rectangle.setFrame( x, y, width, heigth );
+ g.fill( _rectangle );
+ }
+
+ final private void drawRectGradient( final double x,
+ final double y,
+ final double width,
+ final double heigth,
+ final Graphics2D g,
+ final Color color_1,
+ final Color color_2,
+ final Color color_border ) {
+ _rectangle.setFrame( x, y, width, heigth );
+ g.setPaint( new GradientPaint( ( float ) x,
+ ( float ) y,
+ color_1,
+ ( float ) ( x + width ),
+ ( float ) ( y + heigth ),
+ color_2,
+ false ) );
+ g.fill( _rectangle );
+ if ( color_border != null ) {
+ g.setPaint( color_border );
+ g.draw( _rectangle );
+ }
+ }
+
+ private double drawTaxonomyImage( final double x, final double y, final PhylogenyNode node, final Graphics2D g ) {
+ final List<Uri> us = new ArrayList<Uri>();
+ for( final Taxonomy t : node.getNodeData().getTaxonomies() ) {
+ for( final Uri uri : t.getUris() ) {
+ us.add( uri );
+ }
+ }
+ double offset = 0;
+ for( final Uri uri : us ) {
+ if ( uri != null ) {
+ final String uri_str = uri.getValue().toString().toLowerCase();
+ if ( getImageMap().containsKey( uri_str ) ) {
+ final BufferedImage bi = getImageMap().get( uri_str );
+ if ( ( bi != null ) && ( bi.getHeight() > 5 ) && ( bi.getWidth() > 5 ) ) {
+ double scaling_factor = 1;
+ if ( getOptions().isAllowMagnificationOfTaxonomyImages()
+ || ( bi.getHeight() > ( 1.8 * getYdistance() ) ) ) {
+ scaling_factor = ( 1.8 * getYdistance() ) / bi.getHeight();
+ }
+ // y = y - ( 0.9 * getYdistance() );
+ final double hs = bi.getHeight() * scaling_factor;
+ double ws = ( bi.getWidth() * scaling_factor ) + offset;
+ final double my_y = y - ( 0.5 * hs );
+ final int x_w = ( int ) ( x + ws + 0.5 );
+ final int y_h = ( int ) ( my_y + hs + 0.5 );
+ if ( ( ( x_w - x ) > 7 ) && ( ( y_h - my_y ) > 7 ) ) {
+ g.drawImage( bi,
+ ( int ) ( x + 0.5 + offset ),
+ ( int ) ( my_y + 0.5 ),
+ x_w,
+ y_h,
+ 0,
+ 0,
+ bi.getWidth(),
+ bi.getHeight(),
+ null );
+ ws += 8;
+ }
+ else {
+ ws = 0.0;
+ }
+ offset = ws;
+ }
+ }
+ }
+ }
+ return offset;
+ }
+
+ final private void errorMessageNoCutCopyPasteInUnrootedDisplay() {
+ JOptionPane.showMessageDialog( this,
+ "Cannot cut, copy, paste, add, or delete subtrees/nodes in unrooted display",
+ "Attempt to cut/copy/paste/add/delete in unrooted display",
+ JOptionPane.ERROR_MESSAGE );
+ }
+
+ private final Color getColorForFoundNode( final PhylogenyNode n ) {
+ if ( isInCurrentExternalNodes( n ) ) {
+ return getTreeColorSet().getFoundColor0();
+ }
+ else if ( isInFoundNodes0( n ) && !isInFoundNodes1( n ) ) {
+ return getTreeColorSet().getFoundColor0();
+ }
+ else if ( !isInFoundNodes0( n ) && isInFoundNodes1( n ) ) {
+ return getTreeColorSet().getFoundColor1();
+ }
+ else {
+ return getTreeColorSet().getFoundColor0and1();
+ }
+ }
+
+ final private Set<Long> getCopiedAndPastedNodes() {
+ return getMainPanel().getCopiedAndPastedNodes();
+ }
+
+ final private Set<Long> getCurrentExternalNodes() {
+ return _current_external_nodes;
+ }
+
+ final private Phylogeny getCutOrCopiedTree() {
+ return getMainPanel().getCutOrCopiedTree();
+ }
+
+ private List<PhylogenyNode> getFoundNodes0AsListOfPhylogenyNodes() {
+ final List<PhylogenyNode> additional_nodes = new ArrayList<PhylogenyNode>();
+ for( final Long id : getFoundNodes0() ) {
+ additional_nodes.add( _phylogeny.getNode( id ) );
+ }
+ return additional_nodes;
+ }
+
+ private List<PhylogenyNode> getFoundNodes1AsListOfPhylogenyNodes() {
+ final List<PhylogenyNode> additional_nodes = new ArrayList<PhylogenyNode>();
+ for( final Long id : getFoundNodes1() ) {
+ additional_nodes.add( _phylogeny.getNode( id ) );
+ }
+ return additional_nodes;
+ }
+
+ final private float getLastDragPointX() {
+ return _last_drag_point_x;
+ }
+
+ final private float getLastDragPointY() {
+ return _last_drag_point_y;
+ }
+
+ final private short getMaxBranchesToLeaf( final PhylogenyNode node ) {
+ if ( !_nodeid_dist_to_leaf.containsKey( node.getId() ) ) {
+ final short m = PhylogenyMethods.calculateMaxBranchesToLeaf( node );
+ _nodeid_dist_to_leaf.put( node.getId(), m );
+ return m;
+ }
+ else {
+ return _nodeid_dist_to_leaf.get( node.getId() );
+ }
+ }
+
+ final private double getMaxDistanceToRoot() {
+ if ( _max_distance_to_root < 0 ) {
+ recalculateMaxDistanceToRoot();
+ }
+ return _max_distance_to_root;
+ }
+
+ final private float getOvMaxHeight() {
+ return _ov_max_height;
+ }
+
+ final private float getOvMaxWidth() {
+ return _ov_max_width;
+ }
+
+ final private float getOvXcorrectionFactor() {
+ return _ov_x_correction_factor;
+ }
+
+ final private float getOvXDistance() {
+ return _ov_x_distance;
+ }
+
+ final private int getOvXPosition() {
+ return _ov_x_position;
+ }
+
+ final private float getOvYDistance() {
+ return _ov_y_distance;
+ }
+
+ final private int getOvYPosition() {
+ return _ov_y_position;
+ }
+
+ final private int getOvYStart() {
+ return _ov_y_start;
+ }
+
+ final private List<Accession> getPdbAccs( final PhylogenyNode node ) {
+ final List<Accession> pdb_ids = new ArrayList<Accession>();
+ if ( node.getNodeData().isHasSequence() ) {
+ final Sequence seq = node.getNodeData().getSequence();
+ if ( !ForesterUtil.isEmpty( seq.getCrossReferences() ) ) {
+ final SortedSet<Accession> cross_refs = seq.getCrossReferences();
+ for( final Accession acc : cross_refs ) {
+ if ( acc.getSource().equalsIgnoreCase( "pdb" ) ) {
+ pdb_ids.add( acc );