+ viewport.getAlignment().deleteAllGroups();
+ viewport.sequenceColours = null;
+ viewport.setSelectionGroup(null);
+ PaintRefresher.Refresh(this, viewport.getSequenceSetId());
+ alignPanel.updateAnnotation();
+ alignPanel.paintAlignment(true);
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e
+ * DOCUMENT ME!
+ */
+ @Override
+ public void selectAllSequenceMenuItem_actionPerformed(ActionEvent e)
+ {
+ SequenceGroup sg = new SequenceGroup();
+
+ for (int i = 0; i < viewport.getAlignment().getSequences().size(); i++)
+ {
+ sg.addSequence(viewport.getAlignment().getSequenceAt(i), false);
+ }
+
+ sg.setEndRes(viewport.getAlignment().getWidth() - 1);
+ viewport.setSelectionGroup(sg);
+ viewport.sendSelection();
+ alignPanel.paintAlignment(true);
+ PaintRefresher.Refresh(alignPanel, viewport.getSequenceSetId());
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e
+ * DOCUMENT ME!
+ */
+ @Override
+ public void deselectAllSequenceMenuItem_actionPerformed(ActionEvent e)
+ {
+ if (viewport.cursorMode)
+ {
+ alignPanel.seqPanel.keyboardNo1 = null;
+ alignPanel.seqPanel.keyboardNo2 = null;
+ }
+ viewport.setSelectionGroup(null);
+ viewport.getColumnSelection().clear();
+ viewport.setSelectionGroup(null);
+ alignPanel.seqPanel.seqCanvas.highlightSearchResults(null);
+ alignPanel.idPanel.idCanvas.searchResults = null;
+ alignPanel.paintAlignment(true);
+ PaintRefresher.Refresh(alignPanel, viewport.getSequenceSetId());
+ viewport.sendSelection();
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e
+ * DOCUMENT ME!
+ */
+ @Override
+ public void invertSequenceMenuItem_actionPerformed(ActionEvent e)
+ {
+ SequenceGroup sg = viewport.getSelectionGroup();
+
+ if (sg == null)
+ {
+ selectAllSequenceMenuItem_actionPerformed(null);
+
+ return;
+ }
+
+ for (int i = 0; i < viewport.getAlignment().getSequences().size(); i++)
+ {
+ sg.addOrRemove(viewport.getAlignment().getSequenceAt(i), false);
+ }
+
+ alignPanel.paintAlignment(true);
+ PaintRefresher.Refresh(alignPanel, viewport.getSequenceSetId());
+ viewport.sendSelection();
+ }
+
+ @Override
+ public void invertColSel_actionPerformed(ActionEvent e)
+ {
+ viewport.invertColumnSelection();
+ alignPanel.paintAlignment(true);
+ viewport.sendSelection();
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e
+ * DOCUMENT ME!
+ */
+ @Override
+ public void remove2LeftMenuItem_actionPerformed(ActionEvent e)
+ {
+ trimAlignment(true);
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e
+ * DOCUMENT ME!
+ */
+ @Override
+ public void remove2RightMenuItem_actionPerformed(ActionEvent e)
+ {
+ trimAlignment(false);
+ }
+
+ void trimAlignment(boolean trimLeft)
+ {
+ ColumnSelection colSel = viewport.getColumnSelection();
+ int column;
+
+ if (colSel.size() > 0)
+ {
+ if (trimLeft)
+ {
+ column = colSel.getMin();
+ }
+ else
+ {
+ column = colSel.getMax();
+ }
+
+ SequenceI[] seqs;
+ if (viewport.getSelectionGroup() != null)
+ {
+ seqs = viewport.getSelectionGroup().getSequencesAsArray(
+ viewport.getHiddenRepSequences());
+ }
+ else
+ {
+ seqs = viewport.getAlignment().getSequencesArray();
+ }
+
+ TrimRegionCommand trimRegion;
+ if (trimLeft)
+ {
+ trimRegion = new TrimRegionCommand("Remove Left",
+ TrimRegionCommand.TRIM_LEFT, seqs, column,
+ viewport.getAlignment(), viewport.getColumnSelection(),
+ viewport.getSelectionGroup());
+ viewport.setStartRes(0);
+ }
+ else
+ {
+ trimRegion = new TrimRegionCommand("Remove Right",
+ TrimRegionCommand.TRIM_RIGHT, seqs, column,
+ viewport.getAlignment(), viewport.getColumnSelection(),
+ viewport.getSelectionGroup());
+ }
+
+ statusBar.setText("Removed " + trimRegion.getSize() + " columns.");
+
+ addHistoryItem(trimRegion);
+
+ for (SequenceGroup sg :viewport.getAlignment().getGroups())
+ {
+ if ((trimLeft && !sg.adjustForRemoveLeft(column))
+ || (!trimLeft && !sg.adjustForRemoveRight(column)))
+ {
+ viewport.getAlignment().deleteGroup(sg);
+ }
+ }
+
+ viewport.firePropertyChange("alignment", null, viewport
+ .getAlignment().getSequences());
+ }
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e
+ * DOCUMENT ME!
+ */
+ @Override
+ public void removeGappedColumnMenuItem_actionPerformed(ActionEvent e)
+ {
+ int start = 0, end = viewport.getAlignment().getWidth() - 1;
+
+ SequenceI[] seqs;
+ if (viewport.getSelectionGroup() != null)
+ {
+ seqs = viewport.getSelectionGroup().getSequencesAsArray(
+ viewport.getHiddenRepSequences());
+ start = viewport.getSelectionGroup().getStartRes();
+ end = viewport.getSelectionGroup().getEndRes();
+ }
+ else
+ {
+ seqs = viewport.getAlignment().getSequencesArray();
+ }
+
+ RemoveGapColCommand removeGapCols = new RemoveGapColCommand(
+ "Remove Gapped Columns", seqs, start, end,
+ viewport.getAlignment());
+
+ addHistoryItem(removeGapCols);
+
+ statusBar.setText("Removed " + removeGapCols.getSize()
+ + " empty columns.");
+
+ // This is to maintain viewport position on first residue
+ // of first sequence
+ SequenceI seq = viewport.getAlignment().getSequenceAt(0);
+ int startRes = seq.findPosition(viewport.startRes);
+ // ShiftList shifts;
+ // viewport.getAlignment().removeGaps(shifts=new ShiftList());
+ // edit.alColumnChanges=shifts.getInverse();
+ // if (viewport.hasHiddenColumns)
+ // viewport.getColumnSelection().compensateForEdits(shifts);
+ viewport.setStartRes(seq.findIndex(startRes) - 1);
+ viewport.firePropertyChange("alignment", null, viewport.getAlignment()
+ .getSequences());
+
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e
+ * DOCUMENT ME!
+ */
+ @Override
+ public void removeAllGapsMenuItem_actionPerformed(ActionEvent e)
+ {
+ int start = 0, end = viewport.getAlignment().getWidth() - 1;
+
+ SequenceI[] seqs;
+ if (viewport.getSelectionGroup() != null)
+ {
+ seqs = viewport.getSelectionGroup().getSequencesAsArray(
+ viewport.getHiddenRepSequences());
+ start = viewport.getSelectionGroup().getStartRes();
+ end = viewport.getSelectionGroup().getEndRes();
+ }
+ else
+ {
+ seqs = viewport.getAlignment().getSequencesArray();
+ }
+
+ // This is to maintain viewport position on first residue
+ // of first sequence
+ SequenceI seq = viewport.getAlignment().getSequenceAt(0);
+ int startRes = seq.findPosition(viewport.startRes);
+
+ addHistoryItem(new RemoveGapsCommand("Remove Gaps", seqs, start, end,
+ viewport.getAlignment()));
+
+ viewport.setStartRes(seq.findIndex(startRes) - 1);
+
+ viewport.firePropertyChange("alignment", null, viewport.getAlignment()
+ .getSequences());
+
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e
+ * DOCUMENT ME!
+ */
+ @Override
+ public void padGapsMenuitem_actionPerformed(ActionEvent e)
+ {
+ viewport.setPadGaps(padGapsMenuitem.isSelected());
+ viewport.firePropertyChange("alignment", null, viewport.getAlignment()
+ .getSequences());
+ }
+
+ // else
+ {
+ // if (justifySeqs>0)
+ {
+ // alignment.justify(justifySeqs!=RIGHT_JUSTIFY);
+ }
+ }
+
+ // }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e
+ * DOCUMENT ME!
+ */
+ @Override
+ public void findMenuItem_actionPerformed(ActionEvent e)
+ {
+ new Finder();
+ }
+
+ @Override
+ public void newView_actionPerformed(ActionEvent e)
+ {
+ newView(true);
+ }
+
+ /**
+ *
+ * @param copyAnnotation
+ * if true then duplicate all annnotation, groups and settings
+ * @return new alignment panel, already displayed.
+ */
+ public AlignmentPanel newView(boolean copyAnnotation)
+ {
+ return newView(null, copyAnnotation);
+ }
+
+ /**
+ *
+ * @param viewTitle
+ * title of newly created view
+ * @return new alignment panel, already displayed.
+ */
+ public AlignmentPanel newView(String viewTitle)
+ {
+ return newView(viewTitle, true);
+ }
+
+ /**
+ *
+ * @param viewTitle
+ * title of newly created view
+ * @param copyAnnotation
+ * if true then duplicate all annnotation, groups and settings
+ * @return new alignment panel, already displayed.
+ */
+ public AlignmentPanel newView(String viewTitle, boolean copyAnnotation)
+ {
+ AlignmentPanel newap = new Jalview2XML().copyAlignPanel(alignPanel,
+ true);
+ if (!copyAnnotation)
+ {
+ // just remove all the current annotation except for the automatic stuff
+ newap.av.getAlignment().deleteAllGroups();
+ for (AlignmentAnnotation alan : newap.av.getAlignment()
+ .getAlignmentAnnotation())
+ {
+ if (!alan.autoCalculated)
+ {
+ newap.av.getAlignment().deleteAnnotation(alan);
+ }
+ ;
+ }
+ }
+
+ newap.av.gatherViewsHere = false;
+
+ if (viewport.viewName == null)
+ {
+ viewport.viewName = "Original";
+ }
+
+ newap.av.historyList = viewport.historyList;
+ newap.av.redoList = viewport.redoList;
+
+ int index = Desktop.getViewCount(viewport.getSequenceSetId());
+ // make sure the new view has a unique name - this is essential for Jalview
+ // 2 archives
+ boolean addFirstIndex = false;
+ if (viewTitle == null || viewTitle.trim().length() == 0)
+ {
+ viewTitle = "View";
+ addFirstIndex = true;
+ }
+ else
+ {
+ index = 1;// we count from 1 if given a specific name
+ }
+ String newViewName = viewTitle + ((addFirstIndex) ? " " + index : "");
+ Vector comps = (Vector) PaintRefresher.components.get(viewport
+ .getSequenceSetId());
+ Vector existingNames = new Vector();
+ for (int i = 0; i < comps.size(); i++)
+ {
+ if (comps.elementAt(i) instanceof AlignmentPanel)
+ {
+ AlignmentPanel ap = (AlignmentPanel) comps.elementAt(i);
+ if (!existingNames.contains(ap.av.viewName))
+ {
+ existingNames.addElement(ap.av.viewName);
+ }
+ }
+ }
+
+ while (existingNames.contains(newViewName))
+ {
+ newViewName = viewTitle + " " + (++index);
+ }
+
+ newap.av.viewName = newViewName;
+
+ addAlignmentPanel(newap, true);
+
+ if (alignPanels.size() == 2)
+ {
+ viewport.gatherViewsHere = true;
+ }
+ tabbedPane.setSelectedIndex(tabbedPane.getTabCount() - 1);
+ return newap;
+ }
+
+ @Override
+ public void expandViews_actionPerformed(ActionEvent e)
+ {
+ Desktop.instance.explodeViews(this);
+ }
+
+ @Override
+ public void gatherViews_actionPerformed(ActionEvent e)
+ {
+ Desktop.instance.gatherViews(this);
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e
+ * DOCUMENT ME!
+ */
+ @Override
+ public void font_actionPerformed(ActionEvent e)
+ {
+ new FontChooser(alignPanel);
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e
+ * DOCUMENT ME!
+ */
+ @Override
+ protected void seqLimit_actionPerformed(ActionEvent e)
+ {
+ viewport.setShowJVSuffix(seqLimits.isSelected());
+
+ alignPanel.idPanel.idCanvas.setPreferredSize(alignPanel
+ .calculateIdWidth());
+ alignPanel.paintAlignment(true);
+ }
+
+ @Override
+ public void idRightAlign_actionPerformed(ActionEvent e)
+ {
+ viewport.rightAlignIds = idRightAlign.isSelected();
+ alignPanel.paintAlignment(true);
+ }
+
+ @Override
+ public void centreColumnLabels_actionPerformed(ActionEvent e)
+ {
+ viewport.centreColumnLabels = centreColumnLabelsMenuItem.getState();
+ alignPanel.paintAlignment(true);
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see jalview.jbgui.GAlignFrame#followHighlight_actionPerformed()
+ */
+ @Override
+ protected void followHighlight_actionPerformed()
+ {
+ if (viewport.followHighlight = this.followHighlightMenuItem.getState())
+ {
+ alignPanel.scrollToPosition(
+ alignPanel.seqPanel.seqCanvas.searchResults, false);
+ }
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e
+ * DOCUMENT ME!
+ */
+ @Override
+ protected void colourTextMenuItem_actionPerformed(ActionEvent e)
+ {
+ viewport.setColourText(colourTextMenuItem.isSelected());
+ alignPanel.paintAlignment(true);
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e
+ * DOCUMENT ME!
+ */
+ @Override
+ public void wrapMenuItem_actionPerformed(ActionEvent e)
+ {
+ scaleAbove.setVisible(wrapMenuItem.isSelected());
+ scaleLeft.setVisible(wrapMenuItem.isSelected());
+ scaleRight.setVisible(wrapMenuItem.isSelected());
+ viewport.setWrapAlignment(wrapMenuItem.isSelected());
+ alignPanel.setWrapAlignment(wrapMenuItem.isSelected());
+ }
+
+ @Override
+ public void showAllSeqs_actionPerformed(ActionEvent e)
+ {
+ viewport.showAllHiddenSeqs();
+ }
+
+ @Override
+ public void showAllColumns_actionPerformed(ActionEvent e)
+ {
+ viewport.showAllHiddenColumns();
+ repaint();
+ }
+
+ @Override
+ public void hideSelSequences_actionPerformed(ActionEvent e)
+ {
+ viewport.hideAllSelectedSeqs();
+ alignPanel.paintAlignment(true);
+ }
+
+ /**
+ * called by key handler and the hide all/show all menu items
+ *
+ * @param toggleSeqs
+ * @param toggleCols
+ */
+ private void toggleHiddenRegions(boolean toggleSeqs, boolean toggleCols)
+ {
+
+ boolean hide = false;
+ SequenceGroup sg = viewport.getSelectionGroup();
+ if (!toggleSeqs && !toggleCols)
+ {
+ // Hide everything by the current selection - this is a hack - we do the
+ // invert and then hide
+ // first check that there will be visible columns after the invert.
+ if ((viewport.getColumnSelection() != null
+ && viewport.getColumnSelection().getSelected() != null && viewport
+ .getColumnSelection().getSelected().size() > 0)
+ || (sg != null && sg.getSize() > 0 && sg.getStartRes() <= sg
+ .getEndRes()))
+ {
+ // now invert the sequence set, if required - empty selection implies
+ // that no hiding is required.
+ if (sg != null)
+ {
+ invertSequenceMenuItem_actionPerformed(null);
+ sg = viewport.getSelectionGroup();
+ toggleSeqs = true;
+
+ }
+ viewport.expandColSelection(sg, true);
+ // finally invert the column selection and get the new sequence
+ // selection.
+ invertColSel_actionPerformed(null);
+ toggleCols = true;
+ }
+ }
+
+ if (toggleSeqs)
+ {
+ if (sg != null && sg.getSize() != viewport.getAlignment().getHeight())
+ {
+ hideSelSequences_actionPerformed(null);
+ hide = true;
+ }
+ else if (!(toggleCols && viewport.getColumnSelection().getSelected()
+ .size() > 0))
+ {
+ showAllSeqs_actionPerformed(null);
+ }
+ }
+
+ if (toggleCols)
+ {
+ if (viewport.getColumnSelection().getSelected().size() > 0)
+ {
+ hideSelColumns_actionPerformed(null);
+ if (!toggleSeqs)
+ {
+ viewport.setSelectionGroup(sg);
+ }
+ }
+ else if (!hide)
+ {
+ showAllColumns_actionPerformed(null);
+ }
+ }
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see
+ * jalview.jbgui.GAlignFrame#hideAllButSelection_actionPerformed(java.awt.
+ * event.ActionEvent)
+ */
+ @Override
+ public void hideAllButSelection_actionPerformed(ActionEvent e)
+ {
+ toggleHiddenRegions(false, false);
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see
+ * jalview.jbgui.GAlignFrame#hideAllSelection_actionPerformed(java.awt.event
+ * .ActionEvent)
+ */
+ @Override
+ public void hideAllSelection_actionPerformed(ActionEvent e)
+ {
+ SequenceGroup sg = viewport.getSelectionGroup();
+ viewport.expandColSelection(sg, false);
+ viewport.hideAllSelectedSeqs();
+ viewport.hideSelectedColumns();
+ alignPanel.paintAlignment(true);
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see
+ * jalview.jbgui.GAlignFrame#showAllhidden_actionPerformed(java.awt.event.
+ * ActionEvent)
+ */
+ @Override
+ public void showAllhidden_actionPerformed(ActionEvent e)
+ {
+ viewport.showAllHiddenColumns();
+ viewport.showAllHiddenSeqs();
+ alignPanel.paintAlignment(true);
+ }
+
+ @Override
+ public void hideSelColumns_actionPerformed(ActionEvent e)
+ {
+ viewport.hideSelectedColumns();
+ alignPanel.paintAlignment(true);
+ }
+
+ @Override
+ public void hiddenMarkers_actionPerformed(ActionEvent e)
+ {
+ viewport.setShowHiddenMarkers(hiddenMarkers.isSelected());
+ repaint();
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e
+ * DOCUMENT ME!
+ */
+ @Override
+ protected void scaleAbove_actionPerformed(ActionEvent e)
+ {
+ viewport.setScaleAboveWrapped(scaleAbove.isSelected());
+ alignPanel.paintAlignment(true);
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e
+ * DOCUMENT ME!
+ */
+ @Override
+ protected void scaleLeft_actionPerformed(ActionEvent e)
+ {
+ viewport.setScaleLeftWrapped(scaleLeft.isSelected());
+ alignPanel.paintAlignment(true);
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e
+ * DOCUMENT ME!
+ */
+ @Override
+ protected void scaleRight_actionPerformed(ActionEvent e)
+ {
+ viewport.setScaleRightWrapped(scaleRight.isSelected());
+ alignPanel.paintAlignment(true);
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e
+ * DOCUMENT ME!
+ */
+ @Override
+ public void viewBoxesMenuItem_actionPerformed(ActionEvent e)
+ {
+ viewport.setShowBoxes(viewBoxesMenuItem.isSelected());
+ alignPanel.paintAlignment(true);
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e
+ * DOCUMENT ME!
+ */
+ @Override
+ public void viewTextMenuItem_actionPerformed(ActionEvent e)
+ {
+ viewport.setShowText(viewTextMenuItem.isSelected());
+ alignPanel.paintAlignment(true);
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e
+ * DOCUMENT ME!
+ */
+ @Override
+ protected void renderGapsMenuItem_actionPerformed(ActionEvent e)
+ {
+ viewport.setRenderGaps(renderGapsMenuItem.isSelected());
+ alignPanel.paintAlignment(true);
+ }
+
+ public FeatureSettings featureSettings;
+
+ @Override
+ public void featureSettings_actionPerformed(ActionEvent e)
+ {
+ if (featureSettings != null)
+ {
+ featureSettings.close();
+ featureSettings = null;
+ }
+ if (!showSeqFeatures.isSelected())
+ {
+ // make sure features are actually displayed
+ showSeqFeatures.setSelected(true);
+ showSeqFeatures_actionPerformed(null);
+ }
+ featureSettings = new FeatureSettings(this);
+ }
+
+ /**
+ * Set or clear 'Show Sequence Features'
+ *
+ * @param evt
+ * DOCUMENT ME!
+ */
+ @Override
+ public void showSeqFeatures_actionPerformed(ActionEvent evt)
+ {
+ viewport.setShowSequenceFeatures(showSeqFeatures.isSelected());
+ alignPanel.paintAlignment(true);
+ if (alignPanel.getOverviewPanel() != null)
+ {
+ alignPanel.getOverviewPanel().updateOverviewImage();
+ }
+ }
+
+ /**
+ * Set or clear 'Show Sequence Features'
+ *
+ * @param evt
+ * DOCUMENT ME!
+ */
+ @Override
+ public void showSeqFeaturesHeight_actionPerformed(ActionEvent evt)
+ {
+ viewport.setShowSequenceFeaturesHeight(showSeqFeaturesHeight
+ .isSelected());
+ if (viewport.getShowSequenceFeaturesHeight())
+ {
+ // ensure we're actually displaying features
+ viewport.setShowSequenceFeatures(true);
+ showSeqFeatures.setSelected(true);
+ }
+ alignPanel.paintAlignment(true);
+ if (alignPanel.getOverviewPanel() != null)
+ {
+ alignPanel.getOverviewPanel().updateOverviewImage();
+ }
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e
+ * DOCUMENT ME!
+ */
+ @Override
+ public void annotationPanelMenuItem_actionPerformed(ActionEvent e)
+ {
+ viewport.setShowAnnotation(annotationPanelMenuItem.isSelected());
+ alignPanel.setAnnotationVisible(annotationPanelMenuItem.isSelected());
+ }
+
+ @Override
+ public void alignmentProperties()
+ {
+ JEditorPane editPane = new JEditorPane("text/html", "");
+ editPane.setEditable(false);
+ StringBuffer contents = new AlignmentProperties(viewport.getAlignment())
+ .formatAsHtml();
+ editPane.setText("<html>" + contents.toString() + "</html>");
+ JInternalFrame frame = new JInternalFrame();
+ frame.getContentPane().add(new JScrollPane(editPane));
+
+ Desktop.instance.addInternalFrame(frame, "Alignment Properties: "
+ + getTitle(), 500, 400);
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e
+ * DOCUMENT ME!
+ */
+ @Override
+ public void overviewMenuItem_actionPerformed(ActionEvent e)
+ {
+ if (alignPanel.overviewPanel != null)
+ {
+ return;
+ }
+
+ JInternalFrame frame = new JInternalFrame();
+ OverviewPanel overview = new OverviewPanel(alignPanel);
+ frame.setContentPane(overview);
+ Desktop.addInternalFrame(frame, "Overview " + this.getTitle(),
+ frame.getWidth(), frame.getHeight());
+ frame.pack();
+ frame.setLayer(JLayeredPane.PALETTE_LAYER);
+ frame.addInternalFrameListener(new javax.swing.event.InternalFrameAdapter()
+ {
+ @Override
+ public void internalFrameClosed(
+ javax.swing.event.InternalFrameEvent evt)
+ {
+ alignPanel.setOverviewPanel(null);
+ };
+ });
+
+ alignPanel.setOverviewPanel(overview);
+ }
+
+ @Override
+ public void textColour_actionPerformed(ActionEvent e)
+ {
+ new TextColourChooser().chooseColour(alignPanel, null);
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e
+ * DOCUMENT ME!
+ */
+ @Override
+ protected void noColourmenuItem_actionPerformed(ActionEvent e)
+ {
+ changeColour(null);
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e
+ * DOCUMENT ME!
+ */
+ @Override
+ public void clustalColour_actionPerformed(ActionEvent e)
+ {
+ changeColour(new ClustalxColourScheme(viewport.getAlignment(), viewport.getHiddenRepSequences()));
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e
+ * DOCUMENT ME!
+ */
+ @Override
+ public void zappoColour_actionPerformed(ActionEvent e)
+ {
+ changeColour(new ZappoColourScheme());
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e
+ * DOCUMENT ME!
+ */
+ @Override
+ public void taylorColour_actionPerformed(ActionEvent e)
+ {
+ changeColour(new TaylorColourScheme());
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e
+ * DOCUMENT ME!
+ */
+ @Override
+ public void hydrophobicityColour_actionPerformed(ActionEvent e)
+ {
+ changeColour(new HydrophobicColourScheme());
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e
+ * DOCUMENT ME!
+ */
+ @Override
+ public void helixColour_actionPerformed(ActionEvent e)
+ {
+ changeColour(new HelixColourScheme());
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e
+ * DOCUMENT ME!
+ */
+ @Override
+ public void strandColour_actionPerformed(ActionEvent e)
+ {
+ changeColour(new StrandColourScheme());
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e
+ * DOCUMENT ME!
+ */
+ @Override
+ public void turnColour_actionPerformed(ActionEvent e)
+ {
+ changeColour(new TurnColourScheme());
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e
+ * DOCUMENT ME!
+ */
+ @Override
+ public void buriedColour_actionPerformed(ActionEvent e)
+ {
+ changeColour(new BuriedColourScheme());
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e
+ * DOCUMENT ME!
+ */
+ @Override
+ public void nucleotideColour_actionPerformed(ActionEvent e)
+ {
+ changeColour(new NucleotideColourScheme());
+ }
+
+ @Override
+ public void purinePyrimidineColour_actionPerformed(ActionEvent e)
+ {
+ changeColour(new PurinePyrimidineColourScheme());
+ }
+
+ /*
+ * public void covariationColour_actionPerformed(ActionEvent e) {
+ * changeColour(new
+ * CovariationColourScheme(viewport.getAlignment().getAlignmentAnnotation
+ * ()[0])); }
+ */
+ @Override
+ public void annotationColour_actionPerformed(ActionEvent e)
+ {
+ new AnnotationColourChooser(viewport, alignPanel);
+ }
+
+ @Override
+ public void rnahelicesColour_actionPerformed(ActionEvent e)
+ {
+ new RNAHelicesColourChooser(viewport, alignPanel);
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e
+ * DOCUMENT ME!
+ */
+ @Override
+ protected void applyToAllGroups_actionPerformed(ActionEvent e)
+ {
+ viewport.setColourAppliesToAllGroups(applyToAllGroups.isSelected());
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param cs
+ * DOCUMENT ME!
+ */
+ public void changeColour(ColourSchemeI cs)
+ {
+ // TODO: compare with applet and pull up to model method
+ int threshold = 0;
+
+ if (cs != null)
+ {
+ if (viewport.getAbovePIDThreshold())
+ {
+ threshold = SliderPanel.setPIDSliderSource(alignPanel, cs,
+ "Background");
+
+ cs.setThreshold(threshold, viewport.getIgnoreGapsConsensus());
+
+ viewport.setGlobalColourScheme(cs);
+ }
+ else
+ {
+ cs.setThreshold(0, viewport.getIgnoreGapsConsensus());
+ }
+
+ if (viewport.getConservationSelected())
+ {
+
+ Alignment al = (Alignment) viewport.getAlignment();
+ Conservation c = new Conservation("All",
+ ResidueProperties.propHash, 3, al.getSequences(), 0,
+ al.getWidth() - 1);
+
+ c.calculate();
+ c.verdict(false, viewport.getConsPercGaps());
+
+ cs.setConservation(c);
+
+ cs.setConservationInc(SliderPanel.setConservationSlider(alignPanel,
+ cs, "Background"));
+ }
+ else
+ {
+ cs.setConservation(null);
+ }
+
+ cs.setConsensus(viewport.getSequenceConsensusHash());
+ }
+
+ viewport.setGlobalColourScheme(cs);
+
+ if (viewport.getColourAppliesToAllGroups())
+ {
+
+
+ for (SequenceGroup sg:viewport.getAlignment().getGroups())
+ {
+ if (cs == null)
+ {
+ sg.cs = null;
+ continue;
+ }
+
+ if (cs instanceof ClustalxColourScheme)
+ {
+ sg.cs = new ClustalxColourScheme(sg, viewport
+ .getHiddenRepSequences());
+ }
+ else if (cs instanceof UserColourScheme)
+ {
+ sg.cs = new UserColourScheme(((UserColourScheme) cs).getColours());
+ }
+ else
+ {
+ try
+ {
+ sg.cs = cs.getClass().newInstance();
+ } catch (Exception ex)
+ {
+ }
+ }
+
+ if (viewport.getAbovePIDThreshold()
+ || cs instanceof PIDColourScheme
+ || cs instanceof Blosum62ColourScheme)
+ {
+ sg.cs.setThreshold(threshold, viewport.getIgnoreGapsConsensus());
+
+ sg.cs.setConsensus(AAFrequency.calculate(
+ sg.getSequences(viewport.getHiddenRepSequences()),
+ sg.getStartRes(), sg.getEndRes() + 1));
+ }
+ else
+ {
+ sg.cs.setThreshold(0, viewport.getIgnoreGapsConsensus());
+ }
+
+ if (viewport.getConservationSelected())
+ {
+ Conservation c = new Conservation("Group",
+ ResidueProperties.propHash, 3, sg.getSequences(viewport
+ .getHiddenRepSequences()), sg.getStartRes(),
+ sg.getEndRes() + 1);
+ c.calculate();
+ c.verdict(false, viewport.getConsPercGaps());
+ sg.cs.setConservation(c);
+ }
+ else
+ {
+ sg.cs.setConservation(null);
+ }
+ }
+ }
+
+ if (alignPanel.getOverviewPanel() != null)
+ {
+ alignPanel.getOverviewPanel().updateOverviewImage();
+ }
+
+ alignPanel.paintAlignment(true);
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e
+ * DOCUMENT ME!
+ */
+ @Override
+ protected void modifyPID_actionPerformed(ActionEvent e)
+ {
+ if (viewport.getAbovePIDThreshold()
+ && viewport.getGlobalColourScheme() != null)
+ {
+ SliderPanel.setPIDSliderSource(alignPanel,
+ viewport.getGlobalColourScheme(), "Background");
+ SliderPanel.showPIDSlider();
+ }
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e
+ * DOCUMENT ME!
+ */
+ @Override
+ protected void modifyConservation_actionPerformed(ActionEvent e)
+ {
+ if (viewport.getConservationSelected()
+ && viewport.getGlobalColourScheme() != null)
+ {
+ SliderPanel.setConservationSlider(alignPanel,
+ viewport.getGlobalColourScheme(), "Background");
+ SliderPanel.showConservationSlider();
+ }
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e
+ * DOCUMENT ME!
+ */
+ @Override
+ protected void conservationMenuItem_actionPerformed(ActionEvent e)
+ {
+ viewport.setConservationSelected(conservationMenuItem.isSelected());
+
+ viewport.setAbovePIDThreshold(false);
+ abovePIDThreshold.setSelected(false);
+
+ changeColour(viewport.getGlobalColourScheme());
+
+ modifyConservation_actionPerformed(null);
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e
+ * DOCUMENT ME!
+ */
+ @Override
+ public void abovePIDThreshold_actionPerformed(ActionEvent e)
+ {
+ viewport.setAbovePIDThreshold(abovePIDThreshold.isSelected());
+
+ conservationMenuItem.setSelected(false);
+ viewport.setConservationSelected(false);
+
+ changeColour(viewport.getGlobalColourScheme());
+
+ modifyPID_actionPerformed(null);
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e
+ * DOCUMENT ME!
+ */
+ @Override
+ public void userDefinedColour_actionPerformed(ActionEvent e)
+ {
+ if (e.getActionCommand().equals("User Defined..."))
+ {
+ new UserDefinedColours(alignPanel, null);
+ }
+ else
+ {
+ UserColourScheme udc = (UserColourScheme) UserDefinedColours
+ .getUserColourSchemes().get(e.getActionCommand());
+
+ changeColour(udc);
+ }
+ }
+
+ public void updateUserColourMenu()
+ {
+
+ Component[] menuItems = colourMenu.getMenuComponents();
+ int i, iSize = menuItems.length;
+ for (i = 0; i < iSize; i++)
+ {
+ if (menuItems[i].getName() != null
+ && menuItems[i].getName().equals("USER_DEFINED"))
+ {
+ colourMenu.remove(menuItems[i]);
+ iSize--;
+ }
+ }
+ if (jalview.gui.UserDefinedColours.getUserColourSchemes() != null)
+ {
+ java.util.Enumeration userColours = jalview.gui.UserDefinedColours
+ .getUserColourSchemes().keys();
+
+ while (userColours.hasMoreElements())
+ {
+ final JRadioButtonMenuItem radioItem = new JRadioButtonMenuItem(
+ userColours.nextElement().toString());
+ radioItem.setName("USER_DEFINED");
+ radioItem.addMouseListener(new MouseAdapter()
+ {
+ @Override
+ public void mousePressed(MouseEvent evt)
+ {
+ if (evt.isControlDown()
+ || SwingUtilities.isRightMouseButton(evt))
+ {
+ radioItem.removeActionListener(radioItem.getActionListeners()[0]);
+
+ int option = JOptionPane.showInternalConfirmDialog(
+ jalview.gui.Desktop.desktop,
+ "Remove from default list?",
+ "Remove user defined colour",
+ JOptionPane.YES_NO_OPTION);
+ if (option == JOptionPane.YES_OPTION)
+ {
+ jalview.gui.UserDefinedColours
+ .removeColourFromDefaults(radioItem.getText());
+ colourMenu.remove(radioItem);
+ }
+ else
+ {
+ radioItem.addActionListener(new ActionListener()
+ {
+ @Override
+ public void actionPerformed(ActionEvent evt)
+ {
+ userDefinedColour_actionPerformed(evt);
+ }
+ });
+ }
+ }
+ }
+ });
+ radioItem.addActionListener(new ActionListener()
+ {
+ @Override
+ public void actionPerformed(ActionEvent evt)
+ {
+ userDefinedColour_actionPerformed(evt);
+ }
+ });
+
+ colourMenu.insert(radioItem, 15);
+ colours.add(radioItem);
+ }
+ }
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e
+ * DOCUMENT ME!
+ */
+ @Override
+ public void PIDColour_actionPerformed(ActionEvent e)
+ {
+ changeColour(new PIDColourScheme());
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e
+ * DOCUMENT ME!
+ */
+ @Override
+ public void BLOSUM62Colour_actionPerformed(ActionEvent e)
+ {
+ changeColour(new Blosum62ColourScheme());
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e
+ * DOCUMENT ME!
+ */
+ @Override
+ public void sortPairwiseMenuItem_actionPerformed(ActionEvent e)
+ {
+ SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
+ AlignmentSorter.sortByPID(viewport.getAlignment(), viewport
+ .getAlignment().getSequenceAt(0), null);
+ addHistoryItem(new OrderCommand("Pairwise Sort", oldOrder,
+ viewport.getAlignment()));
+ alignPanel.paintAlignment(true);
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e
+ * DOCUMENT ME!
+ */
+ @Override
+ public void sortIDMenuItem_actionPerformed(ActionEvent e)
+ {
+ SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
+ AlignmentSorter.sortByID(viewport.getAlignment());
+ addHistoryItem(new OrderCommand("ID Sort", oldOrder,
+ viewport.getAlignment()));
+ alignPanel.paintAlignment(true);
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e
+ * DOCUMENT ME!
+ */
+ @Override
+ public void sortLengthMenuItem_actionPerformed(ActionEvent e)
+ {
+ SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
+ AlignmentSorter.sortByLength(viewport.getAlignment());
+ addHistoryItem(new OrderCommand("Length Sort", oldOrder,
+ viewport.getAlignment()));
+ alignPanel.paintAlignment(true);
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e
+ * DOCUMENT ME!
+ */
+ @Override
+ public void sortGroupMenuItem_actionPerformed(ActionEvent e)
+ {
+ SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
+ AlignmentSorter.sortByGroup(viewport.getAlignment());
+ addHistoryItem(new OrderCommand("Group Sort", oldOrder,
+ viewport.getAlignment()));
+
+ alignPanel.paintAlignment(true);
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e
+ * DOCUMENT ME!
+ */
+ @Override
+ public void removeRedundancyMenuItem_actionPerformed(ActionEvent e)
+ {
+ new RedundancyPanel(alignPanel, this);
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e
+ * DOCUMENT ME!
+ */
+ @Override
+ public void pairwiseAlignmentMenuItem_actionPerformed(ActionEvent e)
+ {
+ if ((viewport.getSelectionGroup() == null)
+ || (viewport.getSelectionGroup().getSize() < 2))
+ {
+ JOptionPane.showInternalMessageDialog(this,
+ "You must select at least 2 sequences.", "Invalid Selection",
+ JOptionPane.WARNING_MESSAGE);
+ }
+ else
+ {
+ JInternalFrame frame = new JInternalFrame();
+ frame.setContentPane(new PairwiseAlignPanel(viewport));
+ Desktop.addInternalFrame(frame, "Pairwise Alignment", 600, 500);
+ }
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e
+ * DOCUMENT ME!
+ */
+ @Override
+ public void PCAMenuItem_actionPerformed(ActionEvent e)
+ {
+ if (((viewport.getSelectionGroup() != null)
+ && (viewport.getSelectionGroup().getSize() < 4) && (viewport
+ .getSelectionGroup().getSize() > 0))
+ || (viewport.getAlignment().getHeight() < 4))
+ {
+ JOptionPane.showInternalMessageDialog(this,
+ "Principal component analysis must take\n"
+ + "at least 4 input sequences.",
+ "Sequence selection insufficient",
+ JOptionPane.WARNING_MESSAGE);
+
+ return;
+ }
+
+ new PCAPanel(alignPanel);
+ }
+
+ @Override
+ public void autoCalculate_actionPerformed(ActionEvent e)
+ {
+ viewport.autoCalculateConsensus = autoCalculate.isSelected();
+ if (viewport.autoCalculateConsensus)
+ {
+ viewport.firePropertyChange("alignment", null, viewport
+ .getAlignment().getSequences());
+ }
+ }
+
+ @Override
+ public void sortByTreeOption_actionPerformed(ActionEvent e)
+ {
+ viewport.sortByTree = sortByTree.isSelected();
+ }
+
+ @Override
+ protected void listenToViewSelections_actionPerformed(ActionEvent e)
+ {
+ viewport.followSelection = listenToViewSelections.isSelected();
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e
+ * DOCUMENT ME!
+ */
+ @Override
+ public void averageDistanceTreeMenuItem_actionPerformed(ActionEvent e)
+ {
+ NewTreePanel("AV", "PID", "Average distance tree using PID");
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e
+ * DOCUMENT ME!
+ */
+ @Override
+ public void neighbourTreeMenuItem_actionPerformed(ActionEvent e)
+ {
+ NewTreePanel("NJ", "PID", "Neighbour joining tree using PID");
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e
+ * DOCUMENT ME!
+ */
+ @Override
+ protected void njTreeBlosumMenuItem_actionPerformed(ActionEvent e)
+ {
+ NewTreePanel("NJ", "BL", "Neighbour joining tree using BLOSUM62");
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e
+ * DOCUMENT ME!
+ */
+ @Override
+ protected void avTreeBlosumMenuItem_actionPerformed(ActionEvent e)
+ {
+ NewTreePanel("AV", "BL", "Average distance tree using BLOSUM62");
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param type
+ * DOCUMENT ME!
+ * @param pwType
+ * DOCUMENT ME!
+ * @param title
+ * DOCUMENT ME!
+ */
+ void NewTreePanel(String type, String pwType, String title)
+ {
+ TreePanel tp;
+
+ if (viewport.getSelectionGroup() != null)
+ {
+ if (viewport.getSelectionGroup().getSize() < 3)
+ {
+ JOptionPane
+ .showMessageDialog(
+ Desktop.desktop,
+ "You need to have more than two sequences selected to build a tree!",
+ "Not enough sequences", JOptionPane.WARNING_MESSAGE);
+ return;
+ }
+
+ SequenceGroup sg = viewport.getSelectionGroup();
+
+ /* Decide if the selection is a column region */
+ for (SequenceI _s:sg.getSequences())
+ {
+ if (_s.getLength() < sg
+ .getEndRes())
+ {
+ JOptionPane
+ .showMessageDialog(
+ Desktop.desktop,
+ "The selected region to create a tree may\nonly contain residues or gaps.\n"
+ + "Try using the Pad function in the edit menu,\n"
+ + "or one of the multiple sequence alignment web services.",
+ "Sequences in selection are not aligned",
+ JOptionPane.WARNING_MESSAGE);
+
+ return;
+ }
+ }
+
+ title = title + " on region";
+ tp = new TreePanel(alignPanel, type, pwType);
+ }
+ else
+ {
+ // are the visible sequences aligned?
+ if (!viewport.getAlignment().isAligned(false))
+ {
+ JOptionPane
+ .showMessageDialog(
+ Desktop.desktop,
+ "The sequences must be aligned before creating a tree.\n"
+ + "Try using the Pad function in the edit menu,\n"
+ + "or one of the multiple sequence alignment web services.",
+ "Sequences not aligned",
+ JOptionPane.WARNING_MESSAGE);
+
+ return;
+ }
+
+ if (viewport.getAlignment().getHeight() < 2)
+ {
+ return;
+ }
+
+ tp = new TreePanel(alignPanel, type, pwType);
+ }
+
+ title += " from ";
+
+ if (viewport.viewName != null)
+ {
+ title += viewport.viewName + " of ";
+ }
+
+ title += this.title;
+
+ Desktop.addInternalFrame(tp, title, 600, 500);
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param title
+ * DOCUMENT ME!
+ * @param order
+ * DOCUMENT ME!
+ */
+ public void addSortByOrderMenuItem(String title,
+ final AlignmentOrder order)
+ {
+ final JMenuItem item = new JMenuItem("by " + title);
+ sort.add(item);
+ item.addActionListener(new java.awt.event.ActionListener()
+ {
+ @Override
+ public void actionPerformed(ActionEvent e)
+ {
+ SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
+
+ // TODO: JBPNote - have to map order entries to curent SequenceI
+ // pointers
+ AlignmentSorter.sortBy(viewport.getAlignment(), order);
+
+ addHistoryItem(new OrderCommand(order.getName(), oldOrder, viewport
+ .getAlignment()));
+
+ alignPanel.paintAlignment(true);
+ }
+ });
+ }
+
+ /**
+ * Add a new sort by annotation score menu item
+ *
+ * @param sort
+ * the menu to add the option to
+ * @param scoreLabel
+ * the label used to retrieve scores for each sequence on the
+ * alignment
+ */
+ public void addSortByAnnotScoreMenuItem(JMenu sort,
+ final String scoreLabel)
+ {
+ final JMenuItem item = new JMenuItem(scoreLabel);
+ sort.add(item);
+ item.addActionListener(new java.awt.event.ActionListener()
+ {
+ @Override
+ public void actionPerformed(ActionEvent e)
+ {
+ SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
+ AlignmentSorter.sortByAnnotationScore(scoreLabel,
+ viewport.getAlignment());// ,viewport.getSelectionGroup());
+ addHistoryItem(new OrderCommand("Sort by " + scoreLabel, oldOrder,
+ viewport.getAlignment()));
+ alignPanel.paintAlignment(true);
+ }
+ });
+ }
+
+ /**
+ * last hash for alignment's annotation array - used to minimise cost of
+ * rebuild.
+ */
+ protected int _annotationScoreVectorHash;
+
+ /**
+ * search the alignment and rebuild the sort by annotation score submenu the
+ * last alignment annotation vector hash is stored to minimize cost of
+ * rebuilding in subsequence calls.
+ *
+ */
+ @Override
+ public void buildSortByAnnotationScoresMenu()
+ {
+ if (viewport.getAlignment().getAlignmentAnnotation() == null)
+ {
+ return;
+ }
+
+ if (viewport.getAlignment().getAlignmentAnnotation().hashCode() != _annotationScoreVectorHash)
+ {
+ sortByAnnotScore.removeAll();
+ // almost certainly a quicker way to do this - but we keep it simple
+ Hashtable scoreSorts = new Hashtable();
+ AlignmentAnnotation aann[];
+ for (SequenceI sqa:viewport.getAlignment().getSequences())
+ {
+ aann = sqa.getAnnotation();
+ for (int i = 0; aann != null && i < aann.length; i++)
+ {
+ if (aann[i].hasScore() && aann[i].sequenceRef != null)
+ {
+ scoreSorts.put(aann[i].label, aann[i].label);
+ }
+ }
+ }
+ Enumeration labels = scoreSorts.keys();
+ while (labels.hasMoreElements())
+ {
+ addSortByAnnotScoreMenuItem(sortByAnnotScore,
+ (String) labels.nextElement());
+ }
+ sortByAnnotScore.setVisible(scoreSorts.size() > 0);
+ scoreSorts.clear();
+
+ _annotationScoreVectorHash = viewport.getAlignment()
+ .getAlignmentAnnotation().hashCode();
+ }
+ }
+
+ /**
+ * Maintain the Order by->Displayed Tree menu. Creates a new menu item for a
+ * TreePanel with an appropriate <code>jalview.analysis.AlignmentSorter</code>
+ * call. Listeners are added to remove the menu item when the treePanel is
+ * closed, and adjust the tree leaf to sequence mapping when the alignment is
+ * modified.
+ *
+ * @param treePanel
+ * Displayed tree window.
+ * @param title
+ * SortBy menu item title.
+ */
+ @Override
+ public void buildTreeMenu()
+ {
+ sortByTreeMenu.removeAll();
+
+ Vector comps = (Vector) PaintRefresher.components.get(viewport
+ .getSequenceSetId());
+ Vector treePanels = new Vector();
+ int i, iSize = comps.size();
+ for (i = 0; i < iSize; i++)
+ {
+ if (comps.elementAt(i) instanceof TreePanel)
+ {
+ treePanels.add(comps.elementAt(i));
+ }
+ }
+
+ iSize = treePanels.size();
+
+ if (iSize < 1)
+ {
+ sortByTreeMenu.setVisible(false);
+ return;
+ }
+
+ sortByTreeMenu.setVisible(true);
+
+ for (i = 0; i < treePanels.size(); i++)
+ {
+ final TreePanel tp = (TreePanel) treePanels.elementAt(i);
+ final JMenuItem item = new JMenuItem(tp.getTitle());
+ final NJTree tree = ((TreePanel) treePanels.elementAt(i)).getTree();
+ item.addActionListener(new java.awt.event.ActionListener()
+ {
+ @Override
+ public void actionPerformed(ActionEvent e)
+ {
+ tp.sortByTree_actionPerformed(null);
+ addHistoryItem(tp.sortAlignmentIn(alignPanel));
+
+ }
+ });
+
+ sortByTreeMenu.add(item);
+ }
+ }
+
+ public boolean sortBy(AlignmentOrder alorder, String undoname)
+ {
+ SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
+ AlignmentSorter.sortBy(viewport.getAlignment(), alorder);
+ if (undoname != null)
+ {
+ addHistoryItem(new OrderCommand(undoname, oldOrder,
+ viewport.getAlignment()));
+ }
+ alignPanel.paintAlignment(true);
+ return true;
+ }
+
+ /**
+ * Work out whether the whole set of sequences or just the selected set will
+ * be submitted for multiple alignment.
+ *
+ */
+ public jalview.datamodel.AlignmentView gatherSequencesForAlignment()
+ {
+ // Now, check we have enough sequences
+ AlignmentView msa = null;
+
+ if ((viewport.getSelectionGroup() != null)
+ && (viewport.getSelectionGroup().getSize() > 1))
+ {
+ // JBPNote UGLY! To prettify, make SequenceGroup and Alignment conform to
+ // some common interface!
+ /*
+ * SequenceGroup seqs = viewport.getSelectionGroup(); int sz; msa = new
+ * SequenceI[sz = seqs.getSize(false)];
+ *
+ * for (int i = 0; i < sz; i++) { msa[i] = (SequenceI)
+ * seqs.getSequenceAt(i); }
+ */
+ msa = viewport.getAlignmentView(true);
+ }
+ else
+ {
+ /*
+ * Vector seqs = viewport.getAlignment().getSequences();
+ *
+ * if (seqs.size() > 1) { msa = new SequenceI[seqs.size()];
+ *
+ * for (int i = 0; i < seqs.size(); i++) { msa[i] = (SequenceI)
+ * seqs.elementAt(i); } }
+ */
+ msa = viewport.getAlignmentView(false);
+ }
+ return msa;
+ }
+
+ /**
+ * Decides what is submitted to a secondary structure prediction service: the
+ * first sequence in the alignment, or in the current selection, or, if the
+ * alignment is 'aligned' (ie padded with gaps), then the currently selected
+ * region or the whole alignment. (where the first sequence in the set is the
+ * one that the prediction will be for).
+ */
+ public AlignmentView gatherSeqOrMsaForSecStrPrediction()
+ {
+ AlignmentView seqs = null;
+
+ if ((viewport.getSelectionGroup() != null)
+ && (viewport.getSelectionGroup().getSize() > 0))
+ {
+ seqs = viewport.getAlignmentView(true);
+ }
+ else
+ {
+ seqs = viewport.getAlignmentView(false);
+ }
+ // limit sequences - JBPNote in future - could spawn multiple prediction
+ // jobs
+ // TODO: viewport.getAlignment().isAligned is a global state - the local
+ // selection may well be aligned - we preserve 2.0.8 behaviour for moment.
+ if (!viewport.getAlignment().isAligned(false))
+ {
+ seqs.setSequences(new SeqCigar[]
+ { seqs.getSequences()[0] });
+ // TODO: if seqs.getSequences().length>1 then should really have warned
+ // user!
+
+ }
+ return seqs;
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e
+ * DOCUMENT ME!
+ */
+ @Override
+ protected void LoadtreeMenuItem_actionPerformed(ActionEvent e)
+ {
+ // Pick the tree file
+ JalviewFileChooser chooser = new JalviewFileChooser(
+ jalview.bin.Cache.getProperty("LAST_DIRECTORY"));
+ chooser.setFileView(new JalviewFileView());
+ chooser.setDialogTitle("Select a newick-like tree file");
+ chooser.setToolTipText("Load a tree file");
+
+ int value = chooser.showOpenDialog(null);
+
+ if (value == JalviewFileChooser.APPROVE_OPTION)
+ {
+ String choice = chooser.getSelectedFile().getPath();
+ jalview.bin.Cache.setProperty("LAST_DIRECTORY", choice);
+ jalview.io.NewickFile fin = null;
+ try
+ {
+ fin = new jalview.io.NewickFile(choice, "File");
+ viewport.setCurrentTree(ShowNewickTree(fin, choice).getTree());
+ } catch (Exception ex)
+ {
+ JOptionPane.showMessageDialog(Desktop.desktop, ex.getMessage(),
+ "Problem reading tree file", JOptionPane.WARNING_MESSAGE);
+ ex.printStackTrace();
+ }
+ if (fin != null && fin.hasWarningMessage())
+ {
+ JOptionPane.showMessageDialog(Desktop.desktop,
+ fin.getWarningMessage(), "Possible problem with tree file",
+ JOptionPane.WARNING_MESSAGE);
+ }
+ }
+ }
+
+ @Override
+ protected void tcoffeeColorScheme_actionPerformed(ActionEvent e)
+ {
+ changeColour(new TCoffeeColourScheme(alignPanel.getAlignment()));
+ }
+
+ public TreePanel ShowNewickTree(NewickFile nf, String title)
+ {
+ return ShowNewickTree(nf, title, 600, 500, 4, 5);
+ }
+
+ public TreePanel ShowNewickTree(NewickFile nf, String title,
+ AlignmentView input)
+ {
+ return ShowNewickTree(nf, title, input, 600, 500, 4, 5);
+ }
+
+ public TreePanel ShowNewickTree(NewickFile nf, String title, int w,
+ int h, int x, int y)
+ {
+ return ShowNewickTree(nf, title, null, w, h, x, y);
+ }
+
+ /**
+ * Add a treeviewer for the tree extracted from a newick file object to the
+ * current alignment view
+ *
+ * @param nf
+ * the tree
+ * @param title
+ * tree viewer title
+ * @param input
+ * Associated alignment input data (or null)
+ * @param w
+ * width
+ * @param h
+ * height
+ * @param x
+ * position
+ * @param y
+ * position
+ * @return TreePanel handle
+ */
+ public TreePanel ShowNewickTree(NewickFile nf, String title,
+ AlignmentView input, int w, int h, int x, int y)
+ {
+ TreePanel tp = null;
+
+ try
+ {