+ newView(null);
+ }
+ else if (source == showColumns)
+ {
+ viewport.showAllHiddenColumns();
+ alignPanel.paintAlignment(true, true);
+ viewport.sendSelection();
+ }
+ else if (source == showSeqs)
+ {
+ viewport.showAllHiddenSeqs();
+ alignPanel.paintAlignment(true, true);
+ // uncomment if we want to slave sequence selections in split frame
+ // viewport.sendSelection();
+ }
+ else if (source == hideColumns)
+ {
+ viewport.hideSelectedColumns();
+ alignPanel.paintAlignment(true, true);
+ viewport.sendSelection();
+ }
+ else if (source == hideSequences
+ && viewport.getSelectionGroup() != null)
+ {
+ viewport.hideAllSelectedSeqs();
+ alignPanel.paintAlignment(true, true);
+ // uncomment if we want to slave sequence selections in split frame
+ // viewport.sendSelection();
+ }
+ else if (source == hideAllButSelection)
+ {
+ toggleHiddenRegions(false, false);
+ alignPanel.paintAlignment(true, true);
+ viewport.sendSelection();
+ }
+ else if (source == hideAllSelection)
+ {
+ SequenceGroup sg = viewport.getSelectionGroup();
+ viewport.expandColSelection(sg, false);
+ viewport.hideAllSelectedSeqs();
+ viewport.hideSelectedColumns();
+ alignPanel.paintAlignment(true, true);
+ viewport.sendSelection();
+ }
+ else if (source == showAllHidden)
+ {
+ viewport.showAllHiddenColumns();
+ viewport.showAllHiddenSeqs();
+ alignPanel.paintAlignment(true, true);
+ viewport.sendSelection();
+ }
+ else if (source == showGroupConsensus)
+ {
+ showGroupConsensus_actionPerformed();
+ }
+ else if (source == showGroupConservation)
+ {
+ showGroupConservation_actionPerformed();
+ }
+ else if (source == showSequenceLogo)
+ {
+ showSequenceLogo_actionPerformed();
+ }
+ else if (source == normSequenceLogo)
+ {
+ normSequenceLogo_actionPerformed();
+ }
+ else if (source == showConsensusHistogram)
+ {
+ showConsensusHistogram_actionPerformed();
+ }
+ else if (source == applyAutoAnnotationSettings)
+ {
+ applyAutoAnnotationSettings_actionPerformed();
+ }
+ else if (source == featureSettings)
+ {
+ new FeatureSettings(alignPanel);
+ }
+ else if (source == alProperties)
+ {
+ StringBuffer contents = new jalview.io.AlignmentProperties(
+ viewport.getAlignment()).formatAsString();
+ CutAndPasteTransfer cap = new CutAndPasteTransfer(false, this);
+ cap.setText(contents.toString());
+ Frame frame = new Frame();
+ frame.add(cap);
+ jalview.bin.JalviewLite.addFrame(frame, MessageManager
+ .formatMessage("label.alignment_properties", new String[]
+ { getTitle() }), 400, 250);
+ }
+ else if (source == overviewMenuItem)
+ {
+ overviewMenuItem_actionPerformed();
+ }
+ else if (source == noColourmenuItem)
+ {
+ changeColour(null);
+ }
+ else if (source == clustalColour)
+ {
+ abovePIDThreshold.setState(false);
+ changeColour(new ClustalxColourScheme(viewport.getAlignment(), null));
+ }
+ else if (source == zappoColour)
+ {
+ changeColour(new ZappoColourScheme());
+ }
+ else if (source == taylorColour)
+ {
+ changeColour(new TaylorColourScheme());
+ }
+ else if (source == hydrophobicityColour)
+ {
+ changeColour(new HydrophobicColourScheme());
+ }
+ else if (source == helixColour)
+ {
+ changeColour(new HelixColourScheme());
+ }
+ else if (source == strandColour)
+ {
+ changeColour(new StrandColourScheme());
+ }
+ else if (source == turnColour)
+ {
+ changeColour(new TurnColourScheme());
+ }
+ else if (source == buriedColour)
+ {
+ changeColour(new BuriedColourScheme());
+ }
+ else if (source == nucleotideColour)
+ {
+ changeColour(new NucleotideColourScheme());
+ }
+ else if (source == purinePyrimidineColour)
+ {
+ changeColour(new PurinePyrimidineColourScheme());
+ }
+ // else if (source == RNAInteractionColour)
+ // {
+ // changeColour(new RNAInteractionColourScheme());
+ // }
+ else if (source == RNAHelixColour)
+ {
+ changeColour(new RNAHelicesColour(viewport.getAlignment()));
+ // new RNAHelicesColourChooser(viewport, alignPanel);
+ }
+ else if (source == modifyPID)
+ {
+ modifyPID_actionPerformed();
+ }
+ else if (source == modifyConservation)
+ {
+ modifyConservation_actionPerformed();
+ }
+ else if (source == userDefinedColour)
+ {
+ new UserDefinedColours(alignPanel, null);
+ }
+ else if (source == PIDColour)
+ {
+ changeColour(new PIDColourScheme());
+ }
+ else if (source == BLOSUM62Colour)
+ {
+ changeColour(new Blosum62ColourScheme());
+ }
+ else if (source == tcoffeeColour)
+ {
+ changeColour(new TCoffeeColourScheme(alignPanel.getAlignment()));
+ }
+ else if (source == annotationColour)
+ {
+ new AnnotationColourChooser(viewport, alignPanel);
+ }
+ else if (source == annotationColumnSelection)
+ {
+ new AnnotationColumnChooser(viewport, alignPanel);
+ }
+ else if (source == sortPairwiseMenuItem)
+ {
+ sortPairwiseMenuItem_actionPerformed();
+ }
+ else if (source == sortIDMenuItem)
+ {
+ sortIDMenuItem_actionPerformed();
+ }
+ else if (source == sortLengthMenuItem)
+ {
+ sortLengthMenuItem_actionPerformed();
+ }
+ else if (source == sortGroupMenuItem)
+ {
+ sortGroupMenuItem_actionPerformed();
+ }
+ else if (source == removeRedundancyMenuItem)
+ {
+ removeRedundancyMenuItem_actionPerformed();
+ }
+ else if (source == pairwiseAlignmentMenuItem)
+ {
+ pairwiseAlignmentMenuItem_actionPerformed();
+ }
+ else if (source == PCAMenuItem)
+ {
+ PCAMenuItem_actionPerformed();
+ }
+ else if (source == averageDistanceTreeMenuItem)
+ {
+ averageDistanceTreeMenuItem_actionPerformed();
+ }
+ else if (source == neighbourTreeMenuItem)
+ {
+ neighbourTreeMenuItem_actionPerformed();
+ }
+ else if (source == njTreeBlosumMenuItem)
+ {
+ njTreeBlosumMenuItem_actionPerformed();
+ }
+ else if (source == avDistanceTreeBlosumMenuItem)
+ {
+ avTreeBlosumMenuItem_actionPerformed();
+ }
+ else if (source == documentation)
+ {
+ documentation_actionPerformed();
+ }
+ else if (source == about)
+ {
+ about_actionPerformed();
+ }
+
+ }
+
+ public void inputText_actionPerformed()
+ {
+ CutAndPasteTransfer cap = new CutAndPasteTransfer(true, this);
+ Frame frame = new Frame();
+ frame.add(cap);
+ jalview.bin.JalviewLite.addFrame(frame,
+ MessageManager.getString("label.input_cut_paste"), 500, 500);
+ }
+
+ protected void outputText_actionPerformed(ActionEvent e)
+ {
+ CutAndPasteTransfer cap = new CutAndPasteTransfer(true, this);
+ Frame frame = new Frame();
+ frame.add(cap);
+ JalviewLite.addFrame(frame, MessageManager
+ .formatMessage("label.alignment_output_command", new Object[]
+ { e.getActionCommand() }), 600, 500);
+
+ FileFormatI fileFormat = FileFormats.getInstance()
+ .forName(e.getActionCommand());
+ cap.setText(
+ new AppletFormatAdapter(alignPanel).formatSequences(fileFormat,
+ viewport.getAlignment(), viewport.getShowJVSuffix()));
+ }
+
+ public void loadAnnotations()
+ {
+ CutAndPasteTransfer cap = new CutAndPasteTransfer(true, this);
+ cap.setText(MessageManager
+ .getString("label.paste_features_annotations_Tcoffee_here"));
+ cap.setAnnotationImport();
+ Frame frame = new Frame();
+ frame.add(cap);
+ jalview.bin.JalviewLite.addFrame(frame,
+ MessageManager.getString("action.paste_annotations"), 400, 300);
+
+ }
+
+ public String outputAnnotations(boolean displayTextbox)
+ {
+ String annotation = new AnnotationFile()
+ .printAnnotationsForView(viewport);
+
+ if (displayTextbox)
+ {
+ CutAndPasteTransfer cap = new CutAndPasteTransfer(false, this);
+ Frame frame = new Frame();
+ frame.add(cap);
+ jalview.bin.JalviewLite.addFrame(frame,
+ MessageManager.getString("label.annotations"), 600, 500);
+ cap.setText(annotation);
+ }
+
+ return annotation;
+ }
+
+ private Map<String, FeatureColourI> getDisplayedFeatureCols()
+ {
+ if (alignPanel.getFeatureRenderer() != null
+ && viewport.getFeaturesDisplayed() != null)
+ {
+ return alignPanel.getFeatureRenderer().getDisplayedFeatureCols();
+
+ }
+ return null;
+ }
+
+ private List<String> getDisplayedFeatureGroups()
+ {
+ if (alignPanel.getFeatureRenderer() != null
+ && viewport.getFeaturesDisplayed() != null)
+ {
+ return alignPanel.getFeatureRenderer().getDisplayedFeatureGroups();
+
+ }
+ return null;
+ }
+
+ public String outputFeatures(boolean displayTextbox, String format)
+ {
+ String features;
+ FeaturesFile formatter = new FeaturesFile();
+ if (format.equalsIgnoreCase("Jalview"))
+ {
+ features = formatter.printJalviewFormat(viewport.getAlignment()
+ .getSequencesArray(), getDisplayedFeatureCols(),
+ getDisplayedFeatureGroups(), true);
+ }
+ else
+ {
+ features = formatter.printGffFormat(viewport.getAlignment()
+ .getSequencesArray(), getDisplayedFeatureCols(),
+ getDisplayedFeatureGroups(), true);
+ }
+
+ if (displayTextbox)
+ {
+ boolean frimport = false;
+ if (features == null || features.equals("No Features Visible"))
+ {
+ features = "# No features visible - paste some and import them here.";
+ frimport = true;
+ }
+
+ CutAndPasteTransfer cap = new CutAndPasteTransfer(frimport, this);
+ if (frimport)
+ {
+ cap.setAnnotationImport();
+ }
+ Frame frame = new Frame();
+ frame.add(cap);
+ jalview.bin.JalviewLite.addFrame(frame,
+ MessageManager.getString("label.features"), 600, 500);
+ cap.setText(features);
+ }
+ else
+ {
+ if (features == null)
+ {
+ features = "";
+ }
+ }
+
+ return features;
+ }
+
+ void launchFullApplication()
+ {
+ StringBuffer url = new StringBuffer(jalviewServletURL);
+
+ // allow servlet parameters to be passed in applet parameter
+ String firstSep = url.lastIndexOf("?") > url.lastIndexOf("/") ? "&"
+ : "?";
+ url.append(firstSep);
+
+ url.append(
+ "open=" + appendProtocol(viewport.applet.getParameter("file")));
+
+ if (viewport.applet.getParameter("features") != null)
+ {
+ url.append("&features=");
+ url.append(appendProtocol(viewport.applet.getParameter("features")));
+ }
+
+ if (viewport.applet.getParameter("annotations") != null)
+ {
+ url.append("&annotations=");
+ url.append(
+ appendProtocol(viewport.applet.getParameter("annotations")));
+ }
+
+ if (viewport.applet.getParameter("jnetfile") != null
+ || viewport.applet.getParameter("jpredfile") != null)
+ {
+ url.append("&annotations=");
+ url.append(appendProtocol(
+ viewport.applet.getParameter("jnetfile") != null
+ ? viewport.applet.getParameter("jnetfile")
+ : viewport.applet.getParameter("jpredfile")));
+ }
+
+ if (viewport.applet.getParameter("defaultColour") != null)
+ {
+ url.append("&colour=" + removeWhiteSpace(
+ viewport.applet.getParameter("defaultColour")));
+ }
+
+ if (viewport.applet.getParameter("userDefinedColour") != null)
+ {
+ url.append("&colour=" + removeWhiteSpace(
+ viewport.applet.getParameter("userDefinedColour")));
+ }
+ if (viewport.applet.getParameter("tree") != null)
+ {
+ url.append("&tree="
+ + appendProtocol(viewport.applet.getParameter("tree")));
+ }
+ if (viewport.applet.getParameter("treeFile") != null)
+ {
+ url.append("&tree="
+ + appendProtocol(viewport.applet.getParameter("treeFile")));
+ }
+
+ showURL(url.toString(), "FULL_APP");
+ }
+
+ String removeWhiteSpace(String colour)
+ {
+ StringBuffer sb = new StringBuffer();
+ for (int i = 0; i < colour.length(); i++)
+ {
+ if (Character.isWhitespace(colour.charAt(i)))
+ {
+ sb.append("%20");
+ }
+ else
+ {
+ sb.append(colour.charAt(i));
+ }
+ }
+
+ return sb.toString();
+ }
+
+ String appendProtocol(String url)
+ {
+ try
+ {
+ new URL(url);
+ url = URLEncoder.encode(url);
+ }
+ /*
+ * When we finally deprecate 1.1 compatibility, we can start to use
+ * URLEncoder.encode(url,"UTF-8") and then we'll need this catch: catch
+ * (UnsupportedEncodingException ex) { System.err.println("WARNING -
+ * IMPLEMENTATION ERROR - UNSUPPORTED ENCODING EXCEPTION FOR "+url);
+ * ex.printStackTrace(); }
+ */
+ catch (java.net.MalformedURLException ex)
+ {
+ url = viewport.applet.getCodeBase() + url;
+ }
+ return url;
+ }
+
+ public void closeMenuItem_actionPerformed()
+ {
+ PaintRefresher.RemoveComponent(alignPanel);
+ if (alignPanel.seqPanel != null
+ && alignPanel.seqPanel.seqCanvas != null)
+ {
+ PaintRefresher.RemoveComponent(alignPanel.seqPanel.seqCanvas);
+ }
+ if (alignPanel.idPanel != null && alignPanel.idPanel.idCanvas != null)
+ {
+ PaintRefresher.RemoveComponent(alignPanel.idPanel.idCanvas);
+ }
+
+ if (PaintRefresher.components.size() == 0 && viewport.applet == null)
+ {
+ System.exit(0);
+ }
+
+ viewport = null;
+ if (alignPanel != null && alignPanel.overviewPanel != null)
+ {
+ alignPanel.overviewPanel.dispose();
+ }
+ alignPanel = null;
+ this.dispose();
+ }
+
+ /**
+ * TODO: JAL-1104
+ */
+ void updateEditMenuBar()
+ {
+
+ if (viewport.getHistoryList().size() > 0)
+ {
+ undoMenuItem.setEnabled(true);
+ CommandI command = viewport.getHistoryList().peek();
+ undoMenuItem.setLabel(MessageManager
+ .formatMessage("label.undo_command", new Object[]
+ { command.getDescription() }));
+ }
+ else
+ {
+ undoMenuItem.setEnabled(false);
+ undoMenuItem.setLabel(MessageManager.getString("action.undo"));
+ }
+
+ if (viewport.getRedoList().size() > 0)
+ {
+ redoMenuItem.setEnabled(true);
+
+ CommandI command = viewport.getRedoList().peek();
+ redoMenuItem.setLabel(MessageManager
+ .formatMessage("label.redo_command", new Object[]
+ { command.getDescription() }));
+ }
+ else
+ {
+ redoMenuItem.setEnabled(false);
+ redoMenuItem.setLabel(MessageManager.getString("action.redo"));
+ }
+ }
+
+ /**
+ * TODO: JAL-1104
+ */
+ @Override
+ public void addHistoryItem(CommandI command)
+ {
+ if (command.getSize() > 0)
+ {
+ viewport.addToHistoryList(command);
+ viewport.clearRedoList();
+ updateEditMenuBar();
+ viewport.updateHiddenColumns();
+ }
+ }
+
+ /**
+ * TODO: JAL-1104 DOCUMENT ME!
+ *
+ * @param e
+ * DOCUMENT ME!
+ */
+ protected void undoMenuItem_actionPerformed()
+ {
+ if (viewport.getHistoryList().isEmpty())
+ {
+ return;
+ }
+
+ CommandI command = viewport.getHistoryList().pop();
+ viewport.addToRedoList(command);
+ command.undoCommand(null);
+
+ AlignmentViewport originalSource = getOriginatingSource(command);
+ // JBPNote Test
+ if (originalSource != viewport)
+ {
+ System.err
+ .println("Warning: Viewport object mismatch whilst undoing");
+ }
+ originalSource.updateHiddenColumns(); // originalSource.hasHiddenColumns =
+ // viewport.getColumnSelection().getHiddenColumns()
+ // != null;
+ updateEditMenuBar();
+ originalSource.firePropertyChange("alignment", null,
+ originalSource.getAlignment().getSequences());
+ }
+
+ /**
+ * TODO: JAL-1104 DOCUMENT ME!
+ *
+ * @param e
+ * DOCUMENT ME!
+ */
+ protected void redoMenuItem_actionPerformed()
+ {
+ if (viewport.getRedoList().isEmpty())
+ {
+ return;
+ }
+
+ CommandI command = viewport.getRedoList().pop();
+ viewport.addToHistoryList(command);
+ command.doCommand(null);
+
+ AlignmentViewport originalSource = getOriginatingSource(command);
+ // JBPNote Test
+ if (originalSource != viewport)
+ {
+ System.err
+ .println("Warning: Viewport object mismatch whilst re-doing");
+ }
+ originalSource.updateHiddenColumns(); // sethasHiddenColumns(); =
+ // viewport.getColumnSelection().getHiddenColumns()
+ // != null;
+
+ updateEditMenuBar();
+ originalSource.firePropertyChange("alignment", null,
+ originalSource.getAlignment().getSequences());
+ }
+
+ AlignmentViewport getOriginatingSource(CommandI command)
+ {
+ AlignmentViewport originalSource = null;
+ // For sequence removal and addition, we need to fire
+ // the property change event FROM the viewport where the
+ // original alignment was altered
+ AlignmentI al = null;
+ if (command instanceof EditCommand)
+ {
+ EditCommand editCommand = (EditCommand) command;
+ al = editCommand.getAlignment();
+ Vector comps = PaintRefresher.components
+ .get(viewport.getSequenceSetId());
+ for (int i = 0; i < comps.size(); i++)
+ {
+ if (comps.elementAt(i) instanceof AlignmentPanel)
+ {
+ if (al == ((AlignmentPanel) comps.elementAt(i)).av.getAlignment())
+ {
+ originalSource = ((AlignmentPanel) comps.elementAt(i)).av;
+ break;
+ }
+ }
+ }
+ }
+
+ if (originalSource == null)
+ {
+ // The original view is closed, we must validate
+ // the current view against the closed view first
+ if (al != null)
+ {
+ PaintRefresher.validateSequences(al, viewport.getAlignment());
+ }
+
+ originalSource = viewport;
+ }
+
+ return originalSource;
+ }
+
+ /**
+ * Move the currently selected sequences up or down one position in the
+ * alignment
+ *
+ * @param up
+ */
+ public void moveSelectedSequences(boolean up)
+ {
+ SequenceGroup sg = viewport.getSelectionGroup();
+ if (sg == null)
+ {
+ return;
+ }
+ viewport.getAlignment().moveSelectedSequencesByOne(sg,
+ up ? null : viewport.getHiddenRepSequences(), up);
+ alignPanel.paintAlignment(true, false);
+
+ /*
+ * Also move cDNA/protein complement sequences
+ */
+ AlignViewportI complement = viewport.getCodingComplement();
+ if (complement != null)
+ {
+ SequenceGroup mappedSelection = MappingUtils.mapSequenceGroup(sg,
+ viewport, complement);
+ complement.getAlignment().moveSelectedSequencesByOne(mappedSelection,
+ up ? null : complement.getHiddenRepSequences(), up);
+ getSplitFrame().getComplement(this).alignPanel.paintAlignment(true,
+ false);
+ }
+ }
+
+ synchronized void slideSequences(boolean right, int size)
+ {
+ List<SequenceI> sg = new Vector<>();
+ if (viewport.cursorMode)
+ {
+ sg.add(viewport.getAlignment()
+ .getSequenceAt(alignPanel.seqPanel.seqCanvas.cursorY));
+ }
+ else if (viewport.getSelectionGroup() != null
+ && viewport.getSelectionGroup().getSize() != viewport
+ .getAlignment().getHeight())
+ {
+ sg = viewport.getSelectionGroup()
+ .getSequences(viewport.getHiddenRepSequences());
+ }
+
+ if (sg.size() < 1)
+ {
+ return;
+ }
+
+ Vector<SequenceI> invertGroup = new Vector();
+
+ for (int i = 0; i < viewport.getAlignment().getHeight(); i++)
+ {
+ if (!sg.contains(viewport.getAlignment().getSequenceAt(i)))
+ {
+ invertGroup.addElement(viewport.getAlignment().getSequenceAt(i));
+ }
+ }
+
+ SequenceI[] seqs1 = sg.toArray(new SequenceI[sg.size()]);
+
+ SequenceI[] seqs2 = invertGroup
+ .toArray(new SequenceI[invertGroup.size()]);
+ for (int i = 0; i < invertGroup.size(); i++)
+ {
+ seqs2[i] = invertGroup.elementAt(i);
+ }
+
+ SlideSequencesCommand ssc;
+ if (right)
+ {
+ ssc = new SlideSequencesCommand("Slide Sequences", seqs2, seqs1, size,
+ viewport.getGapCharacter());
+ }
+ else
+ {
+ ssc = new SlideSequencesCommand("Slide Sequences", seqs1, seqs2, size,
+ viewport.getGapCharacter());
+ }
+
+ int groupAdjustment = 0;
+ if (ssc.getGapsInsertedBegin() && right)
+ {
+ if (viewport.cursorMode)
+ {
+ alignPanel.seqPanel.moveCursor(size, 0);
+ }
+ else
+ {
+ groupAdjustment = size;
+ }
+ }
+ else if (!ssc.getGapsInsertedBegin() && !right)
+ {
+ if (viewport.cursorMode)
+ {
+ alignPanel.seqPanel.moveCursor(-size, 0);
+ }
+ else
+ {
+ groupAdjustment = -size;
+ }
+ }
+
+ if (groupAdjustment != 0)
+ {
+ viewport.getSelectionGroup().setStartRes(
+ viewport.getSelectionGroup().getStartRes() + groupAdjustment);
+ viewport.getSelectionGroup().setEndRes(
+ viewport.getSelectionGroup().getEndRes() + groupAdjustment);
+ }
+
+ boolean appendHistoryItem = false;
+ Deque<CommandI> historyList = viewport.getHistoryList();
+ if (historyList != null && historyList.size() > 0
+ && historyList.peek() instanceof SlideSequencesCommand)
+ {
+ appendHistoryItem = ssc.appendSlideCommand(
+ (SlideSequencesCommand) historyList.peek());
+ }
+
+ if (!appendHistoryItem)
+ {
+ addHistoryItem(ssc);
+ }
+
+ repaint();
+ }
+
+ static StringBuffer copiedSequences;
+
+ static Vector<int[]> copiedHiddenColumns;
+
+ protected void copy_actionPerformed()
+ {
+ if (viewport.getSelectionGroup() == null)
+ {
+ return;
+ }
+
+ SequenceGroup sg = viewport.getSelectionGroup();
+ copiedSequences = new StringBuffer();
+ Map<Integer, SequenceI> orderedSeqs = new HashMap<>();
+ for (int i = 0; i < sg.getSize(); i++)
+ {
+ SequenceI seq = sg.getSequenceAt(i);
+ int index = viewport.getAlignment().findIndex(seq);
+ orderedSeqs.put(index, seq);
+ }
+
+ int index = 0, startRes, endRes;
+ char ch;
+
+ if (viewport.hasHiddenColumns() && viewport.getSelectionGroup() != null)
+ {
+ copiedHiddenColumns = new Vector<>(viewport.getAlignment()
+ .getHiddenColumns().getHiddenColumnsCopy());
+ int hiddenOffset = viewport.getSelectionGroup().getStartRes();
+ for (int[] region : copiedHiddenColumns)
+ {
+ region[0] = region[0] - hiddenOffset;
+ region[1] = region[1] - hiddenOffset;
+ }
+ }
+ else
+ {
+ copiedHiddenColumns = null;
+ }
+
+ for (int i = 0; i < sg.getSize(); i++)
+ {
+ SequenceI seq = null;
+
+ while (seq == null)
+ {
+ if (orderedSeqs.containsKey(index))
+ {
+ seq = orderedSeqs.get(index);
+ index++;
+ break;
+ }
+ else
+ {
+ index++;
+ }
+ }
+
+ // FIND START RES
+ // Returns residue following index if gap
+ startRes = seq.findPosition(sg.getStartRes());
+
+ // FIND END RES
+ // Need to find the residue preceeding index if gap
+ endRes = 0;
+
+ for (int j = 0; j < sg.getEndRes() + 1 && j < seq.getLength(); j++)
+ {
+ ch = seq.getCharAt(j);
+ if (!jalview.util.Comparison.isGap((ch)))
+ {
+ endRes++;
+ }
+ }
+
+ if (endRes > 0)
+ {
+ endRes += seq.getStart() - 1;
+ }
+
+ copiedSequences.append(seq.getName() + "\t" + startRes + "\t" + endRes
+ + "\t" + seq.getSequenceAsString(sg.getStartRes(),
+ sg.getEndRes() + 1)
+ + "\n");
+ }
+
+ }
+
+ protected void pasteNew_actionPerformed()
+ {
+ paste(true);
+ }
+
+ protected void pasteThis_actionPerformed()
+ {
+ paste(false);
+ }
+
+ void paste(boolean newAlignment)
+ {
+ try
+ {
+
+ if (copiedSequences == null)
+ {
+ return;
+ }
+
+ StringTokenizer st = new StringTokenizer(copiedSequences.toString());
+ Vector seqs = new Vector();
+ while (st.hasMoreElements())
+ {
+ String name = st.nextToken();
+ int start = Integer.parseInt(st.nextToken());
+ int end = Integer.parseInt(st.nextToken());
+ seqs.addElement(new Sequence(name, st.nextToken(), start, end));
+ }
+ SequenceI[] newSeqs = new SequenceI[seqs.size()];
+ for (int i = 0; i < seqs.size(); i++)
+ {
+ newSeqs[i] = (SequenceI) seqs.elementAt(i);
+ }
+
+ if (newAlignment)
+ {
+ String newtitle = MessageManager
+ .getString("label.copied_sequences");
+ if (getTitle().startsWith(
+ MessageManager.getString("label.copied_sequences")))
+ {
+ newtitle = getTitle();
+ }
+ else
+ {
+ newtitle = newtitle.concat(MessageManager
+ .formatMessage("label.from_msname", new String[]
+ { getTitle() }));
+ }
+ AlignFrame af = new AlignFrame(new Alignment(newSeqs),
+ viewport.applet, newtitle, false);
+ if (copiedHiddenColumns != null)
+ {
+ for (int i = 0; i < copiedHiddenColumns.size(); i++)
+ {
+ int[] region = copiedHiddenColumns.elementAt(i);
+ af.viewport.hideColumns(region[0], region[1]);
+ }
+ }
+
+ jalview.bin.JalviewLite.addFrame(af, newtitle, frameWidth,
+ frameHeight);
+ }
+ else
+ {
+ addSequences(newSeqs);
+ }
+
+ } catch (Exception ex)
+ {
+ } // could be anything being pasted in here
+
+ }
+
+ void addSequences(SequenceI[] seqs)
+ {
+ for (int i = 0; i < seqs.length; i++)
+ {
+ viewport.getAlignment().addSequence(seqs[i]);
+ }
+
+ // !newAlignment
+ addHistoryItem(new EditCommand(
+ MessageManager.getString("label.add_sequences"), Action.PASTE,
+ seqs, 0, viewport.getAlignment().getWidth(),
+ viewport.getAlignment()));
+
+ viewport.getRanges().setEndSeq(viewport.getAlignment().getHeight());
+ viewport.getAlignment().getWidth();
+ viewport.firePropertyChange("alignment", null,
+ viewport.getAlignment().getSequences());
+
+ }
+
+ protected void cut_actionPerformed()
+ {
+ copy_actionPerformed();
+ delete_actionPerformed();
+ }
+
+ protected void delete_actionPerformed()
+ {
+
+ SequenceGroup sg = viewport.getSelectionGroup();
+ if (sg == null)
+ {
+ return;
+ }
+
+ Vector seqs = new Vector();
+ SequenceI seq;
+ for (int i = 0; i < sg.getSize(); i++)
+ {
+ seq = sg.getSequenceAt(i);
+ seqs.addElement(seq);
+ }
+
+ /*
+ * If the cut affects all sequences, warn, remove highlighted columns
+ */
+ if (sg.getSize() == viewport.getAlignment().getHeight())
+ {
+ boolean isEntireAlignWidth = (((sg.getEndRes() - sg.getStartRes())
+ + 1) == viewport.getAlignment().getWidth()) ? true : false;
+ if (isEntireAlignWidth)
+ {
+ String title = MessageManager.getString("label.delete_all");
+ Panel infoPanel = new Panel();
+ infoPanel.setLayout(new FlowLayout());
+ infoPanel.add(
+ new Label(MessageManager.getString("warn.delete_all")));
+
+ final JVDialog dialog = new JVDialog(this, title, true, 400, 200);
+ dialog.setMainPanel(infoPanel);
+ dialog.ok.setLabel(MessageManager.getString("action.ok"));
+ dialog.cancel.setLabel(MessageManager.getString("action.cancel"));
+ dialog.setVisible(true);
+
+ if (!dialog.accept)
+ {
+ return;
+ }
+ }
+ viewport.getColumnSelection().removeElements(sg.getStartRes(),
+ sg.getEndRes() + 1);
+ }
+
+ SequenceI[] cut = new SequenceI[seqs.size()];
+ for (int i = 0; i < seqs.size(); i++)
+ {
+ cut[i] = (SequenceI) seqs.elementAt(i);
+ }
+
+ /*
+ * //ADD HISTORY ITEM
+ */
+ addHistoryItem(new EditCommand(
+ MessageManager.getString("label.cut_sequences"), Action.CUT,
+ cut, sg.getStartRes(), sg.getEndRes() - sg.getStartRes() + 1,
+ viewport.getAlignment()));
+
+ viewport.setSelectionGroup(null);
+ viewport.getAlignment().deleteGroup(sg);
+
+ viewport.firePropertyChange("alignment", null,
+ viewport.getAlignment().getSequences());
+
+ if (viewport.getAlignment().getHeight() < 1)
+ {
+ this.setVisible(false);
+ }
+ viewport.sendSelection();
+ }
+
+ /**
+ * group consensus toggled
+ *
+ */
+ protected void showGroupConsensus_actionPerformed()
+ {
+ viewport.setShowGroupConsensus(showGroupConsensus.getState());
+ alignPanel.updateAnnotation(applyAutoAnnotationSettings.getState());
+
+ }
+
+ /**
+ * group conservation toggled.
+ */
+ protected void showGroupConservation_actionPerformed()
+ {
+ viewport.setShowGroupConservation(showGroupConservation.getState());
+ alignPanel.updateAnnotation(applyAutoAnnotationSettings.getState());
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see
+ * jalview.jbgui.GAlignFrame#showConsensusHistogram_actionPerformed(java.awt
+ * .event.ActionEvent)
+ */
+ protected void showConsensusHistogram_actionPerformed()
+ {
+ viewport.setShowConsensusHistogram(showConsensusHistogram.getState());
+ alignPanel.updateAnnotation(applyAutoAnnotationSettings.getState());
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see
+ * jalview.jbgui.GAlignFrame#showConsensusProfile_actionPerformed(java.awt
+ * .event.ActionEvent)
+ */
+ protected void showSequenceLogo_actionPerformed()
+ {
+ viewport.setShowSequenceLogo(showSequenceLogo.getState());
+ alignPanel.updateAnnotation(applyAutoAnnotationSettings.getState());
+ }
+
+ protected void normSequenceLogo_actionPerformed()
+ {
+ showSequenceLogo.setState(true);
+ viewport.setShowSequenceLogo(true);
+ viewport.setNormaliseSequenceLogo(normSequenceLogo.getState());
+ alignPanel.updateAnnotation(applyAutoAnnotationSettings.getState());
+ }
+
+ protected void applyAutoAnnotationSettings_actionPerformed()
+ {
+ alignPanel.updateAnnotation(applyAutoAnnotationSettings.getState());
+ }
+
+ protected void makeGrpsFromSelection_actionPerformed()
+ {
+ if (avc.makeGroupsFromSelection())
+ {
+ PaintRefresher.Refresh(this, viewport.getSequenceSetId());
+ alignPanel.updateAnnotation();
+ alignPanel.paintAlignment(true, true);
+ }
+ }
+
+ protected void createGroup_actionPerformed()
+ {
+ avc.createGroup();
+ }
+
+ protected void unGroup_actionPerformed()
+ {
+ if (avc.unGroup())
+ {
+ alignPanel.alignmentChanged();
+ }
+ }
+
+ protected void deleteGroups_actionPerformed()
+ {
+ if (avc.deleteGroups())
+ {
+ alignPanel.alignmentChanged();
+ }
+ }
+
+ public void selectAllSequenceMenuItem_actionPerformed()
+ {
+ 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);
+ // JAL-2034 - should delegate to
+ // alignPanel to decide if overview needs
+ // updating.
+ alignPanel.paintAlignment(false, false);
+ PaintRefresher.Refresh(alignPanel, viewport.getSequenceSetId());
+ viewport.sendSelection();
+ }
+
+ public void deselectAllSequenceMenuItem_actionPerformed()
+ {
+ if (viewport.cursorMode)
+ {
+ alignPanel.seqPanel.keyboardNo1 = null;
+ alignPanel.seqPanel.keyboardNo2 = null;
+ }
+ viewport.setSelectionGroup(null);
+ viewport.getColumnSelection().clear();
+ viewport.setSelectionGroup(null);
+ alignPanel.idPanel.idCanvas.searchResults = null;
+ alignPanel.seqPanel.seqCanvas.highlightSearchResults(null);
+ // JAL-2034 - should delegate to
+ // alignPanel to decide if overview needs
+ // updating.
+ alignPanel.paintAlignment(false, false);
+ PaintRefresher.Refresh(alignPanel, viewport.getSequenceSetId());
+ viewport.sendSelection();
+ }
+
+ public void invertSequenceMenuItem_actionPerformed()
+ {
+ SequenceGroup sg = viewport.getSelectionGroup();
+ for (int i = 0; i < viewport.getAlignment().getSequences().size(); i++)
+ {
+ sg.addOrRemove(viewport.getAlignment().getSequenceAt(i), false);
+ }
+
+ PaintRefresher.Refresh(alignPanel, viewport.getSequenceSetId());
+ viewport.sendSelection();
+ }
+
+ public void invertColSel_actionPerformed()
+ {
+ viewport.invertColumnSelection();
+ alignPanel.paintAlignment(true, false);
+ PaintRefresher.Refresh(alignPanel, viewport.getSequenceSetId());
+ viewport.sendSelection();
+ }
+
+ void trimAlignment(boolean trimLeft)
+ {
+ AlignmentI al = viewport.getAlignment();
+ ViewportRanges ranges = viewport.getRanges();
+ ColumnSelection colSel = viewport.getColumnSelection();
+ int column;
+
+ if (!colSel.isEmpty())
+ {
+ if (trimLeft)
+ {
+ column = colSel.getMin();
+ }
+ else
+ {
+ column = colSel.getMax();
+ }
+
+ SequenceI[] seqs;
+ if (viewport.getSelectionGroup() != null)
+ {
+ seqs = viewport.getSelectionGroup()
+ .getSequencesAsArray(viewport.getHiddenRepSequences());
+ }
+ else
+ {
+ seqs = al.getSequencesArray();
+ }
+
+ TrimRegionCommand trimRegion;
+ if (trimLeft)
+ {
+ trimRegion = new TrimRegionCommand("Remove Left", true, seqs,
+ column, al);
+ ranges.setStartRes(0);
+ }
+ else
+ {
+ trimRegion = new TrimRegionCommand("Remove Right", false, seqs,
+ column, al);
+ }
+
+ statusBar.setText(MessageManager
+ .formatMessage("label.removed_columns", new String[]
+ { Integer.valueOf(trimRegion.getSize()).toString() }));
+ addHistoryItem(trimRegion);
+
+ for (SequenceGroup sg : al.getGroups())
+ {
+ if ((trimLeft && !sg.adjustForRemoveLeft(column))
+ || (!trimLeft && !sg.adjustForRemoveRight(column)))
+ {
+ al.deleteGroup(sg);
+ }
+ }
+
+ viewport.firePropertyChange("alignment", null, al.getSequences());
+ }
+ }
+
+ public void removeGappedColumnMenuItem_actionPerformed()
+ {
+ AlignmentI al = viewport.getAlignment();
+ ViewportRanges ranges = viewport.getRanges();
+ int start = 0;
+ int end = ranges.getAbsoluteAlignmentWidth() - 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(MessageManager
+ .formatMessage("label.removed_empty_columns", new String[]
+ { Integer.valueOf(removeGapCols.getSize()).toString() }));
+
+ // This is to maintain viewport position on first residue
+ // of first sequence
+ SequenceI seq = al.getSequenceAt(0);
+ int startRes = seq.findPosition(ranges.getStartRes());
+ // ShiftList shifts;
+ // viewport.getAlignment().removeGaps(shifts=new ShiftList());
+ // edit.alColumnChanges=shifts.getInverse();
+ // if (viewport.hasHiddenColumns)
+ // viewport.getColumnSelection().compensateForEdits(shifts);
+ ranges.setStartRes(seq.findIndex(startRes) - 1);
+ viewport.firePropertyChange("alignment", null, al.getSequences());
+
+ }
+
+ public void removeAllGapsMenuItem_actionPerformed()
+ {
+ AlignmentI al = viewport.getAlignment();
+ ViewportRanges ranges = viewport.getRanges();
+ int start = 0;
+ int end = ranges.getAbsoluteAlignmentWidth() - 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 = al.getSequenceAt(0);
+ int startRes = seq.findPosition(ranges.getStartRes());
+
+ addHistoryItem(
+ new RemoveGapsCommand("Remove Gaps", seqs, start, end, al));
+
+ ranges.setStartRes(seq.findIndex(startRes) - 1);
+
+ viewport.firePropertyChange("alignment", null, al.getSequences());
+
+ }
+
+ public void findMenuItem_actionPerformed()
+ {
+ new Finder(alignPanel);
+ }
+
+ /**
+ * create a new view derived from the current view
+ *
+ * @param viewtitle
+ * @return frame for the new view
+ */
+ public AlignFrame newView(String viewtitle)
+ {
+ AlignmentI newal;
+ if (viewport.hasHiddenRows())
+ {
+ newal = new Alignment(viewport.getAlignment().getHiddenSequences()
+ .getFullAlignment().getSequencesArray());
+ }
+ else
+ {
+ newal = new Alignment(viewport.getAlignment().getSequencesArray());
+ }
+
+ if (viewport.getAlignment().getAlignmentAnnotation() != null)
+ {
+ for (int i = 0; i < viewport.getAlignment()
+ .getAlignmentAnnotation().length; i++)
+ {
+ if (!viewport.getAlignment()
+ .getAlignmentAnnotation()[i].autoCalculated)
+ {
+ newal.addAnnotation(
+ viewport.getAlignment().getAlignmentAnnotation()[i]);
+ }
+ }
+ }
+
+ AlignFrame newaf = new AlignFrame(newal, viewport.applet, "", false);
+
+ newaf.viewport.setSequenceSetId(alignPanel.av.getSequenceSetId());
+ PaintRefresher.Register(alignPanel, alignPanel.av.getSequenceSetId());
+ PaintRefresher.Register(newaf.alignPanel,
+ newaf.alignPanel.av.getSequenceSetId());
+
+ PaintRefresher.Register(newaf.alignPanel.idPanel.idCanvas,
+ newaf.alignPanel.av.getSequenceSetId());
+ PaintRefresher.Register(newaf.alignPanel.seqPanel.seqCanvas,
+ newaf.alignPanel.av.getSequenceSetId());
+
+ Vector comps = PaintRefresher.components
+ .get(viewport.getSequenceSetId());
+ int viewSize = -1;
+ for (int i = 0; i < comps.size(); i++)
+ {
+ if (comps.elementAt(i) instanceof AlignmentPanel)
+ {
+ viewSize++;
+ }
+ }
+
+ String title = new String(this.getTitle());
+ if (viewtitle != null)
+ {
+ title = viewtitle + " ( " + title + ")";