+ alignPanel.paintAlignment(true);
+ }
+ 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)
+ {
+ 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);
+ jalview.bin.JalviewLite.addFrame(frame, MessageManager.formatMessage(
+ "label.alignment_output_command",
+ new Object[] { e.getActionCommand() }), 600, 500);
+
+ FeatureRenderer fr = this.alignPanel.cloneFeatureRenderer();
+ cap.setText(new AppletFormatAdapter(alignPanel).formatSequences(
+ e.getActionCommand(), 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, Object> getDisplayedFeatureCols()
+ {
+ if (alignPanel.getFeatureRenderer() != null
+ && viewport.getFeaturesDisplayed() != null)
+ {
+ return alignPanel.getFeatureRenderer().getDisplayedFeatureCols();
+
+ }
+ return null;
+ }
+
+ public String outputFeatures(boolean displayTextbox, String format)
+ {
+ String features;
+ if (format.equalsIgnoreCase("Jalview"))
+ {
+ features = new FeaturesFile().printJalviewFormat(viewport
+ .getAlignment().getSequencesArray(),
+ getDisplayedFeatureCols());
+ }
+ else
+ {
+ features = new FeaturesFile().printGFFFormat(viewport.getAlignment()
+ .getSequencesArray(), getDisplayedFeatureCols());
+ }
+
+ 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)
+ {
+ url.append("&annotations=");
+ url.append(appendProtocol(viewport.applet.getParameter("jnetfile")));
+ }
+
+ 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);
+ }
+ else
+ {
+ }
+ viewport = null;
+ 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 = (Vector) 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);
+
+ /*
+ * 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);
+ // TODO need to trigger a repaint of the complementary panel - how?
+ // would prefer to handle in SplitFrame but it is not overriding key
+ // listener chiz
+ }
+ }
+
+ synchronized void slideSequences(boolean right, int size)
+ {
+ List<SequenceI> sg = new Vector<SequenceI>();
+ 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 copiedHiddenColumns;
+
+ protected void copy_actionPerformed()
+ {
+ if (viewport.getSelectionGroup() == null)
+ {
+ return;
+ }
+
+ SequenceGroup sg = viewport.getSelectionGroup();
+ copiedSequences = new StringBuffer();
+ Map<Integer, SequenceI> orderedSeqs = new HashMap<Integer, SequenceI>();
+ 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();
+ int hiddenOffset = viewport.getSelectionGroup().getStartRes();
+ for (int[] region : viewport.getColumnSelection().getHiddenColumns())
+ {
+ copiedHiddenColumns.addElement(new int[] {
+ region[0] - hiddenOffset, 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 = (int[]) 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.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, remove highlighted columns
+ if (sg.getSize() == viewport.getAlignment().getHeight())
+ {
+ 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);
+ }
+ }
+
+ 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);
+ alignPanel.paintAlignment(true);
+ 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);
+ alignPanel.paintAlignment(true);
+ 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);
+ PaintRefresher.Refresh(alignPanel, viewport.getSequenceSetId());
+ viewport.sendSelection();
+ }
+
+ 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(MessageManager.formatMessage(
+ "label.removed_columns",
+ new String[] { Integer.valueOf(trimRegion.getSize())
+ .toString() }));
+ 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());