X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fgui%2FAlignFrame.java;h=f82efb5b9b25bade7cbc11287ced0586f4c9c0d2;hb=0b23947e2cdcd704d3f313b23ba271e43d097344;hp=725ffe94081041637d2c501bb2769bd2a8eea304;hpb=79e0822af333c1c0597d53b0aa679846a590beb3;p=jalview.git diff --git a/src/jalview/gui/AlignFrame.java b/src/jalview/gui/AlignFrame.java index 725ffe9..f82efb5 100755 --- a/src/jalview/gui/AlignFrame.java +++ b/src/jalview/gui/AlignFrame.java @@ -1,16 +1,25 @@ -/******************** - * 2004 Jalview Reengineered - * Barton Group - * Dundee University +/* + * Jalview - A Sequence Alignment Editor and Viewer + * Copyright (C) 2006 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 java.beans.*; +import java.io.*; import java.util.*; import java.awt.*; @@ -18,920 +27,2136 @@ import java.awt.datatransfer.*; import java.awt.event.*; import java.awt.print.*; import javax.swing.*; -import javax.swing.event.*; import jalview.analysis.*; import jalview.datamodel.*; import jalview.io.*; import jalview.jbgui.*; import jalview.schemes.*; +import jalview.commands.*; import jalview.ws.*; +import java.awt.dnd.*; - -public class AlignFrame extends GAlignFrame +/** + * DOCUMENT ME! + * + * @author $author$ + * @version $Revision$ + */ +public class AlignFrame extends GAlignFrame implements DropTargetListener { - final AlignmentPanel alignPanel; - final AlignViewport viewport; - public static final int NEW_WINDOW_WIDTH = 700; - public static final int NEW_WINDOW_HEIGHT = 500; - public String currentFileFormat = "Jalview"; - - public AlignFrame(AlignmentI al) - { - viewport = new AlignViewport(al); - - alignPanel = new AlignmentPanel(this, viewport); - alignPanel.annotationPanel.adjustPanelHeight(); - alignPanel.annotationSpaceFillerHolder.setPreferredSize(alignPanel.annotationPanel.getPreferredSize()); - alignPanel.annotationScroller.setPreferredSize(alignPanel.annotationPanel.getPreferredSize()); - alignPanel.setAnnotationVisible( viewport.getShowAnnotation() ); - - getContentPane().add(alignPanel, java.awt.BorderLayout.CENTER); - - addInternalFrameListener(new InternalFrameAdapter() - { - public void internalFrameActivated(InternalFrameEvent evt) - { - javax.swing.SwingUtilities.invokeLater(new Runnable() - { - public void run() - { alignPanel.requestFocus(); } - }); - - } - }); + /** DOCUMENT ME!! */ + public static final int DEFAULT_WIDTH = 700; - } + /** DOCUMENT ME!! */ + public static final int DEFAULT_HEIGHT = 500; + public AlignmentPanel alignPanel; - public void saveAlignmentMenu_actionPerformed(ActionEvent e) - { - 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); + AlignViewport viewport; - chooser.setAcceptAllFileFilterUsed(false); - chooser.setFileView(new JalviewFileView()); - chooser.setDialogTitle("Save Alignment to file"); - chooser.setToolTipText("Save"); - int value = chooser.showSaveDialog(this); - if(value == JalviewFileChooser.APPROVE_OPTION) - { - currentFileFormat = chooser.getSelectedFormat(); + Vector alignPanels = new Vector(); - if (currentFileFormat.equals("Jalview")) - { - String shortName = title.replace('/', '_'); - title = title.replace('\\', '_'); - String choice = chooser.getSelectedFile().getPath(); - Jalview2XML.SaveState(this, choice, shortName); - // USE Jalview2XML to save this file - return; - } - String choice = chooser.getSelectedFile().getPath(); - jalview.bin.Cache.setProperty("LAST_DIRECTORY", choice); - String output = FormatAdapter.formatSequences(currentFileFormat, viewport.getAlignment().getSequences()); - try{ - java.io.PrintWriter out = new java.io.PrintWriter( new java.io.FileWriter( choice ) ); - out.println(output); - out.close(); - } - catch(Exception ex){} - } + /** DOCUMENT ME!! */ + public String currentFileFormat = null; - } + public String fileName = null; - 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.formatSequences(e.getActionCommand(), viewport.getAlignment().getSequences())); - } + private int treeCount = 0; - protected void htmlMenuItem_actionPerformed(ActionEvent e) + /** + * Creates a new AlignFrame object. + * + * @param al DOCUMENT ME! + */ + public AlignFrame(AlignmentI al, int width, int height) { - HTMLOutput htmlOutput = new HTMLOutput(viewport); - htmlOutput = null; + this(al, null, width, height); } - protected void createPNG_actionPerformed(ActionEvent e) - { - alignPanel.makePNG(); - } - protected void epsFile_actionPerformed(ActionEvent e) + /** + * new alignment window with hidden columns + * @param al AlignmentI + * @param hiddenColumns ColumnSelection or null + */ + public AlignFrame(AlignmentI al, ColumnSelection hiddenColumns, + int width, int height) { - alignPanel.makeEPS(); - } + this.setSize(width, height); + viewport = new AlignViewport(al, hiddenColumns); + alignPanel = new AlignmentPanel(this, viewport); - public void printMenuItem_actionPerformed(ActionEvent e) - { - //Putting in a thread avoids Swing painting problems - PrintThread thread = new PrintThread(); - thread.start(); - } - - class PrintThread extends Thread - { - public void run() + if(al.getDataset()==null) { - PrinterJob printJob = PrinterJob.getPrinterJob(); - PageFormat pf = printJob.pageDialog(printJob.defaultPage()); - printJob.setPrintable(alignPanel, pf); - if (printJob.printDialog()) - { - try - { - printJob.print(); - } - catch (Exception PrintException) - { - PrintException.printStackTrace(); - } - } + al.setDataset(null); } + addAlignmentPanel(alignPanel, true); + init(); } - - - - public void closeMenuItem_actionPerformed(ActionEvent e) + /** + * Make a new AlignFrame from exisiting alignmentPanels + * @param ap AlignmentPanel + * @param av AlignViewport + */ + public AlignFrame(AlignmentPanel ap) { - try{ - this.setClosed(true); - }catch(Exception ex){} + viewport = ap.av; + alignPanel = ap; + addAlignmentPanel(ap, false); + init(); } - Stack historyList = new Stack(); - Stack redoList = new Stack(); - private int treeCount = 0; + void init() + { + this.setDropTarget(new java.awt.dnd.DropTarget(this, this)); - 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 (viewport.conservation == null) + { + BLOSUM62Colour.setEnabled(false); + conservationMenuItem.setEnabled(false); + modifyConservation.setEnabled(false); + // PIDColour.setEnabled(false); + // abovePIDThreshold.setEnabled(false); + // modifyPID.setEnabled(false); + } - if(redoList.size()>0) - { - redoMenuItem.setEnabled(true); - HistoryItem hi = (HistoryItem)redoList.peek(); - redoMenuItem.setText("Redo "+hi.getDescription()); - } - else - { - redoMenuItem.setEnabled(false); - redoMenuItem.setText("Redo"); - } - } + String sortby = jalview.bin.Cache.getDefault("SORT_ALIGNMENT", "No sort"); - public void addHistoryItem(HistoryItem hi) - { - historyList.push(hi); - updateEditMenuBar(); - } + if (sortby.equals("Id")) + sortIDMenuItem_actionPerformed(null); + else if (sortby.equals("Pairwise Identity")) + sortPairwiseMenuItem_actionPerformed(null); - protected void undoMenuItem_actionPerformed(ActionEvent e) + if (Desktop.desktop != null) { - HistoryItem hi = (HistoryItem)historyList.pop(); - redoList.push(new HistoryItem(hi.getDescription(), viewport.alignment, HistoryItem.HIDE)); - restoreHistoryItem(hi); + addServiceListeners(); + setGUINucleotide(viewport.alignment.isNucleotide()); } + setMenusFromViewport(viewport); - protected void redoMenuItem_actionPerformed(ActionEvent e) + if (viewport.wrapAlignment) { - HistoryItem hi = (HistoryItem)redoList.pop(); - restoreHistoryItem(hi); - updateEditMenuBar(); - viewport.updateConsensus(); - alignPanel.repaint(); - alignPanel.repaint(); + wrapMenuItem_actionPerformed(null); } + addKeyListener(); - // used by undo and redo - void restoreHistoryItem(HistoryItem hi) - { - if(hi.getType()== HistoryItem.SORT) - { - for(int i=0; i= KeyEvent.VK_0 + && evt.getKeyCode() <= KeyEvent.VK_9) { - restore.setSequence(hi.getHidden().elementAt(i).toString()); - viewport.alignment.getSequences().insertElementAt( - restore, - hi.getAlignIndex(i)); + alignPanel.seqPanel.numberPressed(evt.getKeyChar()); } - else - 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(); + switch (evt.getKeyCode()) + { + case KeyEvent.VK_V: + if (!evt.isControlDown()) + { + AlignmentPanel newap = + new Jalview2XML().copyAlignPanel(alignPanel, true); + + if(viewport.viewName==null) + viewport.viewName="View 1"; + + newap.av.historyList = viewport.historyList; + newap.av.redoList = viewport.redoList; + newap.av.viewName = "View " + + (Desktop.getViewCount(viewport.getSequenceSetId())+1); + + addAlignmentPanel(newap, false); + + tabbedPane.setSelectedIndex(tabbedPane.getTabCount()-1); + + } + break; + case KeyEvent.VK_G: + Desktop.instance.gatherViews(af); + break; + + case KeyEvent.VK_X: + if (!evt.isControlDown()) + { + Desktop.instance.explodeViews(af); + } + break; + + + case 27: // escape key + deselectAllSequenceMenuItem_actionPerformed(null); + + break; + + case KeyEvent.VK_DOWN: + if (viewport.cursorMode) + { + alignPanel.seqPanel.moveCursor(0, 1); + } + else + moveSelectedSequences(false); + break; + + case KeyEvent.VK_UP: + if (viewport.cursorMode) + { + alignPanel.seqPanel.moveCursor(0, -1); + } + else + moveSelectedSequences(true); + break; + + case KeyEvent.VK_LEFT: + if (viewport.cursorMode) + { + alignPanel.seqPanel.moveCursor( -1, 0); + } + break; + + case KeyEvent.VK_RIGHT: + if (viewport.cursorMode) + { + alignPanel.seqPanel.moveCursor(1, 0); + } + break; + + case KeyEvent.VK_SPACE: + if (viewport.cursorMode) + { + alignPanel.seqPanel.insertGapAtCursor(evt.isControlDown() + || evt.isShiftDown() + || evt.isAltDown()); + } + break; + + case KeyEvent.VK_DELETE: + case KeyEvent.VK_BACK_SPACE: + if (!viewport.cursorMode) + { + cut_actionPerformed(null); + } + else + alignPanel.seqPanel.deleteGapAtCursor(evt.isControlDown() + || evt.isShiftDown() + || evt.isAltDown()); + + break; + + case KeyEvent.VK_S: + if (viewport.cursorMode) + { + alignPanel.seqPanel.setCursorRow(); + } + break; + case KeyEvent.VK_C: + if (viewport.cursorMode && !evt.isControlDown()) + { + alignPanel.seqPanel.setCursorColumn(); + } + break; + case KeyEvent.VK_P: + if (viewport.cursorMode) + { + alignPanel.seqPanel.setCursorPosition(); + } + break; + + case KeyEvent.VK_ENTER: + case KeyEvent.VK_COMMA: + if (viewport.cursorMode) + { + alignPanel.seqPanel.setCursorRowAndColumn(); + } + break; + + case KeyEvent.VK_Q: + if (viewport.cursorMode) + { + alignPanel.seqPanel.setSelectionAreaAtCursor(true); + } + break; + case KeyEvent.VK_M: + if (viewport.cursorMode) + { + alignPanel.seqPanel.setSelectionAreaAtCursor(false); + } + break; + + case KeyEvent.VK_F2: + viewport.cursorMode = !viewport.cursorMode; + statusBar.setText("Keyboard editing mode is " + + (viewport.cursorMode ? "on" : "off")); + if (viewport.cursorMode) + { + alignPanel.seqPanel.seqCanvas.cursorX = viewport.startRes; + alignPanel.seqPanel.seqCanvas.cursorY = viewport.startSeq; + } + alignPanel.seqPanel.seqCanvas.repaint(); + break; + + case KeyEvent.VK_F1: + try + { + ClassLoader cl = jalview.gui.Desktop.class.getClassLoader(); + java.net.URL url = javax.help.HelpSet.findHelpSet(cl, "help/help"); + javax.help.HelpSet hs = new javax.help.HelpSet(cl, url); + + javax.help.HelpBroker hb = hs.createHelpBroker(); + hb.setCurrentID("home"); + hb.setDisplayed(true); + } + catch (Exception ex) + { + ex.printStackTrace(); + } + break + ; + case KeyEvent.VK_H: + { + boolean toggleSeqs = !evt.isControlDown(); + boolean toggleCols = !evt.isShiftDown(); + + boolean hide = false; + + SequenceGroup sg = viewport.getSelectionGroup(); + if (toggleSeqs) + { + if (sg != null && sg.getSize(false) != viewport.alignment.getHeight()) + { + hideSelSequences_actionPerformed(null); + hide = true; + } + else if (! (toggleCols && viewport.colSel.getSelected().size() > 0)) + showAllSeqs_actionPerformed(null); + } + + if (toggleCols) + { + if (viewport.colSel.getSelected().size() > 0) + { + hideSelColumns_actionPerformed(null); + if (!toggleSeqs) + viewport.selectionGroup = sg; + } + else if (!hide) + showAllColumns_actionPerformed(null); + } + break; + } + case KeyEvent.VK_PAGE_UP: + if (viewport.wrapAlignment) + alignPanel.scrollUp(true); + else + alignPanel.setScrollValues(viewport.startRes, + viewport.startSeq + - viewport.endSeq + viewport.startSeq); + break; + case KeyEvent.VK_PAGE_DOWN: + if (viewport.wrapAlignment) + alignPanel.scrollUp(false); + else + alignPanel.setScrollValues(viewport.startRes, + viewport.startSeq + + viewport.endSeq - viewport.startSeq); + break; + } + } + }); + } - viewport.updateConsensus(); - viewport.updateConservation(); - alignPanel.repaint(); - } - public void moveSelectedSequences(boolean up) + public void addAlignmentPanel(final AlignmentPanel ap, + boolean newPanel) { - SequenceGroup sg = viewport.getSelectionGroup(); - if (sg == null) - return; + ap.alignFrame = this; - if (up) - { - for (int i = 1; i < viewport.alignment.getHeight(); i++) - { - SequenceI seq = viewport.alignment.getSequenceAt(i); - if (!sg.sequences.contains(seq)) - continue; + alignPanels.addElement(ap); - SequenceI temp = viewport.alignment.getSequenceAt(i - 1); - if (sg.sequences.contains(temp)) - continue; + int aSize = alignPanels.size(); - viewport.alignment.getSequences().setElementAt(temp, i); - viewport.alignment.getSequences().setElementAt(seq, i - 1); - } + tabbedPane.setVisible(aSize>1 || ap.av.viewName!=null); + + if (aSize == 1 && ap.av.viewName==null) + { + this.getContentPane().add(ap, BorderLayout.CENTER); } else { - for (int i = viewport.alignment.getHeight() - 2; i > -1; i--) + if (aSize == 2) { - SequenceI seq = viewport.alignment.getSequenceAt(i); - if (!sg.sequences.contains(seq)) - continue; + AlignmentPanel first = (AlignmentPanel) alignPanels.firstElement(); + tabbedPane.addTab(first.av.viewName==null?"Original":first.av.viewName,first); - 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); + this.getContentPane().add(tabbedPane, BorderLayout.CENTER); } - } - - alignPanel.repaint(); - } - - - - protected void copy_actionPerformed(ActionEvent e) - { - if(viewport.getSelectionGroup()==null) - return; - - SequenceGroup sg = viewport.getSelectionGroup(); - - Clipboard c = Toolkit.getDefaultToolkit().getSystemClipboard(); - StringBuffer buffer= new StringBuffer(); - Hashtable orderedSeqs = new Hashtable(); - 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); + Desktop.instance.inputTextboxMenuItem_actionPerformed(viewport); + } - if(viewport.getSelectionGroup()!=null) - viewport.getSelectionGroup().adjustForRemoveLeft(min); + public void addFromURL_actionPerformed(ActionEvent e) + { + Desktop.instance.inputURLMenuItem_actionPerformed(viewport); + } - Vector groups = viewport.alignment.getGroups(); - for(int i=0; i 0) - { - addHistoryItem(new HistoryItem("Remove Right",viewport.alignment, - HistoryItem.HIDE)); - - int max = colSel.getMax(); - viewport.getAlignment().trimRight(max); - if(viewport.getSelectionGroup()!=null) - viewport.getSelectionGroup().adjustForRemoveRight(max); + 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, + false); - Vector groups = viewport.alignment.getGroups(); - for(int i=0; i -1) + { + shortName = shortName.substring(shortName.lastIndexOf( + java.io.File.separatorChar) + 1); } - viewport.updateConservation(); - viewport.updateConsensus(); - alignPanel.repaint(); - } + new Jalview2XML().SaveAlignment(this, file, shortName); - public void findMenuItem_actionPerformed(ActionEvent e) - { - JInternalFrame frame = new JInternalFrame(); - Finder finder = new Finder(viewport, alignPanel, frame); - frame.setContentPane(finder); - Desktop.addInternalFrame(frame, "Find", 340,110); - frame.setLayer(JLayeredPane.PALETTE_LAYER); + statusBar.setText("Successfully saved to file: " + +fileName+" in " + +format +" format."); - } + // USE Jalview2XML to save this file + return true; + } + else + { - public void font_actionPerformed(ActionEvent e) - { - FontChooser fc = new FontChooser( alignPanel ); - } + String[] omitHidden = null; - protected void fullSeqId_actionPerformed(ActionEvent e) - { - viewport.setShowFullId( fullSeqId.isSelected() ); + if (viewport.hasHiddenColumns) + { + int reply = JOptionPane.showInternalConfirmDialog(Desktop.desktop, + "The Alignment contains hidden columns." + + "\nDo you want to save only the visible alignment?", + "Save / Omit Hidden Columns", + JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE); + + if (reply == JOptionPane.YES_OPTION) + omitHidden = viewport.getViewAsString(false); + } - alignPanel.idPanel.idCanvas.setPreferredSize( alignPanel.calculateIdWidth() ); - alignPanel.repaint(); - } + String output = new FormatAdapter().formatSequences( + format, + viewport.alignment.getSequencesArray(), + omitHidden); - protected void colourTextMenuItem_actionPerformed(ActionEvent e) - { - viewport.setColourText( colourTextMenuItem.isSelected() ); - alignPanel.repaint(); - } + if (output == null) + { + return false; + } - protected void wrapMenuItem_actionPerformed(ActionEvent e) - { - viewport.setWrapAlignment( wrapMenuItem.isSelected() ); - alignPanel.setWrapAlignment( wrapMenuItem.isSelected() ); - scaleAbove.setVisible( wrapMenuItem.isSelected() ); - scaleLeft.setVisible( wrapMenuItem.isSelected() ); - scaleRight.setVisible( wrapMenuItem.isSelected() ); - alignPanel.repaint(); - } + try + { + java.io.PrintWriter out = new java.io.PrintWriter( + new java.io.FileWriter(file)); - protected void scaleAbove_actionPerformed(ActionEvent e) - { - viewport.setScaleAboveWrapped(scaleAbove.isSelected()); - alignPanel.repaint(); + out.print(output); + out.close(); + this.setTitle(file); + statusBar.setText("Successfully saved to file: " + +fileName+" in " + +format +" format."); + return true; + } + catch (Exception ex) + { + ex.printStackTrace(); + } + } + return false; } - protected void scaleLeft_actionPerformed(ActionEvent e) + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ + protected void outputText_actionPerformed(ActionEvent e) { - viewport.setScaleLeftWrapped(scaleLeft.isSelected()); - alignPanel.repaint(); - } + String [] omitHidden = null; - protected void scaleRight_actionPerformed(ActionEvent e) - { - viewport.setScaleRightWrapped(scaleRight.isSelected()); - alignPanel.repaint(); - } + if(viewport.hasHiddenColumns) + { + int reply = JOptionPane.showInternalConfirmDialog(Desktop.desktop, + "The Alignment contains hidden columns." + +"\nDo you want to output only the visible alignment?", + "Save / Omit Hidden Columns", + JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE); + if(reply==JOptionPane.YES_OPTION) + { + omitHidden = viewport.getViewAsString(false); + } + } + CutAndPasteTransfer cap = new CutAndPasteTransfer(); + Desktop.addInternalFrame(cap, + "Alignment output - " + e.getActionCommand(), 600, + 500); - public void viewBoxesMenuItem_actionPerformed(ActionEvent e) - { - viewport.setShowBoxes( viewBoxesMenuItem.isSelected() ); - alignPanel.repaint(); + + cap.setText(new FormatAdapter().formatSequences( + e.getActionCommand(), + viewport.alignment.getSequencesArray(), + omitHidden)); } - public void viewTextMenuItem_actionPerformed(ActionEvent e) + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ + protected void htmlMenuItem_actionPerformed(ActionEvent e) { - viewport.setShowText( viewTextMenuItem.isSelected() ); - alignPanel.repaint(); + new HTMLOutput(viewport, + alignPanel.seqPanel.seqCanvas.getSequenceRenderer(), + alignPanel.seqPanel.seqCanvas.getFeatureRenderer()); } - - protected void renderGapsMenuItem_actionPerformed(ActionEvent e) + public void createImageMap(File file, String image) { - viewport.setRenderGaps(renderGapsMenuItem.isSelected()); - alignPanel.repaint(); + alignPanel.makePNGImageMap(file, image); } - public void sequenceFeatures_actionPerformed(ActionEvent evt) + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ + public void createPNG(File f) { - viewport.showSequenceFeatures(sequenceFeatures.isSelected()); - if(viewport.showSequenceFeatures && !((Alignment)viewport.alignment).featuresAdded) - { - SequenceFeatureFetcher sft = new SequenceFeatureFetcher(viewport.alignment, alignPanel); - ((Alignment)viewport.alignment).featuresAdded = true; - } - alignPanel.repaint(); + alignPanel.makePNG(f); } - public void annotationPanelMenuItem_actionPerformed(ActionEvent e) + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ + public void createEPS(File f) { - if(annotationPanelMenuItem.isSelected() && viewport.getWrapAlignment()) - { - annotationPanelMenuItem.setSelected(false); - return; - } - viewport.setShowAnnotation( annotationPanelMenuItem.isSelected() ); - alignPanel.setAnnotationVisible( annotationPanelMenuItem.isSelected() ); + alignPanel.makeEPS(f); } - public void overviewMenuItem_actionPerformed(ActionEvent e) + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ + public void printMenuItem_actionPerformed(ActionEvent e) { - if (alignPanel.overviewPanel != null) - return; - - JInternalFrame frame = new JInternalFrame(); - OverviewPanel overview = new OverviewPanel(alignPanel); - frame.setContentPane(overview); - Desktop.addInternalFrame(frame, "Overview " + this.getTitle(), - frame.getWidth(), frame.getHeight()); - frame.pack(); - frame.setLayer(JLayeredPane.PALETTE_LAYER); - frame.addInternalFrameListener(new javax.swing.event.InternalFrameAdapter() - { public void internalFrameClosed(javax.swing.event.InternalFrameEvent evt) - { - alignPanel.setOverviewPanel(null); - }; - }); - - alignPanel.setOverviewPanel( overview ); - - + //Putting in a thread avoids Swing painting problems + PrintThread thread = new PrintThread(); + thread.start(); } - protected void noColourmenuItem_actionPerformed(ActionEvent e) + public void exportFeatures_actionPerformed(ActionEvent e) { - changeColour( null ); + new AnnotationExporter().exportFeatures(alignPanel); } - public void clustalColour_actionPerformed(ActionEvent e) + public void exportAnnotations_actionPerformed(ActionEvent e) { - abovePIDThreshold.setSelected(false); - changeColour(new ClustalxColourScheme(viewport.alignment.getSequences(), viewport.alignment.getWidth())); + new AnnotationExporter().exportAnnotations( + alignPanel, + viewport.alignment.getAlignmentAnnotation() + ); } - public void zappoColour_actionPerformed(ActionEvent e) - { - changeColour(new ZappoColourScheme()); - } - public void taylorColour_actionPerformed(ActionEvent e) + public void associatedData_actionPerformed(ActionEvent e) { - changeColour(new TaylorColourScheme()); - } + // Pick the tree file + JalviewFileChooser chooser = new JalviewFileChooser(jalview.bin.Cache. + getProperty( + "LAST_DIRECTORY")); + chooser.setFileView(new JalviewFileView()); + chooser.setDialogTitle("Load Jalview Annotations or Features File"); + chooser.setToolTipText("Load Jalview Annotations / Features file"); + int value = chooser.showOpenDialog(null); - public void hydrophobicityColour_actionPerformed(ActionEvent e) - { - changeColour( new HydrophobicColourScheme() ); - } + if (value == JalviewFileChooser.APPROVE_OPTION) + { + String choice = chooser.getSelectedFile().getPath(); + jalview.bin.Cache.setProperty("LAST_DIRECTORY", choice); + loadJalviewDataFile(choice); + } - public void helixColour_actionPerformed(ActionEvent e) - { - changeColour(new HelixColourScheme() ); } - public void strandColour_actionPerformed(ActionEvent e) + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ + public void closeMenuItem_actionPerformed(ActionEvent e) { - changeColour(new StrandColourScheme()); - } + try + { + if(alignPanels!=null) + { + for (int i = 0; i < alignPanels.size(); i++) + { + AlignmentPanel ap = (AlignmentPanel) alignPanels.elementAt(i); + PaintRefresher.RemoveComponent(ap.seqPanel.seqCanvas); + PaintRefresher.RemoveComponent(ap.idPanel.idCanvas); + PaintRefresher.RemoveComponent(ap); + } + // alignPanels = null; + } + // else + // System.out.println("null one here"); + // alignPanel = null; + // viewport = null; - public void turnColour_actionPerformed(ActionEvent e) - { - changeColour(new TurnColourScheme()); + this.setClosed(true); + } + catch (Exception ex) + { + ex.printStackTrace(); + } } - public void buriedColour_actionPerformed(ActionEvent e) + /** + * DOCUMENT ME! + */ + void updateEditMenuBar() { - changeColour(new BuriedColourScheme() ); - } - public void nucleotideColour_actionPerformed(ActionEvent e) - { - changeColour(new NucleotideColourScheme()); - } + if (viewport.historyList.size() > 0) + { + undoMenuItem.setEnabled(true); + CommandI command = (CommandI) viewport.historyList.peek(); + undoMenuItem.setText("Undo " + command.getDescription()); + } + else + { + undoMenuItem.setEnabled(false); + undoMenuItem.setText("Undo"); + } + if (viewport.redoList.size() > 0) + { + redoMenuItem.setEnabled(true); - protected void applyToAllGroups_actionPerformed(ActionEvent e) - { - viewport.setColourAppliesToAllGroups(applyToAllGroups.isSelected()); + CommandI command = (CommandI) viewport.redoList.peek(); + redoMenuItem.setText("Redo " + command.getDescription()); + } + else + { + redoMenuItem.setEnabled(false); + redoMenuItem.setText("Redo"); + } } - - void changeColour(ColourSchemeI cs) + public void addHistoryItem(CommandI command) { - int threshold = 0; - - if ( viewport.getAbovePIDThreshold() ) + if(command.getSize()>0) { - threshold = SliderPanel.setPIDSliderSource(alignPanel, cs, "Background"); - - if (cs instanceof ResidueColourScheme) - ( (ResidueColourScheme) cs).setThreshold(threshold); - else if (cs instanceof ScoreColourScheme) - ( (ScoreColourScheme) cs).setThreshold(threshold); - - viewport.setGlobalColourScheme(cs); + viewport.historyList.push(command); + viewport.redoList.clear(); + updateEditMenuBar(); + viewport.hasHiddenColumns = viewport.colSel.getHiddenColumns() != null; } - else if (cs instanceof ResidueColourScheme) - ( (ResidueColourScheme) cs).setThreshold(0); - else if (cs instanceof ScoreColourScheme) - ( (ScoreColourScheme) cs).setThreshold(0); + } - if (viewport.getConservationSelected()) - { - ConservationColourScheme ccs = null; + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ + protected void undoMenuItem_actionPerformed(ActionEvent e) + { + CommandI command = (CommandI)viewport.historyList.pop(); + viewport.redoList.push(command); + command.undoCommand(); - Alignment al = (Alignment) viewport.alignment; - Conservation c = new Conservation("All", - ResidueProperties.propHash, 3, - al.getSequences(), 0, - al.getWidth() - 1); + viewport.hasHiddenColumns = viewport.colSel.getHiddenColumns() != null; + updateEditMenuBar(); + viewport.firePropertyChange("alignment", null, + viewport.getAlignment().getSequences()); + } - c.calculate(); - c.verdict(false, viewport.ConsPercGaps); + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ + protected void redoMenuItem_actionPerformed(ActionEvent e) + { + CommandI command = (CommandI) viewport.redoList.pop(); + viewport.historyList.push(command); + command.doCommand(); + viewport.hasHiddenColumns = viewport.colSel.getHiddenColumns()!=null; - ccs = new ConservationColourScheme(c, cs); + updateEditMenuBar(); + viewport.firePropertyChange("alignment", null, viewport.getAlignment().getSequences()); + } - // MUST NOTIFY THE COLOURSCHEME OF CONSENSUS! - ccs.setConsensus( viewport.vconsensus ); - viewport.setGlobalColourScheme(ccs); - SliderPanel.setConservationSlider(alignPanel, ccs, "Background"); + /** + * DOCUMENT ME! + * + * @param up DOCUMENT ME! + */ + public void moveSelectedSequences(boolean up) + { + SequenceGroup sg = viewport.getSelectionGroup(); - } - else + if (sg == null) { - // MUST NOTIFY THE COLOURSCHEME OF CONSENSUS! - if (cs != null) - cs.setConsensus(viewport.vconsensus); - viewport.setGlobalColourScheme(cs); + return; } - - if(viewport.getColourAppliesToAllGroups()) + if (up) { - Vector groups = viewport.alignment.getGroups(); - for(int i=0; i -1; i--) + { + SequenceI seq = viewport.alignment.getSequenceAt(i); - sg.cs.setConsensus( AAFrequency.calculate(sg.sequences, 0, sg.getWidth()) ); + if (!sg.getSequences(false).contains(seq)) + { + continue; } - 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); - ConservationColourScheme ccs = new ConservationColourScheme(c, sg.cs); + SequenceI temp = viewport.alignment.getSequenceAt(i + 1); - // MUST NOTIFY THE COLOURSCHEME OF CONSENSUS! - ccs.setConsensus( AAFrequency.calculate(sg.sequences, 0, sg.getWidth())); - sg.cs = ccs; - } - else if(cs!=null) + if (sg.getSequences(false).contains(temp)) { - // MUST NOTIFY THE COLOURSCHEME OF CONSENSUS! - sg.cs.setConsensus(AAFrequency.calculate(sg.sequences, 0, sg.getWidth())); + continue; } + viewport.alignment.getSequences().setElementAt(temp, i); + viewport.alignment.getSequences().setElementAt(seq, i + 1); } } - if(alignPanel.getOverviewPanel()!=null) - alignPanel.getOverviewPanel().updateOverviewImage(); alignPanel.repaint(); } - protected void modifyPID_actionPerformed(ActionEvent e) - { - if(viewport.getAbovePIDThreshold()) - { - SliderPanel.setPIDSliderSource(alignPanel, viewport.getGlobalColourScheme(), - "Background"); - SliderPanel.showPIDSlider(); - } - } - protected void modifyConservation_actionPerformed(ActionEvent e) + + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ + protected void copy_actionPerformed(ActionEvent e) { - if(viewport.getConservationSelected()) + System.gc(); + if (viewport.getSelectionGroup() == null) { - SliderPanel.setConservationSlider(alignPanel, viewport.globalColourScheme, - "Background"); - SliderPanel.showConservationSlider(); + 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 + { + //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>>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 e) + { + + SequenceGroup sg = viewport.getSelectionGroup(); + if (sg == null) + { + return; + } + + Vector seqs = new Vector(); + int cutLength = sg.getEndRes()-sg.getStartRes()+1; + boolean seqsCut = false; + SequenceI seq; + for (int i = 0; i < sg.getSize(false); i++) + { + seq = sg.getSequenceAt(i); + seqs.addElement(seq); + if(seq.getLength()<=cutLength) + seqsCut = true; + } + + + // If the cut affects all sequences, remove highlighted columns + if (sg.getSize(false) == viewport.alignment.getHeight()) + { + viewport.getColumnSelection().removeElements(sg.getStartRes(), + sg.getEndRes() + 1); + } + + + SequenceI [] cut = new SequenceI[seqs.size()]; + for(int i=0; i 0) + { + if(trimLeft) + column = colSel.getMin(); + else + column = colSel.getMax(); + + SequenceI [] seqs; + if(viewport.getSelectionGroup()!=null) + seqs = viewport.getSelectionGroup().getSequencesAsArray(true); + 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); + } + 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(true); + start = viewport.getSelectionGroup().getStartRes(); + end = viewport.getSelectionGroup().getEndRes(); + } + else + seqs = viewport.alignment.getSequencesArray(); + + + RemoveGapColCommand removeGapCols = + new RemoveGapColCommand("Remove Gapped Columns", + seqs, + start, end, + viewport.getGapCharacter()); + + 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(true); + start = viewport.getSelectionGroup().getStartRes(); + end = viewport.getSelectionGroup().getEndRes(); + } + else + seqs = viewport.alignment.getSequencesArray(); + + //This is to maintain viewport position on first residue + //of first sequence + SequenceI seq = viewport.alignment.getSequenceAt(0); + int startRes = seq.findPosition(viewport.startRes); + + addHistoryItem(new RemoveGapsCommand("Remove Gaps", + seqs, + start, end, + viewport.getGapCharacter())); + + viewport.setStartRes(seq.findIndex(startRes)-1); + + viewport.firePropertyChange("alignment", null, viewport.getAlignment().getSequences()); + + } + + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ + public void padGapsMenuitem_actionPerformed(ActionEvent e) + { + viewport.padGaps = padGapsMenuitem.isSelected(); + + viewport.firePropertyChange("alignment", + null, + viewport.getAlignment().getSequences()); + } + + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ + public void findMenuItem_actionPerformed(ActionEvent e) + { + JInternalFrame frame = new JInternalFrame(); + Finder finder = new Finder(viewport, alignPanel, frame); + frame.setContentPane(finder); + frame.setLayer(JLayeredPane.PALETTE_LAYER); + Desktop.addInternalFrame(frame, "Find", 340, 110); + } + + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ + public void font_actionPerformed(ActionEvent e) + { + new FontChooser(alignPanel); + } + + public void smoothFont_actionPerformed(ActionEvent e) + { + viewport.antiAlias = smoothFont.isSelected(); + alignPanel.annotationPanel.image = null; + alignPanel.repaint(); + } + + + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ + protected void seqLimit_actionPerformed(ActionEvent e) + { + viewport.setShowJVSuffix(seqLimits.isSelected()); + + alignPanel.idPanel.idCanvas.setPreferredSize(alignPanel.calculateIdWidth()); + alignPanel.repaint(); + } + + + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ + protected void colourTextMenuItem_actionPerformed(ActionEvent e) + { + viewport.setColourText(colourTextMenuItem.isSelected()); + alignPanel.repaint(); + } + + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ + public void wrapMenuItem_actionPerformed(ActionEvent e) + { + scaleAbove.setVisible(wrapMenuItem.isSelected()); + scaleLeft.setVisible(wrapMenuItem.isSelected()); + scaleRight.setVisible(wrapMenuItem.isSelected()); + viewport.setWrapAlignment(wrapMenuItem.isSelected()); + alignPanel.setWrapAlignment(wrapMenuItem.isSelected()); + } + + public void showAllSeqs_actionPerformed(ActionEvent e) + { + viewport.showAllHiddenSeqs(); + } + + public void showAllColumns_actionPerformed(ActionEvent e) + { + viewport.showAllHiddenColumns(); + repaint(); + } + + public void hideSelSequences_actionPerformed(ActionEvent e) + { + viewport.hideAllSelectedSeqs(); + alignPanel.repaint(); + } + + public void hideSelColumns_actionPerformed(ActionEvent e) + { + viewport.hideSelectedColumns(); + alignPanel.repaint(); + } + + public void hiddenMarkers_actionPerformed(ActionEvent e) + { + viewport.setShowHiddenMarkers(hiddenMarkers.isSelected()); + repaint(); + } + + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ + protected void scaleAbove_actionPerformed(ActionEvent e) + { + viewport.setScaleAboveWrapped(scaleAbove.isSelected()); + alignPanel.repaint(); + } + + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ + protected void scaleLeft_actionPerformed(ActionEvent e) + { + viewport.setScaleLeftWrapped(scaleLeft.isSelected()); + alignPanel.repaint(); + } + + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ + protected void scaleRight_actionPerformed(ActionEvent e) + { + viewport.setScaleRightWrapped(scaleRight.isSelected()); + alignPanel.repaint(); + } + + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ + public void viewBoxesMenuItem_actionPerformed(ActionEvent e) + { + viewport.setShowBoxes(viewBoxesMenuItem.isSelected()); + alignPanel.repaint(); + } + + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ + public void viewTextMenuItem_actionPerformed(ActionEvent e) + { + viewport.setShowText(viewTextMenuItem.isSelected()); + alignPanel.repaint(); + } + + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ + protected void renderGapsMenuItem_actionPerformed(ActionEvent e) + { + viewport.setRenderGaps(renderGapsMenuItem.isSelected()); + alignPanel.repaint(); + } + + + public FeatureSettings featureSettings; + public void featureSettings_actionPerformed(ActionEvent e) + { + if(featureSettings !=null ) + { + featureSettings.close(); + featureSettings = null; + } + featureSettings = new FeatureSettings(this); + } + + /** + * DOCUMENT ME! + * + * @param evt DOCUMENT ME! + */ + public void showSeqFeatures_actionPerformed(ActionEvent evt) + { + viewport.setShowSequenceFeatures(showSeqFeatures.isSelected()); + alignPanel.repaint(); + if (alignPanel.getOverviewPanel() != null) + { + alignPanel.getOverviewPanel().updateOverviewImage(); + } + } + + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ + public void annotationPanelMenuItem_actionPerformed(ActionEvent e) + { + viewport.setShowAnnotation(annotationPanelMenuItem.isSelected()); + alignPanel.setAnnotationVisible(annotationPanelMenuItem.isSelected()); + } + + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ + public void overviewMenuItem_actionPerformed(ActionEvent e) + { + if (alignPanel.overviewPanel != null) + { + return; + } + + JInternalFrame frame = new JInternalFrame(); + OverviewPanel overview = new OverviewPanel(alignPanel); + frame.setContentPane(overview); + Desktop.addInternalFrame(frame, "Overview " + this.getTitle(), + frame.getWidth(), frame.getHeight()); + frame.pack(); + frame.setLayer(JLayeredPane.PALETTE_LAYER); + frame.addInternalFrameListener(new javax.swing.event.InternalFrameAdapter() + { + public void internalFrameClosed( + javax.swing.event.InternalFrameEvent evt) + { + alignPanel.setOverviewPanel(null); + } + ; + }); + + alignPanel.setOverviewPanel(overview); + } + + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ + protected void noColourmenuItem_actionPerformed(ActionEvent e) + { + changeColour(null); + } + + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ + public void clustalColour_actionPerformed(ActionEvent e) + { + changeColour(new ClustalxColourScheme( + viewport.alignment.getSequences(), viewport.alignment.getWidth())); + } + + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ + public void zappoColour_actionPerformed(ActionEvent e) + { + changeColour(new ZappoColourScheme()); + } + + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ + public void taylorColour_actionPerformed(ActionEvent e) + { + changeColour(new TaylorColourScheme()); + } + + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ + public void hydrophobicityColour_actionPerformed(ActionEvent e) + { + changeColour(new HydrophobicColourScheme()); + } + + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ + public void helixColour_actionPerformed(ActionEvent e) + { + changeColour(new HelixColourScheme()); + } + + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ + public void strandColour_actionPerformed(ActionEvent e) + { + changeColour(new StrandColourScheme()); + } + + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ + public void turnColour_actionPerformed(ActionEvent e) + { + changeColour(new TurnColourScheme()); + } + + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ + public void buriedColour_actionPerformed(ActionEvent e) + { + changeColour(new BuriedColourScheme()); + } + + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ + public void nucleotideColour_actionPerformed(ActionEvent e) + { + changeColour(new NucleotideColourScheme()); + } + + public void annotationColour_actionPerformed(ActionEvent e) + { + new AnnotationColourChooser(viewport, alignPanel); + } + + + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ + protected void applyToAllGroups_actionPerformed(ActionEvent e) + { + viewport.setColourAppliesToAllGroups(applyToAllGroups.isSelected()); + } + + /** + * DOCUMENT ME! + * + * @param cs DOCUMENT ME! + */ + public void changeColour(ColourSchemeI cs) + { + int threshold = 0; + + if(cs!=null) + { + if (viewport.getAbovePIDThreshold()) + { + threshold = SliderPanel.setPIDSliderSource(alignPanel, cs, + "Background"); + + cs.setThreshold(threshold, + viewport.getIgnoreGapsConsensus()); + + viewport.setGlobalColourScheme(cs); + } + else + { + cs.setThreshold(0, viewport.getIgnoreGapsConsensus()); + } + + if (viewport.getConservationSelected()) + { + + Alignment al = (Alignment) viewport.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); + + cs.setConservationInc(SliderPanel.setConservationSlider(alignPanel, cs, + "Background")); + } + else + { + cs.setConservation(null); + } + + cs.setConsensus(viewport.hconsensus); + } + + viewport.setGlobalColourScheme(cs); + + if (viewport.getColourAppliesToAllGroups()) + { + Vector groups = viewport.alignment.getGroups(); + + for (int i = 0; i < groups.size(); i++) + { + SequenceGroup sg = (SequenceGroup) groups.elementAt(i); + + if (cs == null) + { + sg.cs = null; + continue; + } + + if (cs instanceof ClustalxColourScheme) + { + sg.cs = new ClustalxColourScheme( + sg.getSequences(true), 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()); + + sg.cs.setConsensus(AAFrequency.calculate( + sg.getSequences(true), 0, + sg.getWidth())); + } + else + sg.cs.setThreshold(0, viewport.getIgnoreGapsConsensus()); + + + if (viewport.getConservationSelected()) + { + Conservation c = new Conservation("Group", + ResidueProperties.propHash, 3, + sg.getSequences(true), 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) { viewport.setConservationSelected(conservationMenuItem.isSelected()); viewport.setAbovePIDThreshold(false); abovePIDThreshold.setSelected(false); - ColourSchemeI cs = viewport.getGlobalColourScheme(); - if(cs instanceof ConservationColourScheme ) - changeColour( ((ConservationColourScheme)cs).cs ); - else - changeColour( cs ); + changeColour(viewport.getGlobalColourScheme()); modifyConservation_actionPerformed(null); } + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ public void abovePIDThreshold_actionPerformed(ActionEvent e) { viewport.setAbovePIDThreshold(abovePIDThreshold.isSelected()); @@ -939,367 +2164,1005 @@ public class AlignFrame extends GAlignFrame conservationMenuItem.setSelected(false); viewport.setConservationSelected(false); - ColourSchemeI cs = viewport.getGlobalColourScheme(); - - if(cs instanceof ConservationColourScheme ) - changeColour( ((ConservationColourScheme)cs).cs ); - else - changeColour( cs ); + 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()); + changeColour(udc); + } + } - public void userDefinedColour_actionPerformed(ActionEvent e) + public void updateUserColourMenu() { - UserDefinedColours chooser = new UserDefinedColours( alignPanel, null); + + 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); + } + }); + + colourMenu.insert(radioItem, 15); + colours.add(radioItem); + } + } } + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ public void PIDColour_actionPerformed(ActionEvent e) { - changeColour( new PIDColourScheme() ); + changeColour(new PIDColourScheme()); + } + + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ + public void BLOSUM62Colour_actionPerformed(ActionEvent e) + { + changeColour(new Blosum62ColourScheme()); + } + + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ + public void sortPairwiseMenuItem_actionPerformed(ActionEvent e) + { + SequenceI [] oldOrder = viewport.getAlignment().getSequencesArray(); + AlignmentSorter.sortByPID(viewport.getAlignment(), + viewport.getAlignment().getSequenceAt(0)); + addHistoryItem(new OrderCommand("Pairwise Sort", oldOrder, viewport.alignment)); + alignPanel.repaint(); + } + + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ + public void sortIDMenuItem_actionPerformed(ActionEvent e) + { + SequenceI [] oldOrder = viewport.getAlignment().getSequencesArray(); + AlignmentSorter.sortByID(viewport.getAlignment()); + addHistoryItem(new OrderCommand("ID Sort", oldOrder, viewport.alignment)); + alignPanel.repaint(); + } + + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ + public void sortGroupMenuItem_actionPerformed(ActionEvent e) + { + SequenceI [] oldOrder = viewport.getAlignment().getSequencesArray(); + AlignmentSorter.sortByGroup(viewport.getAlignment()); + addHistoryItem(new OrderCommand("Group Sort", oldOrder, viewport.alignment)); + + alignPanel.repaint(); + } + + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ + public void removeRedundancyMenuItem_actionPerformed(ActionEvent e) + { + new RedundancyPanel(alignPanel, this); + } + + + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ + public void pairwiseAlignmentMenuItem_actionPerformed(ActionEvent e) + { + if ( (viewport.getSelectionGroup() == null) || + (viewport.getSelectionGroup().getSize(false) < 2)) + { + JOptionPane.showInternalMessageDialog(this, + "You must select at least 2 sequences.", + "Invalid Selection", + JOptionPane.WARNING_MESSAGE); + } + else + { + JInternalFrame frame = new JInternalFrame(); + frame.setContentPane(new PairwiseAlignPanel(viewport)); + Desktop.addInternalFrame(frame, "Pairwise Alignment", 600, 500); + } + } + + /** + * DOCUMENT ME! + * + * @param e DOCUMENT ME! + */ + public void PCAMenuItem_actionPerformed(ActionEvent e) + { + if ( ( (viewport.getSelectionGroup() != null) && + (viewport.getSelectionGroup().getSize(false) < 4) && + (viewport.getSelectionGroup().getSize(false) > 0)) || + (viewport.getAlignment().getHeight() < 4)) + { + JOptionPane.showInternalMessageDialog(this, + "Principal component analysis must take\n" + + "at least 4 input sequences.", + "Sequence selection insufficient", + JOptionPane.WARNING_MESSAGE); + + return; + } + + new PCAPanel(viewport); + } + + + public void autoCalculate_actionPerformed(ActionEvent e) + { + viewport.autoCalculateConsensus = autoCalculate.isSelected(); + if(viewport.autoCalculateConsensus) + { + viewport.firePropertyChange("alignment", + null, + viewport.getAlignment().getSequences()); + } + } + + + /** + * 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 BLOSUM62"); + } + + /** + * DOCUMENT ME! + * + * @param type DOCUMENT ME! + * @param pwType DOCUMENT ME! + * @param title DOCUMENT ME! + */ + void NewTreePanel(String type, String pwType, String title) + { + TreePanel tp; + + if (viewport.getSelectionGroup() != null) { + if (viewport.getSelectionGroup().getSize(false) < 3) { + JOptionPane.showMessageDialog(Desktop.desktop, + "You need to have more than two sequences selected to build a tree!", + "Not enough sequences", + JOptionPane.WARNING_MESSAGE); + return; + } + + int s = 0; + SequenceGroup sg = viewport.getSelectionGroup(); + + /* Decide if the selection is a column region */ + while (s < sg.getSize(false)) + { + if ( ( (SequenceI) sg.getSequences(false).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(alignPanel, type, pwType); + } + 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; + } + + if(viewport.alignment.getHeight()<2) + return; + + tp = new TreePanel(alignPanel, type, pwType); + } + + addTreeMenuItem(tp, title); + + Desktop.addInternalFrame(tp, title + " from " + this.title, 600, 500); + } + + /** + * DOCUMENT ME! + * + * @param title DOCUMENT ME! + * @param order DOCUMENT ME! + */ + public void addSortByOrderMenuItem(String title, final AlignmentOrder order) + { + final JMenuItem item = new JMenuItem("by " + title); + sort.add(item); + item.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + SequenceI [] oldOrder = viewport.getAlignment().getSequencesArray(); + + // TODO: JBPNote - have to map order entries to curent SequenceI pointers + AlignmentSorter.sortBy(viewport.getAlignment(), order); + + addHistoryItem(new OrderCommand(order.getName(), oldOrder, viewport.alignment)); + + 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) + { + SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray(); + AlignmentSorter.sortByTree(viewport.getAlignment(), + treePanel.getTree()); + + addHistoryItem(new OrderCommand("Tree Sort", + oldOrder, + viewport.alignment)); + + + 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); + } + } + ; + }); + } + + /** + * Work out whether the whole set of sequences + * or just the selected set will be submitted for multiple alignment. + * + */ + private jalview.datamodel.AlignmentView gatherSequencesForAlignment() + { + // Now, check we have enough sequences + AlignmentView msa = null; + + if ( (viewport.getSelectionGroup() != null) && + (viewport.getSelectionGroup().getSize(false) > 1)) + { + // JBPNote UGLY! To prettify, make SequenceGroup and Alignment conform to some common interface! + /*SequenceGroup seqs = viewport.getSelectionGroup(); + int sz; + msa = new SequenceI[sz = seqs.getSize(false)]; + + for (int i = 0; i < sz; i++) + { + msa[i] = (SequenceI) seqs.getSequenceAt(i); + } */ + msa = viewport.getAlignmentView(true); + } + else + { + /*Vector seqs = viewport.getAlignment().getSequences(); + + if (seqs.size() > 1) + { + msa = new SequenceI[seqs.size()]; + + for (int i = 0; i < seqs.size(); i++) + { + msa[i] = (SequenceI) seqs.elementAt(i); + } + }*/ + msa = viewport.getAlignmentView(false); + } + return msa; + } + + /** + * Decides what is submitted to a secondary structure prediction service, + * the currently selected sequence, or the currently selected alignment + * (where the first sequence in the set is the one that the prediction + * will be for). + */ + AlignmentView gatherSeqOrMsaForSecStrPrediction() + { + AlignmentView seqs = null; + + if ( (viewport.getSelectionGroup() != null) && + (viewport.getSelectionGroup().getSize(false) > 0)) + { + seqs = viewport.getAlignmentView(true); + } + else + { + seqs = viewport.getAlignmentView(false); + } + // limit sequences - JBPNote in future - could spawn multiple prediction jobs + // TODO: viewport.alignment.isAligned is a global state - the local selection may well be aligned - we preserve 2.0.8 behaviour for moment. + if (!viewport.alignment.isAligned()) + { + seqs.setSequences(new SeqCigar[] { seqs.getSequences()[0] } ); + } + return seqs; + } + /** + * 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); + } + public TreePanel ShowNewickTree(NewickFile nf, String title, AlignmentView input) + { + return ShowNewickTree(nf,title, input, 600,500,4,5); + } + public TreePanel ShowNewickTree(NewickFile nf, String title, int w,int h,int x, int y) { + return ShowNewickTree(nf, title, null, w, h, x, y); } + /** + * Add a treeviewer for the tree extracted from a newick file object to the current alignment view + * + * @param nf the tree + * @param title tree viewer title + * @param input Associated alignment input data (or null) + * @param w width + * @param h height + * @param x position + * @param y position + * @return TreePanel handle + */ + public TreePanel ShowNewickTree(NewickFile nf, String title, AlignmentView input, int w,int h,int x, int y) { + TreePanel tp = null; + try + { + nf.parse(); - public void BLOSUM62Colour_actionPerformed(ActionEvent e) - { - changeColour(new Blosum62ColourScheme() ); - } + if (nf.getTree() != null) + { + tp = new TreePanel(alignPanel, + "FromFile", + title, + nf, input); + tp.setSize(w,h); + if(x>0 && y>0) + tp.setLocation(x,y); - public void sortPairwiseMenuItem_actionPerformed(ActionEvent e) - { - addHistoryItem(new HistoryItem("Pairwise Sort", viewport.alignment, HistoryItem.SORT)); - AlignmentSorter.sortByPID(viewport.getAlignment(), viewport.getAlignment().getSequenceAt(0)); - alignPanel.repaint(); - } - public void sortIDMenuItem_actionPerformed(ActionEvent e) - { - addHistoryItem(new HistoryItem("ID Sort", viewport.alignment, HistoryItem.SORT)); - AlignmentSorter.sortByID( viewport.getAlignment() ); - alignPanel.repaint(); - } + Desktop.addInternalFrame(tp, title, w, h); + addTreeMenuItem(tp, title); + } + } + catch (Exception ex) + { + ex.printStackTrace(); + } - public void sortGroupMenuItem_actionPerformed(ActionEvent e) - { - addHistoryItem(new HistoryItem("Group Sort", viewport.alignment, HistoryItem.SORT)); - AlignmentSorter.sortByGroup(viewport.getAlignment()); - AlignmentSorter.sortGroups(viewport.getAlignment()); - alignPanel.repaint(); + return tp; } - public void removeRedundancyMenuItem_actionPerformed(ActionEvent e) + class PrintThread + extends Thread { - RedundancyPanel sp = new RedundancyPanel(alignPanel); - JInternalFrame frame = new JInternalFrame(); - frame.setContentPane(sp); - Desktop.addInternalFrame(frame, "Redundancy threshold selection", 400, 100, false); + public void run() + { + PrinterJob printJob = PrinterJob.getPrinterJob(); + PageFormat pf = printJob.pageDialog(printJob.defaultPage()); + printJob.setPrintable(alignPanel, pf); + if (printJob.printDialog()) + { + try + { + printJob.print(); + } + catch (Exception PrintException) + { + PrintException.printStackTrace(); + } + } + } } - public void pairwiseAlignmentMenuItem_actionPerformed(ActionEvent e) + /** + * Generates menu items and listener event actions for web service clients + * + */ + public void BuildWebServiceMenu() { - if(viewport.getSelectionGroup().getSize()<2) - JOptionPane.showInternalMessageDialog(this, "You must select at least 2 sequences.", "Invalid Selection", JOptionPane.WARNING_MESSAGE); + 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(); + final AlignFrame af = this; + 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) + { + AlignmentView msa = gatherSequencesForAlignment(); + new jalview.ws.MsaWSClient(sh, title, msa, + false, true, viewport.getAlignment().getDataset(), af); + + } + + }); + 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) + { + AlignmentView msa = gatherSequencesForAlignment(); + new jalview.ws.MsaWSClient(sh, title, msa, + true, true, viewport.getAlignment().getDataset(), af); + + } + + }); + 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) + { + AlignmentView msa = gatherSeqOrMsaForSecStrPrediction(); + if (msa.getSequences().length == 1) + { + // Single Sequence prediction + new jalview.ws.JPredClient(sh, title, false, msa, af, true); + } + else + { + if (msa.getSequences().length > 1) + { + // Sequence profile based prediction + new jalview.ws.JPredClient(sh, + title, true, msa, af, true); + } + } + } + }); + 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 { - JInternalFrame frame = new JInternalFrame(); - frame.setContentPane(new PairwiseAlignPanel(viewport)); - Desktop.addInternalFrame(frame, "Pairwise Alignment", 600, 500); + 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 PCAMenuItem_actionPerformed(ActionEvent e) + /* public void vamsasStore_actionPerformed(ActionEvent e) { + JalviewFileChooser chooser = new JalviewFileChooser(jalview.bin.Cache. + getProperty("LAST_DIRECTORY")); - if( (viewport.getSelectionGroup()!=null && viewport.getSelectionGroup().getSize()<4 && viewport.getSelectionGroup().getSize()>0) - || viewport.getAlignment().getHeight()<4) - { - JOptionPane.showInternalMessageDialog(this, "Principal component analysis must take\n" - +"at least 4 input sequences.", - "Sequence selection insufficient", - JOptionPane.WARNING_MESSAGE); - return; - } + chooser.setFileView(new JalviewFileView()); + chooser.setDialogTitle("Export to Vamsas file"); + chooser.setToolTipText("Export"); - 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); - } + 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 averageDistanceTreeMenuItem_actionPerformed(ActionEvent e) - { - NewTreePanel("AV", "PID", "Average distance tree using PID"); - } - public void neighbourTreeMenuItem_actionPerformed(ActionEvent e) - { - NewTreePanel("NJ", "PID", "Neighbour joining tree using PID"); - } +public void showTranslation_actionPerformed(ActionEvent e) +{ + SequenceI [] selection = viewport.getSelectionAsNewSequence(); + String [] seqstring = viewport.getViewAsString(true); - protected void njTreeBlosumMenuItem_actionPerformed(ActionEvent e) - { - NewTreePanel("NJ", "BL", "Neighbour joining tree using BLOSUM62"); - } + int s, sSize = selection.length; + SequenceI [] newSeq = new SequenceI[sSize]; - protected void avTreeBlosumMenuItem_actionPerformed(ActionEvent e) + int res, resSize; + StringBuffer protein; + String seq; + for(s=0; s 3) - { - tp = new TreePanel(viewport, viewport.getSelectionGroup().sequences, type, - pwType, - 0, viewport.alignment.getWidth()); - } - else - { - tp = new TreePanel(viewport, viewport.getAlignment().getSequences(), - type, pwType, 0, viewport.alignment.getWidth()); - } - addTreeMenuItem(tp, title); + AlignmentI al = new Alignment(newSeq); + al.setDataset(null); - Desktop.addInternalFrame(tp, title, 600, 500); - } - public void addSortByOrderMenuItem(String title, final AlignmentOrder order) { - final JMenuItem item = new JMenuItem("by "+title); - sort.add(item); - item.addActionListener(new java.awt.event.ActionListener() + //////////////////////////////// + // Copy annotations across + jalview.datamodel.AlignmentAnnotation[] annotations + = viewport.alignment.getAlignmentAnnotation(); + int a, aSize; + if(annotations!=null) + { + for (int i = 0; i < annotations.length; i++) { - public void actionPerformed(ActionEvent e) + if (annotations[i].label.equals("Quality") || + annotations[i].label.equals("Conservation") || + annotations[i].label.equals("Consensus")) { - 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(); + continue; } - }); + + aSize = viewport.alignment.getWidth() / 3; + jalview.datamodel.Annotation[] anots = + new jalview.datamodel.Annotation[aSize]; + + for (a = 0; a < viewport.alignment.getWidth(); a++) + { + if (annotations[i].annotations[a] == null + || annotations[i].annotations[a] == null) + continue; + + anots[a / 3] = new Annotation( + annotations[i].annotations[a].displayCharacter, + annotations[i].annotations[a].description, + annotations[i].annotations[a].secondaryStructure, + annotations[i].annotations[a].value, + annotations[i].annotations[a].colour); + } + + jalview.datamodel.AlignmentAnnotation aa + = new jalview.datamodel.AlignmentAnnotation(annotations[i].label, + annotations[i].description, anots); + al.addAnnotation(aa); + } } - void addTreeMenuItem(final TreePanel treePanel, String title) - { - final JMenuItem item = new JMenuItem(title); + AlignFrame af = new AlignFrame(al, DEFAULT_WIDTH, DEFAULT_HEIGHT); + Desktop.addInternalFrame(af, "Translation of "+this.getTitle(), + DEFAULT_WIDTH, + DEFAULT_HEIGHT); - 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); - }; - }); +} - } +/** + * DOCUMENT ME! + * + * @param String DOCUMENT ME! + */ +public boolean parseFeaturesFile(String file, String type) +{ + boolean featuresFile = false; + try{ + featuresFile = new FeaturesFile(file, type).parse(viewport.alignment.getDataset(), + alignPanel.seqPanel.seqCanvas. + getFeatureRenderer().featureColours, + false); + } + catch(Exception ex) + { + ex.printStackTrace(); + } + if(featuresFile) + { + viewport.showSequenceFeatures = true; + showSeqFeatures.setSelected(true); + alignPanel.repaint(); + } - public void clustalAlignMenuItem_actionPerformed(ActionEvent e) - { - // TODO:resolve which menu item was actually selected - // 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); - } + return featuresFile; +} - } - else - { - Vector seqs = viewport.getAlignment().getSequences(); +public void dragEnter(DropTargetDragEvent evt) +{} - if (seqs.size() > 1) { - msa = new SequenceI[seqs.size()]; - for (int i = 0; i < seqs.size(); i++) - { - msa[i] = (SequenceI) seqs.elementAt(i); - } +public void dragExit(DropTargetEvent evt) +{} - } +public void dragOver(DropTargetDragEvent evt) +{} - } - if (msa!=null) { - jalview.ws.MsaWSClient ct = new jalview.ws.MsaWSClient("ClustalWS", title, msa, true, true); - } - } +public void dropActionChanged(DropTargetDragEvent evt) +{} - protected void jpred_actionPerformed(ActionEvent e) +public void drop(DropTargetDropEvent evt) { + Transferable t = evt.getTransferable(); + java.util.List files = null; - if (viewport.getSelectionGroup() != null && viewport.getSelectionGroup().getSize()>0) + try { - // JBPNote UGLY! To prettify, make SequenceGroup and Alignment conform to some common interface! - SequenceGroup seqs = viewport.getSelectionGroup(); - if (seqs.getSize() == 1 || !viewport.alignment.isAligned()) + DataFlavor uriListFlavor = new DataFlavor("text/uri-list;class=java.lang.String"); + if (t.isDataFlavorSupported(DataFlavor.javaFileListFlavor)) { - JPredClient ct = new JPredClient( (SequenceI)seqs.getSequenceAt(0)); + //Works on Windows and MacOSX + evt.acceptDrop(DnDConstants.ACTION_COPY_OR_MOVE); + files = (java.util.List) t.getTransferData(DataFlavor.javaFileListFlavor); } - else + else if (t.isDataFlavorSupported(uriListFlavor)) { - int sz; - SequenceI[] msa = new SequenceI[sz=seqs.getSize()]; - for (int i = 0; i < sz; i++) + // This is used by Unix drag system + evt.acceptDrop(DnDConstants.ACTION_COPY_OR_MOVE); + String data = (String) t.getTransferData(uriListFlavor); + files = new java.util.ArrayList(1); + for (java.util.StringTokenizer st = new java.util.StringTokenizer( + data, + "\r\n"); + st.hasMoreTokens(); ) { - msa[i] = (SequenceI) seqs.getSequenceAt(i); - } + String s = st.nextToken(); + if (s.startsWith("#")) + { + // the line is a comment (as per the RFC 2483) + continue; + } - JPredClient ct = new JPredClient(title, msa); + java.net.URI uri = new java.net.URI(s); + java.io.File file = new java.io.File(uri); + files.add(file); + } } - } - else + catch (Exception e) { - Vector seqs = viewport.getAlignment().getSequences(); - - if (seqs.size() == 1 || !viewport.alignment.isAligned()) - { - JPredClient ct = new JPredClient( (SequenceI) - seqs.elementAt(0)); - } - else + e.printStackTrace(); + } + if (files != null) + { + try { - SequenceI[] msa = new SequenceI[seqs.size()]; - for (int i = 0; i < seqs.size(); i++) + + for (int i = 0; i < files.size(); i++) { - msa[i] = (SequenceI) seqs.elementAt(i); + loadJalviewDataFile(files.get(i).toString()); } - - JPredClient ct = new JPredClient(title, msa); } - + catch (Exception ex) + { + ex.printStackTrace(); + } } - } - protected void msaAlignMenuItem_actionPerformed(ActionEvent e) +} + + // This method will attempt to load a "dropped" file first by testing + // whether its and Annotation file, then features file. If both are + // false then the user may have dropped an alignment file onto this + // AlignFrame + public void loadJalviewDataFile(String file) { - // TODO:resolve which menu item was actually selected - // Now, check we have enough sequences - SequenceI[] msa=null; - if (viewport.getSelectionGroup() != null && viewport.getSelectionGroup().getSize()>1) + try{ + String protocol = "File"; + + if (file.indexOf("http:") > -1 || file.indexOf("file:") > -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); - } + protocol = "URL"; + } + boolean isAnnotation = new AnnotationFile().readAnnotationFile(viewport. + alignment, file); - } - else + if (!isAnnotation) { - Vector seqs = viewport.getAlignment().getSequences(); + boolean isGroupsFile = parseFeaturesFile(file,protocol); + if (!isGroupsFile) + { + String format = new IdentifyFile().Identify(file, protocol); - if (seqs.size() > 1) { - msa = new SequenceI[seqs.size()]; - for (int i = 0; i < seqs.size(); i++) + if(format.equalsIgnoreCase("JnetFile")) { - msa[i] = (SequenceI) seqs.elementAt(i); + jalview.io.JPredFile predictions = new jalview.io.JPredFile( + file, protocol); + new JnetAnnotationMaker().add_annotation(predictions, + viewport.getAlignment(), + 0, false); + alignPanel.adjustAnnotationHeight(); + alignPanel.repaint(); } - + else + new FileLoader().LoadFile(viewport, file, protocol, format); } - } - if (msa!=null) { - MsaWSClient ct = new jalview.ws.MsaWSClient("MuscleWS",title, msa, true, true); + else + { + // (isAnnotation) + alignPanel.adjustAnnotationHeight(); } + + }catch(Exception ex) + { + ex.printStackTrace(); + } } - 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) + + public void tabSelectionChanged(int index) + { + if (index > -1) { - String choice = chooser.getSelectedFile().getPath(); - jalview.bin.Cache.setProperty("LAST_DIRECTORY", choice); - try - { - jalview.io.NewickFile fin = new jalview.io.NewickFile(choice, "File"); - ShowNewickTree(fin, choice); - } - catch (Exception ex) - { - JOptionPane.showMessageDialog(Desktop.desktop, - "Problem reading tree file", - ex.getMessage(), - JOptionPane.WARNING_MESSAGE); - ex.printStackTrace(); - } + alignPanel = (AlignmentPanel) alignPanels.elementAt(index); + viewport = alignPanel.av; + setMenusFromViewport(viewport); } } - public void ShowNewickTree(NewickFile nf, String title) + public void tabbedPane_mousePressed(MouseEvent e) { - try{ - nf.parse(); - if (nf.getTree() != null) + if(SwingUtilities.isRightMouseButton(e)) + { + String reply = JOptionPane.showInternalInputDialog(this, + "Enter View Name", + "Edit View Name", + JOptionPane.QUESTION_MESSAGE); + + if (reply != null) { - TreePanel tp = new TreePanel(viewport, - viewport.getAlignment().getSequences(), - nf, "FromFile", title); - Desktop.addInternalFrame(tp, title, 600, 500); - addTreeMenuItem(tp, title); - viewport.setCurrentTree(tp.getTree()); + viewport.viewName = reply; + tabbedPane.setTitleAt( tabbedPane.getSelectedIndex() ,reply); } - }catch(Exception ex){ex.printStackTrace();} + } } + + public AlignViewport getCurrentView() + { + return viewport; + } }