X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;ds=sidebyside;f=src%2Fjalview%2Fgui%2FAlignFrame.java;h=5685e42a13d28e2fa1db3a7df5b52ee5bdf2aa73;hb=c24071f7b9e6b70c94743214677871ae2dc88499;hp=f5d2e0c7fdcdf0760b6915e73c692eeb8049f7ea;hpb=875e6f6f18c96bfea4a43c951852921ee3f5ee75;p=jalview.git diff --git a/src/jalview/gui/AlignFrame.java b/src/jalview/gui/AlignFrame.java index f5d2e0c..5685e42 100755 --- a/src/jalview/gui/AlignFrame.java +++ b/src/jalview/gui/AlignFrame.java @@ -1,82 +1,365 @@ -/******************** - * 2004 Jalview Reengineered - * Barton Group - * Dundee University +/* + * Jalview - A Sequence Alignment Editor and Viewer + * Copyright (C) 2005 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle * - * AM Waterhouse - *******************/ - - - - + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Softwarechang + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ package jalview.gui; -import jalview.jbgui.GAlignFrame; -import jalview.schemes.*; -import jalview.datamodel.*; -import jalview.analysis.*; -import jalview.io.*; -import jalview.ws.*; -import MCview.*; +import java.beans.*; +import java.io.*; +import java.util.*; + import java.awt.*; +import java.awt.datatransfer.*; import java.awt.event.*; import java.awt.print.*; import javax.swing.*; -import javax.swing.event.*; -import java.util.*; -import jalview.datamodel.SequenceI; -public class AlignFrame extends GAlignFrame +import jalview.analysis.*; +import jalview.datamodel.*; +import jalview.io.*; +import jalview.jbgui.*; +import jalview.schemes.*; +import jalview.ws.*; +import java.awt.dnd.*; + + +/** + * DOCUMENT ME! + * + * @author $author$ + * @version $Revision$ + */ +public class AlignFrame + extends GAlignFrame implements ClipboardOwner, DropTargetListener { - final AlignmentPanel alignPanel; - final AlignViewport viewport; + /** DOCUMENT ME!! */ + public static final int NEW_WINDOW_WIDTH = 700; + + /** DOCUMENT ME!! */ + public static final int NEW_WINDOW_HEIGHT = 500; + AlignmentPanel alignPanel; + AlignViewport viewport; + + Vector viewports = new Vector(); + Vector alignPanels = new Vector(); + + /** DOCUMENT ME!! */ + public String currentFileFormat = null; + Stack historyList = new Stack(); + Stack redoList = new Stack(); + private int treeCount = 0; + + + /** + * Creates a new AlignFrame object. + * + * @param al DOCUMENT ME! + */ public AlignFrame(AlignmentI al) { - super(); - viewport = new AlignViewport(al,true,true,true,false); + viewport = new AlignViewport(al); + viewports.add(viewport); + + this.setDropTarget(new java.awt.dnd.DropTarget(this, this)); + + if(viewport.vconsensus==null) + { + //Out of memory calculating consensus. + BLOSUM62Colour.setEnabled(false); + PIDColour.setEnabled(false); + conservationMenuItem.setEnabled(false); + modifyConservation.setEnabled(false); + abovePIDThreshold.setEnabled(false); + modifyPID.setEnabled(false); + } + alignPanel = new AlignmentPanel(this, viewport); - getContentPane().add(alignPanel, java.awt.BorderLayout.CENTER); - fontNameMenuItem.setText(viewport.getFont().getName()); - fontSizeMenuItem.setText(viewport.getFont().getSize()+""); + alignPanels.add(alignPanel); + + String sortby = jalview.bin.Cache.getDefault("SORT_ALIGNMENT", "No sort"); + + if(sortby.equals("Id")) + sortIDMenuItem_actionPerformed(null); + else if(sortby.equals("Pairwise Identity")) + sortPairwiseMenuItem_actionPerformed(null); + + // remove(tabbedPane); + getContentPane().add(alignPanel, BorderLayout.CENTER); + + + + // tabbedPane.add(al.isNucleotide() ? "DNA":"Protein", alignPanel); + + ///Dataset tab + ///////////////////////// + if(al.getDataset()==null) + { + al.setDataset(null); + } + // AlignViewport ds = new AlignViewport(al.getDataset(), true); + // AlignmentPanel dap = new AlignmentPanel(this, ds); + // tabbedPane.add("Dataset", dap); + // viewports.add(ds); + // alignPanels.add(dap); + ///////////////////////// + + + viewport.addPropertyChangeListener(new PropertyChangeListener() + { + public void propertyChange(PropertyChangeEvent evt) + { + if (evt.getPropertyName().equals("alignment")) + { + alignmentChanged(); + } + } + }); + + + if (Desktop.desktop != null) + { + addServiceListeners(); + setGUINucleotide(al.isNucleotide()); + } + } + + /* Set up intrinsic listeners for dynamically generated GUI bits. */ + private void addServiceListeners() + { + final java.beans.PropertyChangeListener thisListener; + // Do this once to get current state + BuildWebServiceMenu(); + Desktop.discoverer.addPropertyChangeListener( + thisListener = new java.beans.PropertyChangeListener() + { + public void propertyChange(PropertyChangeEvent evt) + { + // System.out.println("Discoverer property change."); + if (evt.getPropertyName().equals("services")) + { + // System.out.println("Rebuilding web service menu"); + BuildWebServiceMenu(); + } + } + }); + addInternalFrameListener(new javax.swing.event. + InternalFrameAdapter() + { + public void internalFrameClosed( + javax.swing.event.InternalFrameEvent evt) + { + // System.out.println("deregistering discoverer listener"); + Desktop.discoverer.removePropertyChangeListener(thisListener); + closeMenuItem_actionPerformed(null); + } + ; + }); + + } + + public void setGUINucleotide(boolean nucleotide) + { + showTranslation.setVisible( nucleotide ); + sequenceFeatures.setVisible(!nucleotide ); + featureSettings.setVisible( !nucleotide ); + conservationMenuItem.setVisible( !nucleotide ); + modifyConservation.setVisible( !nucleotide ); + + //Deal with separators + //Remember AlignFrame always starts as protein + if(nucleotide) + { + viewMenu.remove(viewMenu.getItemCount()-2); + } + else + { + calculateMenu.remove(calculateMenu.getItemCount()-2); + } + } + + + /* + Added so Castor Mapping file can obtain Jalview Version + */ + public String getVersion() + { + return jalview.bin.Cache.getProperty("VERSION"); + } + + + public void fetchSequence_actionPerformed(ActionEvent e) + { + new SequenceFetcher(this); } - protected void saveAs_actionPerformed(ActionEvent e) + + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ + public void saveAlignmentMenu_actionPerformed(ActionEvent e) { - JFileChooser chooser = new JFileChooser(jalview.bin.Cache.LAST_DIRECTORY); - chooser.setDialogTitle("Save Alignment to file - "+e.getActionCommand() +" format."); + JalviewFileChooser chooser = new JalviewFileChooser(jalview.bin.Cache. + getProperty( + "LAST_DIRECTORY"), + new String[] + { + "fa, fasta, fastq", "aln", "pfam", "msf", "pir", "blc", + "jar" + }, + new String[] + { + "Fasta", "Clustal", "PFAM", "MSF", "PIR", "BLC", "Jalview" + }, currentFileFormat); + + chooser.setAcceptAllFileFilterUsed(false); + chooser.setFileView(new JalviewFileView()); + chooser.setDialogTitle("Save Alignment to file"); chooser.setToolTipText("Save"); + int value = chooser.showSaveDialog(this); - if(value == JFileChooser.APPROVE_OPTION) - { - String choice = chooser.getSelectedFile().getPath(); - jalview.bin.Cache.LAST_DIRECTORY = choice; - String output = FormatAdapter.get(e.getActionCommand(), viewport.getAlignment().getSequences()); - try{ - java.io.PrintWriter out = new java.io.PrintWriter( new java.io.FileWriter( choice ) ); - out.println(output); - out.close(); + + if (value == JalviewFileChooser.APPROVE_OPTION) + { + currentFileFormat = chooser.getSelectedFormat(); + + if (currentFileFormat == null) + { + JOptionPane.showInternalMessageDialog(Desktop.desktop, + "You must select a file format before saving!", + "File format not specified", + JOptionPane.WARNING_MESSAGE); + value = chooser.showSaveDialog(this); + return; + } + + jalview.bin.Cache.setProperty("DEFAULT_FILE_FORMAT", + currentFileFormat); + + String choice = chooser.getSelectedFile().getPath(); + jalview.bin.Cache.setProperty("LAST_DIRECTORY", choice); + + saveAlignment(choice, currentFileFormat); + } + } + + public boolean saveAlignment(String file, String format) + { + if (format.equalsIgnoreCase("Jalview")) + { + String shortName = title; + + if (shortName.indexOf(java.io.File.separatorChar) > -1) + { + shortName = shortName.substring(shortName.lastIndexOf( + java.io.File.separatorChar) + 1); } - catch(Exception ex){} + + Jalview2XML.SaveAlignment(this, file, shortName); + + // USE Jalview2XML to save this file + return true; } + else + { + String output = new FormatAdapter().formatSequences(format, + viewport.getAlignment(). + getSequences()); + if (output == null) + { + return false; + } + + try + { + java.io.PrintWriter out = new java.io.PrintWriter( + new java.io.FileWriter(file)); + out.print(output); + out.close(); + return true; + } + catch (Exception ex) + { + ex.printStackTrace(); + } + } + return false; } + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ protected void outputText_actionPerformed(ActionEvent e) { - CutAndPasteTransfer cap = new CutAndPasteTransfer(false); - JInternalFrame frame = new JInternalFrame(); - cap.formatForOutput(); - frame.setContentPane(cap); - Desktop.addInternalFrame(frame, "Alignment output - "+e.getActionCommand(), 600, 500); - cap.setText( FormatAdapter.get(e.getActionCommand(), viewport.getAlignment().getSequences())); + CutAndPasteTransfer cap = new CutAndPasteTransfer(); + Desktop.addInternalFrame(cap, + "Alignment output - " + e.getActionCommand(), 600, + 500); + cap.setText(new FormatAdapter().formatSequences(e.getActionCommand(), + viewport.getAlignment(). + getSequences())); } + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ protected void htmlMenuItem_actionPerformed(ActionEvent e) { - HTMLOutput htmlOutput = new HTMLOutput(viewport); - htmlOutput = null; + new HTMLOutput(viewport, + alignPanel.seqPanel.seqCanvas.getSequenceRenderer(), + alignPanel.seqPanel.seqCanvas.getFeatureRenderer()); + } + + public void createImageMap(File file, String image) + { + alignPanel.makePNGImageMap(file, image); + } + + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ + public void createPNG(File f) + { + alignPanel.makePNG(f); + } + + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ + public void createEPS(File f) + { + alignPanel.makeEPS(f); } + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ public void printMenuItem_actionPerformed(ActionEvent e) { //Putting in a thread avoids Swing painting problems @@ -84,661 +367,1501 @@ public class AlignFrame extends GAlignFrame thread.start(); } - class PrintThread extends Thread + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ + public void closeMenuItem_actionPerformed(ActionEvent e) { - public void run() + try { - PrinterJob printJob = PrinterJob.getPrinterJob(); - PageFormat pf = printJob.pageDialog(printJob.defaultPage()); - printJob.setPrintable(alignPanel, pf); - if (printJob.printDialog()) + PaintRefresher.components.remove(viewport.alignment); + this.setClosed(true); + } + catch (Exception ex) + { + } + } + + /** + * DOCUMENT ME! + */ + void updateEditMenuBar() + { + if (historyList.size() > 0) + { + undoMenuItem.setEnabled(true); + + HistoryItem hi = (HistoryItem) historyList.peek(); + undoMenuItem.setText("Undo " + hi.getDescription()); + } + else + { + undoMenuItem.setEnabled(false); + undoMenuItem.setText("Undo"); + } + + if (redoList.size() > 0) + { + redoMenuItem.setEnabled(true); + + HistoryItem hi = (HistoryItem) redoList.peek(); + redoMenuItem.setText("Redo " + hi.getDescription()); + } + else + { + redoMenuItem.setEnabled(false); + redoMenuItem.setText("Redo"); + } + } + + /** + * DOCUMENT ME! + * + * @param hi DOCUMENT ME! + */ + public void addHistoryItem(HistoryItem hi) + { + historyList.push(hi); + updateEditMenuBar(); + } + + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ + protected void undoMenuItem_actionPerformed(ActionEvent e) + { + HistoryItem hi = (HistoryItem) historyList.pop(); + redoList.push(new HistoryItem(hi.getDescription(), viewport.alignment, + HistoryItem.HIDE)); + restoreHistoryItem(hi); + viewport.firePropertyChange("alignment", null, viewport.getAlignment().getSequences()); + } + + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ + protected void redoMenuItem_actionPerformed(ActionEvent e) + { + HistoryItem hi = (HistoryItem) redoList.pop(); + restoreHistoryItem(hi); + updateEditMenuBar(); + viewport.firePropertyChange("alignment", null, viewport.getAlignment().getSequences()); + } + + // used by undo and redo + void restoreHistoryItem(HistoryItem hi) + { + if (hi.getType() == HistoryItem.SORT) + { + for (int i = 0; i < hi.getSequences().size(); i++) { - try + viewport.alignment.getSequences().setElementAt(hi.getSequences() + .elementAt(i), + i); + } + } + else + { + for (int i = 0; i < hi.getSequences().size(); i++) + { + SequenceI restore = (SequenceI) hi.getSequences().elementAt(i); + + if (restore.getLength() == 0) { - printJob.print(); + restore.setSequence(hi.getHidden().elementAt(i).toString()); + viewport.alignment.getSequences().insertElementAt(restore, + hi.getAlignIndex(i)); } - catch (Exception PrintException) + else { - PrintException.printStackTrace(); + restore.setSequence(hi.getHidden().elementAt(i).toString()); + } + } + + if (hi.getType() == HistoryItem.PASTE) + { + for (int i = viewport.alignment.getHeight() - 1; + i > (hi.getSequences().size() - 1); i--) + { + viewport.alignment.deleteSequence(i); } } } + updateEditMenuBar(); + + viewport.firePropertyChange("alignment", null, + viewport.getAlignment().getSequences()); } + /** + * 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.sequences.contains(seq)) + { + continue; + } + + SequenceI temp = viewport.alignment.getSequenceAt(i - 1); + + if (sg.sequences.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.sequences.contains(seq)) + { + continue; + } + + SequenceI temp = viewport.alignment.getSequenceAt(i + 1); + + if (sg.sequences.contains(temp)) + { + continue; + } + + viewport.alignment.getSequences().setElementAt(temp, i); + viewport.alignment.getSequences().setElementAt(seq, i + 1); + } + } + + alignPanel.repaint(); + } + + public void lostOwnership(Clipboard clipboard, Transferable contents) + { + Desktop.jalviewClipboard = null; + } + + + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ + protected void copy_actionPerformed(ActionEvent e) + { + if (viewport.getSelectionGroup() == null) + { + return; + } + + SequenceGroup sg = viewport.getSelectionGroup(); + + Clipboard c = Toolkit.getDefaultToolkit().getSystemClipboard(); + + Hashtable orderedSeqs = new Hashtable(); + SequenceI[] seqs = new SequenceI[sg.getSize()]; + + for (int i = 0; i < sg.getSize(); i++) + { + SequenceI seq = sg.getSequenceAt(i); + int index = viewport.alignment.findIndex(seq); + orderedSeqs.put(index + "", seq); + } + + int index = 0, startRes, endRes; + char ch; + + for (int i = 0; i < sg.getSize(); i++) + { + SequenceI seq = null; + + while (seq == null) + { + if (orderedSeqs.containsKey(index + "")) + { + seq = (SequenceI) 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; + } + + seqs[i] = new Sequence(seq.getName(), + seq.getSequence(sg.getStartRes(), sg.getEndRes() + 1), + startRes, + endRes); + seqs[i].setDescription(seq.getDescription()); + seqs[i].setDBRef(seq.getDBRef()); + seqs[i].setSequenceFeatures(seq.getSequenceFeatures()); + seqs[i].setDatasetSequence(seq.getDatasetSequence()); + + } + + FastaFile ff = new FastaFile(); + ff.addJVSuffix( viewport.showJVSuffix ); + c.setContents(new StringSelection( ff.print(seqs)), this); + Desktop.jalviewClipboard = new Object[]{seqs, viewport.alignment.getDataset()}; + } + + /** + * 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) + { + addHistoryItem(new HistoryItem("Paste Sequences", viewport.alignment, + HistoryItem.PASTE)); + 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 = (String) contents.getTransferData(DataFlavor.stringFlavor); + if(str.length()<1) + return; + + String format = IdentifyFile.Identify(str, "Paste"); + 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); + } + + if (newAlignment) + { + + Alignment alignment = new Alignment(sequences); + + if(Desktop.jalviewClipboard!=null) + alignment.setDataset( (Alignment)Desktop.jalviewClipboard[1] ); + else + alignment.setDataset( null ); + + + AlignFrame af = new AlignFrame(alignment); + String newtitle = new String("Copied sequences"); + + if (title.startsWith("Copied sequences")) + { + newtitle = title; + } + else + { + newtitle = newtitle.concat("- from " + title); + } + + Desktop.addInternalFrame(af, newtitle, NEW_WINDOW_WIDTH, + NEW_WINDOW_HEIGHT); + } + else + { + //!newAlignment + for (int i = 0; i < sequences.length; i++) + { + Sequence newseq = new Sequence(sequences[i].getName(), + sequences[i].getSequence(), sequences[i].getStart(), + sequences[i].getEnd()); + viewport.alignment.addSequence(newseq); + if(sequences[i].getDatasetSequence()==null) + { + //////////////////////////// + //Datset needs extension; + ///////////////////////////// + Sequence ds = new Sequence(sequences[i].getName(), + AlignSeq.extractGaps("-. ", sequences[i].getSequence()), + sequences[i].getStart(), + sequences[i].getEnd()); + newseq.setDatasetSequence(ds); + viewport.alignment.getDataset().addSequence(ds); + } + else + newseq.setDatasetSequence(sequences[i].getDatasetSequence()); + + } + viewport.setEndSeq(viewport.alignment.getHeight()); + viewport.alignment.getWidth(); + viewport.firePropertyChange("alignment", null, viewport.getAlignment().getSequences()); + } + } + catch (Exception ex) + { + // could be anything being pasted in here + } + } - public void closeMenuItem_actionPerformed(ActionEvent e) + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ + protected void cut_actionPerformed(ActionEvent e) { - try{ - this.setClosed(true); - }catch(Exception ex){} + copy_actionPerformed(null); + delete_actionPerformed(null); } - ArrayList historyList = new ArrayList(); - ArrayList redoList = new ArrayList(); - - void updateEditMenuBar() + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ + protected void delete_actionPerformed(ActionEvent e) { - if(historyList.size()>0) - { - undoMenuItem.setEnabled(true); - Object [] history = (Object[])historyList.get(0); - undoMenuItem.setText("Undo "+history[0]); - } - else + + if (viewport.getSelectionGroup() == null) { - undoMenuItem.setEnabled(false); - undoMenuItem.setText("Undo"); + return; } - if(redoList.size()>0) - { - redoMenuItem.setEnabled(true); - Object [] history = (Object[])redoList.get(0); - redoMenuItem.setText("Redo "+history[0]); - } - else + addHistoryItem(new HistoryItem("Delete Sequences", viewport.alignment, + HistoryItem.HIDE)); + + SequenceGroup sg = viewport.getSelectionGroup(); + boolean allSequences = false; + if (sg.sequences.size() == viewport.alignment.getHeight()) { - redoMenuItem.setEnabled(false); - redoMenuItem.setText("Redo"); + allSequences = true; } - } - public void addHistoryItem(String type) - { - // must make sure we add new sequence objects her, not refs to the existing sequences - redoList.clear(); - SequenceI[] seq = new SequenceI[viewport.getAlignment().getHeight()]; - for(int i=0; i 0) { + addHistoryItem(new HistoryItem("Remove Left", viewport.alignment, + HistoryItem.HIDE)); + int min = colSel.getMin(); viewport.getAlignment().trimLeft(min); - colSel.compensateForEdit(0,min); - alignPanel.RefreshPanels(); + colSel.compensateForEdit(0, min); + + if (viewport.getSelectionGroup() != null) + { + viewport.getSelectionGroup().adjustForRemoveLeft(min); + } + + Vector groups = viewport.alignment.getGroups(); + + for (int i = 0; i < groups.size(); i++) + { + SequenceGroup sg = (SequenceGroup) groups.get(i); + + if (!sg.adjustForRemoveLeft(min)) + { + viewport.alignment.deleteGroup(sg); + } + } + + viewport.firePropertyChange("alignment", null, viewport.getAlignment().getSequences()); } } + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ public void remove2RightMenuItem_actionPerformed(ActionEvent e) { - addHistoryItem("delete columns"); ColumnSelection colSel = viewport.getColumnSelection(); + if (colSel.size() > 0) { + addHistoryItem(new HistoryItem("Remove Right", viewport.alignment, + HistoryItem.HIDE)); + int max = colSel.getMax(); - if(max>1) - viewport.getAlignment().trimRight(max); + viewport.getAlignment().trimRight(max); - alignPanel.RefreshPanels(); - } + if (viewport.getSelectionGroup() != null) + { + viewport.getSelectionGroup().adjustForRemoveRight(max); + } + + Vector groups = viewport.alignment.getGroups(); + + for (int i = 0; i < groups.size(); i++) + { + SequenceGroup sg = (SequenceGroup) groups.get(i); + + if (!sg.adjustForRemoveRight(max)) + { + viewport.alignment.deleteGroup(sg); + } + } + viewport.firePropertyChange("alignment", null, viewport.getAlignment().getSequences()); + } } + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ public void removeGappedColumnMenuItem_actionPerformed(ActionEvent e) { - addHistoryItem("delete gapped columns"); + addHistoryItem(new HistoryItem("Remove Gapped Columns", + viewport.alignment, HistoryItem.HIDE)); + + //This is to maintain viewport position on first residue + //of first sequence + SequenceI seq = viewport.alignment.getSequenceAt(0); + int startRes = seq.findPosition(viewport.startRes); + viewport.getAlignment().removeGaps(); - alignPanel.RefreshPanels(); + + 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) { - addHistoryItem("delete all gaps"); + addHistoryItem(new HistoryItem("Remove Gaps", viewport.alignment, + HistoryItem.HIDE)); + + //This is to maintain viewport position on first residue + //of first sequence + SequenceI seq = viewport.alignment.getSequenceAt(0); + int startRes = seq.findPosition(viewport.startRes); + + SequenceI current; int jSize; - for (int i=0; i < viewport.getAlignment().getSequences().size();i++) + + Vector seqs = null; + + int start = 0; + int end = viewport.alignment.getWidth(); + + if (viewport.getSelectionGroup() != null + && viewport.getSelectionGroup().sequences != null + && viewport.getSelectionGroup().sequences.size() > 0) + { + seqs = viewport.getSelectionGroup().sequences; + start = viewport.getSelectionGroup().getStartRes(); + end = viewport.getSelectionGroup().getEndRes()+1; + } + else + { + seqs = viewport.alignment.getSequences(); + } + + for (int i = 0; i < seqs.size(); i++) { - current = viewport.getAlignment().getSequenceAt(i); + current = (SequenceI) seqs.elementAt(i); jSize = current.getLength(); - for (int j=0; j < jSize; j++) - if(jalview.util.Comparison.isGap(current.getCharAt(j))) + + // Removing a range is much quicker than removing gaps + // one by one for long sequences + int j = start; + int rangeStart=-1, rangeEnd=-1; + + do + { + if (jalview.util.Comparison.isGap(current.getCharAt(j))) + { + if(rangeStart==-1) + { + rangeStart = j; + rangeEnd = j+1; + } + else + { + rangeEnd++; + } + j++; + } + else { - current.deleteCharAt(j); - j--; - jSize--; + if(rangeStart>-1) + { + current.deleteChars(rangeStart, rangeEnd); + j-=rangeEnd-rangeStart; + jSize-=rangeEnd-rangeStart; + rangeStart = -1; + rangeEnd = -1; + } + else + j++; } + } + while (j < end && j < jSize); + if(rangeStart>-1) + { + current.deleteChars(rangeStart, rangeEnd); + } } - alignPanel.RefreshPanels(); + viewport.setStartRes(seq.findIndex(startRes)-1); + + viewport.firePropertyChange("alignment", null, viewport.getAlignment().getSequences()); } - public void setGapCharMenuItem_actionPerformed(ActionEvent e) + public void alignmentChanged() + { + if(viewport.vconsensus!=null) + { + viewport.updateConsensus(); + viewport.updateConservation(); + } + resetAllColourSchemes(); + if(alignPanel.overviewPanel!=null) + alignPanel.overviewPanel.updateOverviewImage(); + + alignPanel.repaint(); + } + + void resetAllColourSchemes() { - char thisChar = '-'; - char nextChar = '.'; - if(viewport.getGapCharacter()=='-') + ColourSchemeI cs = viewport.globalColourScheme; + if(cs!=null) + { + if (cs instanceof ClustalxColourScheme) + { + ( (ClustalxColourScheme) viewport.getGlobalColourScheme()). + resetClustalX(viewport.alignment.getSequences(), + viewport.alignment.getWidth()); + } + + cs.setConsensus(viewport.vconsensus); + if (cs.conservationApplied()) + { + Alignment al = (Alignment) viewport.alignment; + Conservation c = new Conservation("All", + ResidueProperties.propHash, 3, + al.getSequences(), 0, + al.getWidth() - 1); + c.calculate(); + c.verdict(false, viewport.ConsPercGaps); + + cs.setConservation(c); + } + } + + int s, sSize = viewport.alignment.getGroups().size(); + for(s=0; s 50) - threshold = 30; - sp = new SliderPanel(alignPanel, threshold, true,ccs); - Desktop.addInternalFrame(sliderFrame, "Conservation Colour Increment (Global colour)", 400, 90); - threshold = 0; - } - else if (abovePIDThreshold.isSelected()) - { - sp = new SliderPanel(alignPanel, threshold, false, oldCs); - sp.cs = oldCs; - Desktop.addInternalFrame(sliderFrame, "Percentage Identity Threshold (Global colour)", 400, 90); - } + if (viewport.getColourAppliesToAllGroups()) + { + Vector groups = viewport.alignment.getGroups(); - sliderFrame.setContentPane(sp); - if(x!=0 && y!=0) - sliderFrame.setLocation(x,y); + for (int i = 0; i < groups.size(); i++) + { + SequenceGroup sg = (SequenceGroup) groups.elementAt(i); - } - else - threshold = 0; + if (cs == null) + { + sg.cs = null; + continue; + } + + if (cs instanceof ClustalxColourScheme) + { + sg.cs = new ClustalxColourScheme(sg.sequences, sg.getWidth()); + } + else if (cs instanceof UserColourScheme) + { + sg.cs = new UserColourScheme( ( (UserColourScheme) cs).getColours()); + } + else + { + try + { + sg.cs = (ColourSchemeI) cs.getClass().newInstance(); + } + catch (Exception ex) + { + } + } + if (viewport.getAbovePIDThreshold() + || cs instanceof PIDColourScheme + || cs instanceof Blosum62ColourScheme) + { + sg.cs.setThreshold(threshold, + viewport.getIgnoreGapsConsensus()); - if (oldCs instanceof ResidueColourScheme) - { - ResidueColourScheme rcs = (ResidueColourScheme) oldCs; - rcs.setThreshold(threshold); - } - else if (oldCs instanceof ScoreColourScheme) - { - ScoreColourScheme scs = (ScoreColourScheme) oldCs; - scs.setThreshold(threshold); - } + sg.cs.setConsensus(AAFrequency.calculate(sg.sequences, 0, + sg.getWidth())); + } + else + sg.cs.setThreshold(0, viewport.getIgnoreGapsConsensus()); + + + if (viewport.getConservationSelected()) + { + Conservation c = new Conservation("Group", + ResidueProperties.propHash, 3, + sg.sequences, 0, + viewport.alignment.getWidth() - 1); + c.calculate(); + c.verdict(false, viewport.ConsPercGaps); + sg.cs.setConservation(c); + } + else + sg.cs.setConservation(null); + } + } + + if (alignPanel.getOverviewPanel() != null) + { + alignPanel.getOverviewPanel().updateOverviewImage(); + } + + alignPanel.repaint(); + } + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ + protected void modifyPID_actionPerformed(ActionEvent e) + { + if (viewport.getAbovePIDThreshold() && viewport.globalColourScheme!=null) + { + SliderPanel.setPIDSliderSource(alignPanel, + viewport.getGlobalColourScheme(), + "Background"); + SliderPanel.showPIDSlider(); + } + } + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ + protected void modifyConservation_actionPerformed(ActionEvent e) + { + if (viewport.getConservationSelected() && viewport.globalColourScheme!=null) + { + SliderPanel.setConservationSlider(alignPanel, + viewport.globalColourScheme, + "Background"); + SliderPanel.showConservationSlider(); + } } - protected void conservationMenuItem_actionPerformed(ActionEvent e) + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ + protected void conservationMenuItem_actionPerformed(ActionEvent e) { - if(abovePIDThreshold.isSelected()) + viewport.setConservationSelected(conservationMenuItem.isSelected()); + + viewport.setAbovePIDThreshold(false); abovePIDThreshold.setSelected(false); - viewport.setConservationSelected(conservationMenuItem.isSelected()); + changeColour(viewport.getGlobalColourScheme()); - addConservationOrPIDColour(); + modifyConservation_actionPerformed(null); } - JInternalFrame sliderFrame; + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ public void abovePIDThreshold_actionPerformed(ActionEvent e) { - if(conservationMenuItem.isSelected()) - conservationMenuItem.setSelected(false); + viewport.setAbovePIDThreshold(abovePIDThreshold.isSelected()); + + conservationMenuItem.setSelected(false); + viewport.setConservationSelected(false); + + changeColour(viewport.getGlobalColourScheme()); + + modifyPID_actionPerformed(null); + } + + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ + 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()); - addConservationOrPIDColour(); + 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() + { + 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() + { + public void actionPerformed(ActionEvent evt) + { + userDefinedColour_actionPerformed(evt); + } + }); + } + } + }); + radioItem.addActionListener(new ActionListener() + { + public void actionPerformed(ActionEvent evt) + { + userDefinedColour_actionPerformed(evt); + } + }); - public void userDefinedColour_actionPerformed(ActionEvent e) - { - JInternalFrame frame = new JInternalFrame(); - UserDefinedColours chooser = new UserDefinedColours( frame, alignPanel, null); - frame.setContentPane(chooser); - Desktop.addInternalFrame(frame,"User defined colours", 450,540 ); - frame.setResizable(false); - frame.setIconifiable(false); - frame.setMaximizable(false); + colourMenu.insert(radioItem, 15); + colours.add(radioItem); + } + } } + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ public void PIDColour_actionPerformed(ActionEvent e) { - viewport.setGlobalColourScheme( new PIDColourScheme() ); - alignPanel.setColourScheme( ); + changeColour(new PIDColourScheme()); } - + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ public void BLOSUM62Colour_actionPerformed(ActionEvent e) { - viewport.setGlobalColourScheme( new Blosum62ColourScheme(viewport) ); - alignPanel.setColourScheme(); - } - - - - protected void schemeKeyMenuItem_actionPerformed(ActionEvent e) - { - ColourKey colourKey = new ColourKey( viewport.getGlobalColourScheme() ); - Desktop.addInternalFrame(colourKey, "Colour scheme key", 400, 320); + changeColour(new Blosum62ColourScheme()); } - + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ public void sortPairwiseMenuItem_actionPerformed(ActionEvent e) { - addHistoryItem("sort"); - AlignmentSorter.sortByPID(viewport.getAlignment(), viewport.getAlignment().getSequenceAt(0)); - alignPanel.RefreshPanels(); + addHistoryItem(new HistoryItem("Pairwise Sort", viewport.alignment, + HistoryItem.SORT)); + AlignmentSorter.sortByPID(viewport.getAlignment(), + viewport.getAlignment().getSequenceAt(0)); + alignPanel.repaint(); } + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ public void sortIDMenuItem_actionPerformed(ActionEvent e) { - addHistoryItem("sort"); - AlignmentSorter.sortByID( viewport.getAlignment() ); - alignPanel.RefreshPanels(); + addHistoryItem(new HistoryItem("ID Sort", viewport.alignment, + HistoryItem.SORT)); + AlignmentSorter.sortByID(viewport.getAlignment()); + alignPanel.repaint(); } + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ public void sortGroupMenuItem_actionPerformed(ActionEvent e) { - addHistoryItem("sort"); - AlignmentSorter.sortByGroup(viewport.getAlignment()); - AlignmentSorter.sortGroups(viewport.getAlignment()); - alignPanel.RefreshPanels(); - } - - public void sortTreeOrderMenuItem_actionPerformed(ActionEvent e) - { - addHistoryItem("sort"); - if(viewport.getCurrentTree()==null) - return; + addHistoryItem(new HistoryItem("Group Sort", viewport.alignment, + HistoryItem.SORT)); - AlignmentSorter.sortByTree(viewport.getAlignment(), viewport.getCurrentTree()); - alignPanel.RefreshPanels(); + AlignmentSorter.sortByGroup(viewport.getAlignment()); + alignPanel.repaint(); } + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ public void removeRedundancyMenuItem_actionPerformed(ActionEvent e) { - RedundancyPanel sp = new RedundancyPanel(alignPanel); + RedundancyPanel sp = new RedundancyPanel(alignPanel, this); JInternalFrame frame = new JInternalFrame(); frame.setContentPane(sp); - Desktop.addInternalFrame(frame, "Redundancy threshold selection", 400, 100); - frame.setMaximizable(false); - frame.setResizable(false); - + Desktop.addInternalFrame(frame, "Redundancy threshold selection", 400, + 100, false); } + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ public void pairwiseAlignmentMenuItem_actionPerformed(ActionEvent e) { - if(viewport.getSelection().size()<2) - JOptionPane.showInternalMessageDialog(this, "You must select at least 2 sequences.", "Invalid Selection", JOptionPane.WARNING_MESSAGE); + 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(); @@ -747,223 +1870,762 @@ public class AlignFrame extends GAlignFrame } } + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ public void PCAMenuItem_actionPerformed(ActionEvent e) { - if( (viewport.getSelection().size()<4 && viewport.getSelection().size()>0) - || viewport.getAlignment().getHeight()<4) + 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); + JOptionPane.showInternalMessageDialog(this, + "Principal component analysis must take\n" + + "at least 4 input sequences.", + "Sequence selection insufficient", + JOptionPane.WARNING_MESSAGE); + return; } - try{ - PCAPanel pcaPanel = new PCAPanel(viewport, null); - JInternalFrame frame = new JInternalFrame(); - frame.setContentPane(pcaPanel); - Desktop.addInternalFrame(frame, "Principal component analysis", 400, 400); - }catch(java.lang.OutOfMemoryError ex) - { - JOptionPane.showInternalMessageDialog(this, "Too many sequences selected\nfor Principal Component Analysis!!", - "Out of memory", JOptionPane.WARNING_MESSAGE); - } - - + new PCAPanel(viewport); } + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ public void averageDistanceTreeMenuItem_actionPerformed(ActionEvent e) { NewTreePanel("AV", "PID", "Average distance tree using PID"); } + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ public void neighbourTreeMenuItem_actionPerformed(ActionEvent e) { NewTreePanel("NJ", "PID", "Neighbour joining tree using PID"); } - + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ protected void njTreeBlosumMenuItem_actionPerformed(ActionEvent e) { NewTreePanel("NJ", "BL", "Neighbour joining tree using BLOSUM62"); } + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ protected void avTreeBlosumMenuItem_actionPerformed(ActionEvent e) { - NewTreePanel("AV", "BL", "Average distance tree using BLOSUM62PID"); + 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) { - JInternalFrame frame = new javax.swing.JInternalFrame(); - TreePanel tp=null; - if (viewport.getSelection() != null && viewport.getSelection().size() > 3) - { - tp = new TreePanel(viewport, viewport.getSelection().asVector(),type, pwType, - viewport.getStartRes(), viewport.getEndRes()); - } - else - { - tp = new TreePanel(viewport, viewport.getAlignment().getSequences(), - type, pwType, viewport.getStartRes(), - viewport.getEndRes()); - } + final TreePanel tp; - frame.setContentPane(tp); - Desktop.addInternalFrame(frame, title, 600, 500); - } + if ( (viewport.getSelectionGroup() != null) && + (viewport.getSelectionGroup().getSize() > 3)) + { + int s = 0; + SequenceGroup sg = viewport.getSelectionGroup(); + + /* Decide if the selection is a column region */ + while (s < sg.sequences.size()) + { + if ( ( (SequenceI) sg.sequences.elementAt(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(viewport, + viewport.getSelectionGroup().sequences, type, pwType, + sg.getStartRes(), sg.getEndRes()); + } + else + { + //are the sequences aligned? + if (!viewport.alignment.isAligned()) + { + 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; + } + tp = new TreePanel(viewport, + viewport.getAlignment().getSequences(), type, pwType, + 0, + viewport.alignment.getWidth()); + } + addTreeMenuItem(tp, title); + viewport.setCurrentTree(tp.getTree()); + Desktop.addInternalFrame(tp, title + " from " + this.title, 600, 500); + } - public void clustalAlignMenuItem_actionPerformed(ActionEvent e) + /** + * DOCUMENT ME! + * + * @param title DOCUMENT ME! + * @param order DOCUMENT ME! + */ + public void addSortByOrderMenuItem(String title, final AlignmentOrder order) { - JInternalFrame frame = new JInternalFrame(); - ClustalThread ct = new ClustalThread(frame); - Thread t = new Thread(ct); - t.start(); - frame.setContentPane(ct); - Desktop.addInternalFrame(frame, title, 300, 80); + final JMenuItem item = new JMenuItem("by " + title); + sort.add(item); + item.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + addHistoryItem(new HistoryItem("Sort", viewport.alignment, + HistoryItem.SORT)); + + // TODO: JBPNote - have to map order entries to curent SequenceI pointers + AlignmentSorter.sortBy(viewport.getAlignment(), order); + alignPanel.repaint(); + } + }); + } + + /** + * Maintain the Order by->Displayed Tree menu. + * Creates a new menu item for a TreePanel with an appropriate + * jalview.analysis.AlignmentSorter 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. + */ + void addTreeMenuItem(final TreePanel treePanel, String title) + { + final JMenuItem item = new JMenuItem(title); + treeCount++; + + if (treeCount == 1) + { + sort.add(sortByTreeMenu); + } + + sortByTreeMenu.add(item); + item.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + addHistoryItem(new HistoryItem("Tree Sort", + viewport.alignment, HistoryItem.SORT)); + AlignmentSorter.sortByTree(viewport.getAlignment(), + treePanel.getTree()); + alignPanel.repaint(); + } + }); + + treePanel.addInternalFrameListener(new javax.swing.event. + InternalFrameAdapter() + { + public void internalFrameClosed( + javax.swing.event.InternalFrameEvent evt) + { + treeCount--; + sortByTreeMenu.remove(item); + + if (treeCount == 0) + { + sort.remove(sortByTreeMenu); + } + } + ; + }); } - class ClustalThread extends JPanel implements Runnable + /** + * Work out whether the whole set of sequences + * or just the selected set will be submitted for multiple alignment. + * + */ + private SequenceI[] gatherSequencesForAlignment() { - Image [] image; - int imageIndex = 0; - boolean webServiceRunning = false; - JInternalFrame frame; - public ClustalThread(JInternalFrame frame) + // Now, check we have enough sequences + SequenceI[] 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()]; + + for (int i = 0; i < sz; i++) + { + msa[i] = (SequenceI) seqs.getSequenceAt(i); + } + } + else { - this.frame = frame; - image = new Image[9]; - for(int i=0; i<9; i++) + Vector seqs = viewport.getAlignment().getSequences(); + + if (seqs.size() > 1) { - java.net.URL url = getClass().getResource("/dna" + (i+1) + ".gif"); - if (url != null) + msa = new SequenceI[seqs.size()]; + + for (int i = 0; i < seqs.size(); i++) { - image[i] = java.awt.Toolkit.getDefaultToolkit().createImage(url); - MediaTracker mt = new MediaTracker(this); - mt.addImage(image[i], i); - try{mt.waitForID(i);} - catch(Exception ex){} + msa[i] = (SequenceI) seqs.elementAt(i); } } - DNATwirler twirler = new DNATwirler(); - twirler.start(); - webServiceRunning = true; } + return msa; + } + + /** + * Decides what is submitted to a secondary structure prediction service, + * the currently selected sequence, or the currently selected alignment + * (where the first sequence in the set is the one that the prediction + * will be for). + */ + SequenceI[] gatherSeqOrMsaForSecStrPrediction() + { + SequenceI seq = null; + SequenceI[] msa = null; + + if ( (viewport.getSelectionGroup() != null) && + (viewport.getSelectionGroup().getSize() > 0)) + { + // JBPNote UGLY! To prettify, make SequenceGroup and Alignment conform to some common interface! + SequenceGroup seqs = viewport.getSelectionGroup(); + + if ( (seqs.getSize() == 1) || !viewport.alignment.isAligned()) + { + seq = (SequenceI) seqs.getSequenceAt(0); + } + else + { + int sz; + msa = new SequenceI[sz = seqs.getSize()]; - class DNATwirler extends Thread + for (int i = 0; i < sz; i++) + { + msa[i] = (SequenceI) seqs.getSequenceAt(i); + } + } + } + else { - public void run() + Vector seqs = viewport.getAlignment().getSequences(); + + if ( (seqs.size() == 1) || !viewport.alignment.isAligned()) + { + seq = (SequenceI) seqs.elementAt(0); + } + else { - while(webServiceRunning) + msa = new SequenceI[seqs.size()]; + + for (int i = 0; i < seqs.size(); i++) { - try{ - Thread.sleep(100); - imageIndex++; - imageIndex %=9; - repaint(); - } - catch(Exception ex){} + msa[i] = (SequenceI) seqs.elementAt(i); } } } + if (msa != null) + { + return msa; + } + else + { + if (seq != null) + { + return new SequenceI[] + { + seq}; + } + } + return null; + } + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ + 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); + + try + { + jalview.io.NewickFile fin = new jalview.io.NewickFile(choice, + "File"); + viewport.setCurrentTree(ShowNewickTree(fin, choice).getTree()); + } + catch (Exception ex) + { + JOptionPane.showMessageDialog(Desktop.desktop, + "Problem reading tree file", + ex.getMessage(), + JOptionPane.WARNING_MESSAGE); + ex.printStackTrace(); + } + } + } + + + public TreePanel ShowNewickTree(NewickFile nf, String title) + { + return ShowNewickTree(nf,title,600,500,4,5); + } + /** + * DOCUMENT ME! + * + * @param nf DOCUMENT ME! + * @param title DOCUMENT ME! + * + * @return DOCUMENT ME! + */ + public TreePanel ShowNewickTree(NewickFile nf, String title, int w,int h,int x, int y) + { + TreePanel tp = null; + + try + { + nf.parse(); + + if (nf.getTree() != null) + { + tp = new TreePanel(viewport, + viewport.getAlignment().getSequences(), nf, + "FromFile", + title); + + tp.setSize(w,h); + + if(x>0 && y>0) + tp.setLocation(x,y); + + + Desktop.addInternalFrame(tp, title, w, h); + addTreeMenuItem(tp, title); + } + } + catch (Exception ex) + { + ex.printStackTrace(); + } + + return tp; + } - // JBPNote - // Should check to see if the server settings are valid - // Need visual-delay indication here. + class PrintThread + extends Thread + { public void run() - { - jalview.ws.Jemboss jemboss = new jalview.ws.Jemboss(); - Vector sv = viewport.getAlignment().getSequences(); - SequenceI[] seqs = new SequenceI[sv.size()]; - - int i = 0; - do - { - seqs[i] = (SequenceI) sv.elementAt(i); - } - while (++i < sv.size()); - - SequenceI[] alignment = jemboss.clustalW(seqs); // gaps removed within method - - if (alignment != null) - { - AlignFrame af = new AlignFrame(new Alignment(alignment)); - Desktop.addInternalFrame(af, getTitle().concat(" - ClustalW Alignment"), - 700, 500); // JBPNote - is there a new window geom. property ? - } - else - JOptionPane.showMessageDialog(Desktop.desktop, "Problem obtaining clustal alignment", "Web service error", - JOptionPane.WARNING_MESSAGE); - - webServiceRunning = false; - try{ - frame.setClosed(true); - }catch(Exception ex){} - } + { + PrinterJob printJob = PrinterJob.getPrinterJob(); + PageFormat pf = printJob.pageDialog(printJob.defaultPage()); + printJob.setPrintable(alignPanel, pf); - public void paintComponent(Graphics g) - { - g.setColor(Color.white); - g.fillRect(0,0,getWidth(), getHeight()); - if(image!=null) - { - g.drawImage(image[imageIndex],10,10,this); - } - g.setFont(new Font("Arial", Font.BOLD, 12)); - g.setColor(Color.black); - g.drawString("Clustal Alignment Web Service running", 30,30); - } + if (printJob.printDialog()) + { + try + { + printJob.print(); + } + catch (Exception PrintException) + { + PrintException.printStackTrace(); + } + } + } + } + /** + * Generates menu items and listener event actions for web service clients + * + */ + public void BuildWebServiceMenu() + { + if ( (Discoverer.services != null) + && (Discoverer.services.size() > 0)) + { + Vector msaws = (Vector) Discoverer.services.get("MsaWS"); + Vector secstrpr = (Vector) Discoverer.services.get("SecStrPred"); + Vector wsmenu = new Vector(); + if (msaws != null) + { + // Add any Multiple Sequence Alignment Services + final JMenu msawsmenu = new JMenu("Alignment"); + for (int i = 0, j = msaws.size(); i < j; i++) + { + final ext.vamsas.ServiceHandle sh = (ext.vamsas.ServiceHandle) msaws. + get(i); + final JMenuItem method = new JMenuItem(sh.getName()); + method.addActionListener(new ActionListener() + { + public void actionPerformed(ActionEvent e) + { + SequenceI[] msa = gatherSequencesForAlignment(); + new jalview.ws.MsaWSClient(sh, title, msa, + false, true, viewport.getAlignment().getDataset()); + + } + + }); + msawsmenu.add(method); + // Deal with services that we know accept partial alignments. + if (sh.getName().indexOf("lustal") > -1) + { + // We know that ClustalWS can accept partial alignments for refinement. + final JMenuItem methodR = new JMenuItem(sh.getName()+" Realign"); + methodR.addActionListener(new ActionListener() + { + public void actionPerformed(ActionEvent e) + { + SequenceI[] msa = gatherSequencesForAlignment(); + new jalview.ws.MsaWSClient(sh, title, msa, + true, true, viewport.getAlignment().getDataset()); + + } + + }); + msawsmenu.add(methodR); + } + } + wsmenu.add(msawsmenu); + } + if (secstrpr != null) + { + // Add any secondary structure prediction services + final JMenu secstrmenu = new JMenu("Secondary Structure Prediction"); + for (int i = 0, j = secstrpr.size(); i < j; i++) + { + final ext.vamsas.ServiceHandle sh = (ext.vamsas.ServiceHandle) + secstrpr.get(i); + final JMenuItem method = new JMenuItem(sh.getName()); + method.addActionListener(new ActionListener() + { + public void actionPerformed(ActionEvent e) + { + SequenceI[] msa = gatherSeqOrMsaForSecStrPrediction(); + if (msa.length == 1) + { + // Single Sequence prediction + new jalview.ws.JPredClient(sh,title, msa[0]); + } + else + { + if (msa.length > 1) + { + // Single Sequence prediction + jalview.ws.JPredClient ct = new jalview.ws.JPredClient(sh, + title, msa); + } + } + } + }); + secstrmenu.add(method); + } + wsmenu.add(secstrmenu); + } + this.webService.removeAll(); + for (int i = 0, j = wsmenu.size(); i < j; i++) + { + webService.add( (JMenu) wsmenu.get(i)); + } + } + else + { + this.webService.removeAll(); + this.webService.add(this.webServiceNoServices); + } + // TODO: add in rediscovery function + // TODO: reduce code redundancy. + // TODO: group services by location as well as function. } + /* public void vamsasStore_actionPerformed(ActionEvent e) + { + JalviewFileChooser chooser = new JalviewFileChooser(jalview.bin.Cache. + getProperty("LAST_DIRECTORY")); + + chooser.setFileView(new JalviewFileView()); + chooser.setDialogTitle("Export to Vamsas file"); + chooser.setToolTipText("Export"); + + int value = chooser.showSaveDialog(this); + + if (value == JalviewFileChooser.APPROVE_OPTION) + { + jalview.io.VamsasDatastore vs = new jalview.io.VamsasDatastore(viewport); + //vs.store(chooser.getSelectedFile().getAbsolutePath() ); + vs.storeJalview( chooser.getSelectedFile().getAbsolutePath(), this); + } + }*/ - public void pdbTest_actionPerformed(ActionEvent e) + public void featureSettings_actionPerformed(ActionEvent e) { - String reply = - JOptionPane.showInternalInputDialog(this, "Enter pdb code", - "PDB test viewer", JOptionPane.QUESTION_MESSAGE); + new FeatureSettings(viewport, alignPanel); + } - String url = "http://www.ebi.ac.uk/cgi-bin/pdbfetch?id=1a4u"; - if (reply.length()>1) - url = "http://www.ebi.ac.uk/cgi-bin/pdbfetch?id="+reply; - try - { - PDBfile pdb = new PDBfile(url, - "URL"); - Sequence seq = (Sequence)viewport.getAlignment().getSequenceAt(0); - seq.setPDBfile(pdb); - ( (PDBChain) pdb.chains.elementAt(seq.maxchain)).isVisible = true; - ( (PDBChain) pdb.chains.elementAt(seq.maxchain)).sequence = seq; - // ( (PDBChain) pdb.chains.elementAt(seq.maxchain)).colourBySequence(); - - rotCanvas rc = new rotCanvas(pdb); - JInternalFrame frame = new JInternalFrame(); - frame.setContentPane(rc); - Desktop.addInternalFrame(frame, url, 400,400); - } - catch (Exception ex) - { - ex.printStackTrace(); - } +public void showTranslation_actionPerformed(ActionEvent e) +{ + int s, sSize = viewport.alignment.getHeight(); + SequenceI [] newSeq = new SequenceI[sSize]; + + int res, resSize; + StringBuffer protein; + String seq; + for(s=0; s