+ if(originalSource!=null)
+ {
+ originalSource.hasHiddenColumns = viewport.colSel.getHiddenColumns() != null;
+ originalSource.firePropertyChange("alignment",
+ null,
+ originalSource.alignment.getSequences());
+ }
+ }
+
+ AlignViewport getOriginatingSource(CommandI command)
+ {
+ AlignViewport 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.alignment)
+ {
+ 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.alignment);
+ }
+
+ originalSource = viewport;
+ }
+
+ return originalSource;
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param up DOCUMENT ME!
+ */
+ public void moveSelectedSequences(boolean up)
+ {
+ SequenceGroup sg = viewport.getSelectionGroup();
+
+ if (sg == null)
+ {
+ return;
+ }
+
+ if (up)
+ {
+ for (int i = 1; i < viewport.alignment.getHeight(); i++)
+ {
+ SequenceI seq = viewport.alignment.getSequenceAt(i);
+
+ if (!sg.getSequences(null).contains(seq))
+ {
+ continue;
+ }
+
+ SequenceI temp = viewport.alignment.getSequenceAt(i - 1);
+
+ if (sg.getSequences(null).contains(temp))
+ {
+ continue;
+ }
+
+ viewport.alignment.getSequences().setElementAt(temp, i);
+ viewport.alignment.getSequences().setElementAt(seq, i - 1);
+ }
+ }
+ else
+ {
+ for (int i = viewport.alignment.getHeight() - 2; i > -1; i--)
+ {
+ SequenceI seq = viewport.alignment.getSequenceAt(i);
+
+ if (!sg.getSequences(null).contains(seq))
+ {
+ continue;
+ }
+
+ SequenceI temp = viewport.alignment.getSequenceAt(i + 1);
+
+ if (sg.getSequences(null).contains(temp))
+ {
+ continue;
+ }
+
+ viewport.alignment.getSequences().setElementAt(temp, i);
+ viewport.alignment.getSequences().setElementAt(seq, i + 1);
+ }
+ }
+
+ alignPanel.paintAlignment(true);
+ }
+
+
+
+
+ synchronized void slideSequences(boolean right, int size)
+ {
+ Vector sg = new Vector();
+ if(viewport.cursorMode)
+ {
+ sg.addElement(viewport.alignment.getSequenceAt(
+ alignPanel.seqPanel.seqCanvas.cursorY));
+ }
+ else if(viewport.getSelectionGroup()!=null
+ && viewport.getSelectionGroup().getSize()!=viewport.alignment.getHeight())
+ {
+ sg = viewport.getSelectionGroup().getSequences(
+ viewport.hiddenRepSequences);
+ }
+
+ if(sg.size()<1)
+ {
+ return;
+ }
+
+ Vector invertGroup = new Vector();
+
+ for (int i = 0; i < viewport.alignment.getHeight(); i++)
+ {
+ if(!sg.contains(viewport.alignment.getSequenceAt(i)))
+ invertGroup.add(viewport.alignment.getSequenceAt(i));
+ }
+
+ SequenceI[] seqs1 = new SequenceI[sg.size()];
+ for (int i = 0; i < sg.size(); i++)
+ seqs1[i] = (SequenceI) sg.elementAt(i);
+
+ SequenceI[] seqs2 = new SequenceI[invertGroup.size()];
+ for (int i = 0; i < invertGroup.size(); i++)
+ seqs2[i] = (SequenceI) 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;
+ if(viewport.historyList!=null
+ && viewport.historyList.size()>0
+ && viewport.historyList.peek() instanceof SlideSequencesCommand)
+ {
+ appendHistoryItem = ssc.appendSlideCommand(
+ (SlideSequencesCommand)viewport.historyList.peek())
+ ;
+ }
+
+ if(!appendHistoryItem)
+ addHistoryItem(ssc);
+
+ repaint();
+ }
+
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e DOCUMENT ME!
+ */
+ protected void copy_actionPerformed(ActionEvent e)
+ {
+ System.gc();
+ if (viewport.getSelectionGroup() == null)
+ {
+ return;
+ }
+
+ SequenceI [] seqs = viewport.getSelectionAsNewSequence();
+ String[] omitHidden = null;
+
+ if (viewport.hasHiddenColumns)
+ {
+ omitHidden = viewport.getViewAsString(true);
+ }
+
+ String output = new FormatAdapter().formatSequences(
+ "Fasta",
+ seqs,
+ omitHidden);
+
+ StringSelection ss = new StringSelection(output);
+
+ try
+ {
+ jalview.gui.Desktop.internalCopy = true;
+ //Its really worth setting the clipboard contents
+ //to empty before setting the large StringSelection!!
+ Toolkit.getDefaultToolkit().getSystemClipboard()
+ .setContents(new StringSelection(""), null);
+
+ Toolkit.getDefaultToolkit().getSystemClipboard()
+ .setContents(ss, Desktop.instance);
+ }
+ catch (OutOfMemoryError er)
+ {
+ er.printStackTrace();
+ javax.swing.SwingUtilities.invokeLater(new Runnable()
+ {
+ public void run()
+ {
+ javax.swing.JOptionPane.showInternalMessageDialog(Desktop.desktop,
+ "Out of memory copying region!!"
+ +
+ "\nSee help files for increasing Java Virtual Machine memory."
+ , "Out of memory",
+ javax.swing.JOptionPane.WARNING_MESSAGE);
+ }
+ });
+
+ return;
+ }
+
+ Vector hiddenColumns = null;
+ if(viewport.hasHiddenColumns)
+ {
+ hiddenColumns =new Vector();
+ int hiddenOffset = viewport.getSelectionGroup().getStartRes();
+ for (int i = 0; i < viewport.getColumnSelection().getHiddenColumns().size();
+ i++)
+ {
+ int[] region = (int[])
+ viewport.getColumnSelection().getHiddenColumns().elementAt(i);
+
+ hiddenColumns.addElement(new int[]
+ {region[0] - hiddenOffset,
+ region[1]-hiddenOffset});
+ }
+ }
+
+ Desktop.jalviewClipboard = new Object[]
+ {
+ seqs,
+ viewport.alignment.getDataset(),
+ hiddenColumns};
+ statusBar.setText("Copied "+seqs.length+" sequences to clipboard.");
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e DOCUMENT ME!
+ */
+ protected void pasteNew_actionPerformed(ActionEvent e)
+ {
+ paste(true);
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e DOCUMENT ME!
+ */
+ protected void pasteThis_actionPerformed(ActionEvent e)
+ {
+ paste(false);
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param newAlignment DOCUMENT ME!
+ */
+ void paste(boolean newAlignment)
+ {
+ try
+ {
+ Clipboard c = Toolkit.getDefaultToolkit().getSystemClipboard();
+ Transferable contents = c.getContents(this);
+
+ if (contents == null)
+ {
+ return;
+ }
+
+ String str, format;
+ try
+ {
+ str = (String) contents.getTransferData(DataFlavor.stringFlavor);
+ if (str.length() < 1)
+ {
+ return;
+ }
+
+ format = new IdentifyFile().Identify(str, "Paste");
+
+ }
+ catch (OutOfMemoryError er)
+ {
+ er.printStackTrace();
+ javax.swing.SwingUtilities.invokeLater(new Runnable()
+ {
+ public void run()
+ {
+ javax.swing.JOptionPane.showInternalMessageDialog(Desktop.desktop,
+ "Out of memory pasting sequences!!"
+ +
+ "\nSee help files for increasing Java Virtual Machine memory."
+ , "Out of memory",
+ javax.swing.JOptionPane.WARNING_MESSAGE);
+ }
+ });
+
+ return;
+ }
+
+ SequenceI[] sequences;
+
+
+ if(Desktop.jalviewClipboard!=null)
+ {
+ // The clipboard was filled from within Jalview, we must use the sequences
+ // And dataset from the copied alignment
+ sequences = (SequenceI[])Desktop.jalviewClipboard[0];
+ }
+ else
+ {
+ sequences = new FormatAdapter().readFile(str, "Paste", format).
+ getSequencesArray();
+ }
+
+ AlignmentI alignment = null;
+
+ if (newAlignment)
+ {
+ alignment = new Alignment(sequences);
+
+ if (Desktop.jalviewClipboard != null)
+ {
+ alignment.setDataset( (Alignment) Desktop.jalviewClipboard[1]);
+ }
+ else
+ {
+ alignment.setDataset(null);
+ }
+ }
+ else
+ {
+ alignment = viewport.getAlignment();
+
+ //!newAlignment
+ SequenceI [] newseqs = new SequenceI[sequences.length];
+ for (int i = 0; i < sequences.length; i++)
+ {
+ newseqs[i] = new Sequence(sequences[i].getName(),
+ sequences[i].getSequence(),
+ sequences[i].getStart(),
+ sequences[i].getEnd());
+
+ alignment.addSequence(newseqs[i]);
+ }
+
+ /*
+ //ADD HISTORY ITEM
+ */
+ addHistoryItem(new EditCommand(
+ "Add sequences",
+ EditCommand.PASTE,
+ newseqs,
+ 0,
+ alignment.getWidth(),
+ alignment)
+ );
+
+
+ viewport.setEndSeq(alignment.getHeight());
+ alignment.getWidth();
+ viewport.firePropertyChange("alignment", null, alignment.getSequences());
+ }
+
+
+
+ // Add any annotations attached to sequences
+ for (int i = 0; i < sequences.length; i++)
+ {
+ if (sequences[i].getAnnotation() != null)
+ {
+ for (int a = 0; a < sequences[i].getAnnotation().length; a++)
+ {
+ AlignmentAnnotation newAnnot =
+ new AlignmentAnnotation(
+ sequences[i].getAnnotation()[a].label,
+ sequences[i].getAnnotation()[a].description,
+ sequences[i].getAnnotation()[a].annotations,
+ sequences[i].getAnnotation()[a].graphMin,
+ sequences[i].getAnnotation()[a].graphMax,
+ sequences[i].getAnnotation()[a].graph);
+
+ sequences[i].getAnnotation()[a] = newAnnot;
+ newAnnot.sequenceMapping = sequences[i].getAnnotation()[a].
+ sequenceMapping;
+ newAnnot.sequenceRef = sequences[i];
+ newAnnot.adjustForAlignment();
+ alignment.addAnnotation(newAnnot);
+ alignment.setAnnotationIndex(newAnnot, a);
+ }
+
+ alignPanel.annotationPanel.adjustPanelHeight();
+ }
+ }
+
+ if(newAlignment)
+ {
+ AlignFrame af = new AlignFrame(alignment, DEFAULT_WIDTH, DEFAULT_HEIGHT);
+ String newtitle = new String("Copied sequences");
+
+ if(Desktop.jalviewClipboard!=null && Desktop.jalviewClipboard[2]!=null)
+ {
+ Vector hc = (Vector)Desktop.jalviewClipboard[2];
+ for(int i=0; i<hc.size(); i++)
+ {
+ int [] region = (int[]) hc.elementAt(i);
+ af.viewport.hideColumns(region[0], region[1]);
+ }
+ }
+
+
+ //>>>This is a fix for the moment, until a better solution is found!!<<<
+ af.alignPanel.seqPanel.seqCanvas.getFeatureRenderer().transferSettings(
+ alignPanel.seqPanel.seqCanvas.getFeatureRenderer());
+
+
+ if (title.startsWith("Copied sequences"))
+ {
+ newtitle = title;
+ }
+ else
+ {
+ newtitle = newtitle.concat("- from " + title);
+ }
+
+ Desktop.addInternalFrame(af, newtitle, DEFAULT_WIDTH,
+ DEFAULT_HEIGHT);
+
+ }
+
+
+ }
+ catch (Exception ex)
+ {
+ ex.printStackTrace();
+ System.out.println("Exception whilst pasting: "+ex);
+ // could be anything being pasted in here
+ }
+
+
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e DOCUMENT ME!
+ */
+ protected void cut_actionPerformed(ActionEvent e)
+ {
+ copy_actionPerformed(null);
+ delete_actionPerformed(null);
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e DOCUMENT ME!
+ */
+ protected void delete_actionPerformed(ActionEvent evt)
+ {
+
+ 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.alignment.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("Cut Sequences",
+ EditCommand.CUT,
+ cut,
+ sg.getStartRes(),
+ sg.getEndRes()-sg.getStartRes()+1,
+ viewport.alignment));
+
+
+ viewport.setSelectionGroup(null);
+ viewport.alignment.deleteGroup(sg);
+
+ viewport.firePropertyChange("alignment", null,
+ viewport.getAlignment().getSequences());
+
+ if (viewport.getAlignment().getHeight() < 1)
+ {
+ try
+ {
+ this.setClosed(true);
+ }
+ catch (Exception ex)
+ {
+ }
+ }
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e DOCUMENT ME!
+ */
+ protected void deleteGroups_actionPerformed(ActionEvent e)
+ {
+ viewport.alignment.deleteAllGroups();
+ viewport.sequenceColours = null;
+ viewport.setSelectionGroup(null);
+ PaintRefresher.Refresh(this, viewport.getSequenceSetId());
+ alignPanel.paintAlignment(true);
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e DOCUMENT ME!
+ */
+ 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.alignment.getWidth() - 1);
+ viewport.setSelectionGroup(sg);
+ alignPanel.paintAlignment(true);
+ PaintRefresher.Refresh(alignPanel, viewport.getSequenceSetId());
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e DOCUMENT ME!
+ */
+ 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());
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e DOCUMENT ME!
+ */
+ 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());
+ }
+
+ public void invertColSel_actionPerformed(ActionEvent e)
+ {
+ viewport.invertColumnSelection();
+ alignPanel.paintAlignment(true);
+ }
+
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e DOCUMENT ME!
+ */
+ public void remove2LeftMenuItem_actionPerformed(ActionEvent e)
+ {
+ trimAlignment(true);
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e DOCUMENT ME!
+ */
+ 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.
+ hiddenRepSequences);
+ }
+ else
+ {
+ seqs = viewport.alignment.getSequencesArray();
+ }
+
+
+ TrimRegionCommand trimRegion;
+ if(trimLeft)
+ {
+ trimRegion = new TrimRegionCommand("Remove Left",
+ TrimRegionCommand.TRIM_LEFT,
+ seqs,
+ column,
+ viewport.alignment,
+ viewport.colSel,
+ viewport.selectionGroup);
+ viewport.setStartRes(0);
+ }
+ else
+ {
+ trimRegion = new TrimRegionCommand("Remove Right",
+ TrimRegionCommand.TRIM_RIGHT,
+ seqs,
+ column,
+ viewport.alignment,
+ viewport.colSel,
+ viewport.selectionGroup);
+ }
+
+ statusBar.setText("Removed "+trimRegion.getSize()+" columns.");
+
+
+ addHistoryItem(trimRegion);
+
+ Vector groups = viewport.alignment.getGroups();
+
+ for (int i = 0; i < groups.size(); i++)
+ {
+ SequenceGroup sg = (SequenceGroup) groups.get(i);
+
+ if ( (trimLeft && !sg.adjustForRemoveLeft(column))
+ || (!trimLeft && !sg.adjustForRemoveRight(column)))
+ {
+ viewport.alignment.deleteGroup(sg);
+ }
+ }
+
+ viewport.firePropertyChange("alignment", null,
+ viewport.getAlignment().getSequences());
+ }
+ }
+
+ /**
+ * DOCUMENT ME!
+ *
+ * @param e DOCUMENT ME!
+ */
+ public void removeGappedColumnMenuItem_actionPerformed(ActionEvent e)
+ {
+ int start = 0, end = viewport.alignment.getWidth()-1;
+
+ SequenceI[] seqs;
+ if (viewport.getSelectionGroup() != null)
+ {
+ seqs = viewport.getSelectionGroup().getSequencesAsArray(viewport.
+ hiddenRepSequences);
+ start = viewport.getSelectionGroup().getStartRes();
+ end = viewport.getSelectionGroup().getEndRes();
+ }
+ else
+ {
+ seqs = viewport.alignment.getSequencesArray();
+ }
+
+
+ RemoveGapColCommand removeGapCols =
+ new RemoveGapColCommand("Remove Gapped Columns",
+ seqs,
+ start, end,
+ viewport.alignment);
+
+ addHistoryItem(removeGapCols);
+
+ statusBar.setText("Removed "+removeGapCols.getSize()+" empty columns.");
+
+ //This is to maintain viewport position on first residue
+ //of first sequence
+ SequenceI seq = viewport.alignment.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!
+ */
+ public void removeAllGapsMenuItem_actionPerformed(ActionEvent e)
+ {
+ int start = 0, end = viewport.alignment.getWidth()-1;
+
+ SequenceI[] seqs;
+ if (viewport.getSelectionGroup() != null)
+ {
+ seqs = viewport.getSelectionGroup().getSequencesAsArray(viewport.
+ hiddenRepSequences);
+ start = viewport.getSelectionGroup().getStartRes();
+ end = viewport.getSelectionGroup().getEndRes();
+ }