2 * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8)
\r
3 * Copyright (C) 2012 J Procter, AM Waterhouse, LM Lui, J Engelhardt, G Barton, M Clamp, S Searle
\r
5 * This file is part of Jalview.
\r
7 * Jalview is free software: you can redistribute it and/or
\r
8 * modify it under the terms of the GNU General Public License
\r
9 * as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
\r
11 * Jalview is distributed in the hope that it will be useful, but
\r
12 * WITHOUT ANY WARRANTY; without even the implied warranty
\r
13 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
\r
14 * PURPOSE. See the GNU General Public License for more details.
\r
16 * You should have received a copy of the GNU General Public License along with Jalview. If not, see <http://www.gnu.org/licenses/>.
\r
18 package jalview.gui;
\r
20 import jalview.analysis.AAFrequency;
\r
21 import jalview.analysis.AlignmentSorter;
\r
22 import jalview.analysis.Conservation;
\r
23 import jalview.analysis.CrossRef;
\r
24 import jalview.analysis.NJTree;
\r
25 import jalview.analysis.ParseProperties;
\r
26 import jalview.analysis.SequenceIdMatcher;
\r
27 import jalview.api.AlignViewControllerI;
\r
28 import jalview.bin.Cache;
\r
29 import jalview.commands.CommandI;
\r
30 import jalview.commands.EditCommand;
\r
31 import jalview.commands.OrderCommand;
\r
32 import jalview.commands.RemoveGapColCommand;
\r
33 import jalview.commands.RemoveGapsCommand;
\r
34 import jalview.commands.SlideSequencesCommand;
\r
35 import jalview.commands.TrimRegionCommand;
\r
36 import jalview.datamodel.AlignedCodonFrame;
\r
37 import jalview.datamodel.Alignment;
\r
38 import jalview.datamodel.AlignmentAnnotation;
\r
39 import jalview.datamodel.AlignmentI;
\r
40 import jalview.datamodel.AlignmentOrder;
\r
41 import jalview.datamodel.AlignmentView;
\r
42 import jalview.datamodel.ColumnSelection;
\r
43 import jalview.datamodel.PDBEntry;
\r
44 import jalview.datamodel.SeqCigar;
\r
45 import jalview.datamodel.Sequence;
\r
46 import jalview.datamodel.SequenceGroup;
\r
47 import jalview.datamodel.SequenceI;
\r
48 import jalview.io.AlignmentProperties;
\r
49 import jalview.io.AnnotationFile;
\r
50 import jalview.io.FeaturesFile;
\r
51 import jalview.io.FileLoader;
\r
52 import jalview.io.FormatAdapter;
\r
53 import jalview.io.HTMLOutput;
\r
54 import jalview.io.IdentifyFile;
\r
55 import jalview.io.JalviewFileChooser;
\r
56 import jalview.io.JalviewFileView;
\r
57 import jalview.io.JnetAnnotationMaker;
\r
58 import jalview.io.NewickFile;
\r
59 import jalview.io.TCoffeeScoreFile;
\r
60 import jalview.jbgui.GAlignFrame;
\r
61 import jalview.schemes.Blosum62ColourScheme;
\r
62 import jalview.schemes.BuriedColourScheme;
\r
63 import jalview.schemes.ClustalxColourScheme;
\r
64 import jalview.schemes.ColourSchemeI;
\r
65 import jalview.schemes.ColourSchemeProperty;
\r
66 import jalview.schemes.HelixColourScheme;
\r
67 import jalview.schemes.HydrophobicColourScheme;
\r
68 import jalview.schemes.NucleotideColourScheme;
\r
69 import jalview.schemes.PIDColourScheme;
\r
70 import jalview.schemes.PurinePyrimidineColourScheme;
\r
71 import jalview.schemes.RNAHelicesColourChooser;
\r
72 import jalview.schemes.ResidueProperties;
\r
73 import jalview.schemes.StrandColourScheme;
\r
74 import jalview.schemes.TCoffeeColourScheme;
\r
75 import jalview.schemes.TaylorColourScheme;
\r
76 import jalview.schemes.TurnColourScheme;
\r
77 import jalview.schemes.UserColourScheme;
\r
78 import jalview.schemes.ZappoColourScheme;
\r
79 import jalview.util.MessageManager;
\r
80 import jalview.ws.jws1.Discoverer;
\r
81 import jalview.ws.jws2.Jws2Discoverer;
\r
82 import jalview.ws.jws2.jabaws2.Jws2Instance;
\r
83 import jalview.ws.seqfetcher.DbSourceProxy;
\r
85 import java.awt.BorderLayout;
\r
86 import java.awt.Color;
\r
87 import java.awt.Component;
\r
88 import java.awt.GridLayout;
\r
89 import java.awt.Rectangle;
\r
90 import java.awt.Toolkit;
\r
91 import java.awt.datatransfer.Clipboard;
\r
92 import java.awt.datatransfer.DataFlavor;
\r
93 import java.awt.datatransfer.StringSelection;
\r
94 import java.awt.datatransfer.Transferable;
\r
95 import java.awt.dnd.DnDConstants;
\r
96 import java.awt.dnd.DropTargetDragEvent;
\r
97 import java.awt.dnd.DropTargetDropEvent;
\r
98 import java.awt.dnd.DropTargetEvent;
\r
99 import java.awt.dnd.DropTargetListener;
\r
100 import java.awt.event.ActionEvent;
\r
101 import java.awt.event.ActionListener;
\r
102 import java.awt.event.KeyAdapter;
\r
103 import java.awt.event.KeyEvent;
\r
104 import java.awt.event.MouseAdapter;
\r
105 import java.awt.event.MouseEvent;
\r
106 import java.awt.print.PageFormat;
\r
107 import java.awt.print.PrinterJob;
\r
108 import java.beans.PropertyChangeEvent;
\r
109 import java.io.File;
\r
110 import java.net.URL;
\r
111 import java.util.ArrayList;
\r
112 import java.util.Enumeration;
\r
113 import java.util.Hashtable;
\r
114 import java.util.List;
\r
115 import java.util.Vector;
\r
117 import javax.swing.JButton;
\r
118 import javax.swing.JEditorPane;
\r
119 import javax.swing.JInternalFrame;
\r
120 import javax.swing.JLabel;
\r
121 import javax.swing.JLayeredPane;
\r
122 import javax.swing.JMenu;
\r
123 import javax.swing.JMenuItem;
\r
124 import javax.swing.JOptionPane;
\r
125 import javax.swing.JPanel;
\r
126 import javax.swing.JProgressBar;
\r
127 import javax.swing.JRadioButtonMenuItem;
\r
128 import javax.swing.JScrollPane;
\r
129 import javax.swing.SwingUtilities;
\r
135 * @version $Revision$
\r
137 public class AlignFrame extends GAlignFrame implements DropTargetListener,
\r
141 /** DOCUMENT ME!! */
\r
142 public static final int DEFAULT_WIDTH = 700;
\r
144 /** DOCUMENT ME!! */
\r
145 public static final int DEFAULT_HEIGHT = 500;
\r
147 public AlignmentPanel alignPanel;
\r
149 AlignViewport viewport;
\r
151 public AlignViewControllerI avc;
\r
154 Vector alignPanels = new Vector();
\r
157 * Last format used to load or save alignments in this window
\r
159 String currentFileFormat = null;
\r
162 * Current filename for this alignment
\r
164 String fileName = null;
\r
167 * Creates a new AlignFrame object with specific width and height.
\r
173 public AlignFrame(AlignmentI al, int width, int height)
\r
175 this(al, null, width, height);
\r
179 * Creates a new AlignFrame object with specific width, height and
\r
185 * @param sequenceSetId
\r
187 public AlignFrame(AlignmentI al, int width, int height,
\r
188 String sequenceSetId)
\r
190 this(al, null, width, height, sequenceSetId);
\r
194 * Creates a new AlignFrame object with specific width, height and
\r
200 * @param sequenceSetId
\r
203 public AlignFrame(AlignmentI al, int width, int height,
\r
204 String sequenceSetId, String viewId)
\r
206 this(al, null, width, height, sequenceSetId, viewId);
\r
210 * new alignment window with hidden columns
\r
214 * @param hiddenColumns
\r
215 * ColumnSelection or null
\r
217 * Width of alignment frame
\r
221 public AlignFrame(AlignmentI al, ColumnSelection hiddenColumns,
\r
222 int width, int height)
\r
224 this(al, hiddenColumns, width, height, null);
\r
228 * Create alignment frame for al with hiddenColumns, a specific width and
\r
229 * height, and specific sequenceId
\r
232 * @param hiddenColumns
\r
235 * @param sequenceSetId
\r
238 public AlignFrame(AlignmentI al, ColumnSelection hiddenColumns,
\r
239 int width, int height, String sequenceSetId)
\r
241 this(al, hiddenColumns, width, height, sequenceSetId, null);
\r
245 * Create alignment frame for al with hiddenColumns, a specific width and
\r
246 * height, and specific sequenceId
\r
249 * @param hiddenColumns
\r
252 * @param sequenceSetId
\r
257 public AlignFrame(AlignmentI al, ColumnSelection hiddenColumns,
\r
258 int width, int height, String sequenceSetId, String viewId)
\r
260 setSize(width, height);
\r
261 viewport = new AlignViewport(al, hiddenColumns, sequenceSetId, viewId);
\r
263 alignPanel = new AlignmentPanel(this, viewport);
\r
265 if (al.getDataset() == null)
\r
267 al.setDataset(null);
\r
270 addAlignmentPanel(alignPanel, true);
\r
275 * Make a new AlignFrame from exisiting alignmentPanels
\r
282 public AlignFrame(AlignmentPanel ap)
\r
286 addAlignmentPanel(ap, false);
\r
291 * initalise the alignframe from the underlying viewport data and the
\r
296 avc = new jalview.controller.AlignViewController(viewport, alignPanel);
\r
297 if (viewport.getAlignmentConservationAnnotation() == null)
\r
299 BLOSUM62Colour.setEnabled(false);
\r
300 conservationMenuItem.setEnabled(false);
\r
301 modifyConservation.setEnabled(false);
\r
302 // PIDColour.setEnabled(false);
\r
303 // abovePIDThreshold.setEnabled(false);
\r
304 // modifyPID.setEnabled(false);
\r
307 String sortby = jalview.bin.Cache.getDefault("SORT_ALIGNMENT",
\r
310 if (sortby.equals("Id"))
\r
312 sortIDMenuItem_actionPerformed(null);
\r
314 else if (sortby.equals("Pairwise Identity"))
\r
316 sortPairwiseMenuItem_actionPerformed(null);
\r
319 if (Desktop.desktop != null)
\r
321 this.setDropTarget(new java.awt.dnd.DropTarget(this, this));
\r
322 addServiceListeners();
\r
323 setGUINucleotide(viewport.getAlignment().isNucleotide());
\r
326 setMenusFromViewport(viewport);
\r
327 buildSortByAnnotationScoresMenu();
\r
328 if (viewport.wrapAlignment)
\r
330 wrapMenuItem_actionPerformed(null);
\r
333 if (jalview.bin.Cache.getDefault("SHOW_OVERVIEW", false))
\r
335 this.overviewMenuItem_actionPerformed(null);
\r
343 * Change the filename and format for the alignment, and enable the 'reload'
\r
344 * button functionality.
\r
351 public void setFileName(String file, String format)
\r
354 currentFileFormat = format;
\r
355 reload.setEnabled(true);
\r
358 void addKeyListener()
\r
360 addKeyListener(new KeyAdapter()
\r
363 public void keyPressed(KeyEvent evt)
\r
365 if (viewport.cursorMode
\r
366 && ((evt.getKeyCode() >= KeyEvent.VK_0 && evt.getKeyCode() <= KeyEvent.VK_9) || (evt
\r
367 .getKeyCode() >= KeyEvent.VK_NUMPAD0 && evt
\r
368 .getKeyCode() <= KeyEvent.VK_NUMPAD9))
\r
369 && Character.isDigit(evt.getKeyChar()))
\r
370 alignPanel.seqPanel.numberPressed(evt.getKeyChar());
\r
372 switch (evt.getKeyCode())
\r
375 case 27: // escape key
\r
376 deselectAllSequenceMenuItem_actionPerformed(null);
\r
380 case KeyEvent.VK_DOWN:
\r
381 if (evt.isAltDown() || !viewport.cursorMode)
\r
382 moveSelectedSequences(false);
\r
383 if (viewport.cursorMode)
\r
384 alignPanel.seqPanel.moveCursor(0, 1);
\r
387 case KeyEvent.VK_UP:
\r
388 if (evt.isAltDown() || !viewport.cursorMode)
\r
389 moveSelectedSequences(true);
\r
390 if (viewport.cursorMode)
\r
391 alignPanel.seqPanel.moveCursor(0, -1);
\r
395 case KeyEvent.VK_LEFT:
\r
396 if (evt.isAltDown() || !viewport.cursorMode)
\r
397 slideSequences(false, alignPanel.seqPanel.getKeyboardNo1());
\r
399 alignPanel.seqPanel.moveCursor(-1, 0);
\r
403 case KeyEvent.VK_RIGHT:
\r
404 if (evt.isAltDown() || !viewport.cursorMode)
\r
405 slideSequences(true, alignPanel.seqPanel.getKeyboardNo1());
\r
407 alignPanel.seqPanel.moveCursor(1, 0);
\r
410 case KeyEvent.VK_SPACE:
\r
411 if (viewport.cursorMode)
\r
413 alignPanel.seqPanel.insertGapAtCursor(evt.isControlDown()
\r
414 || evt.isShiftDown() || evt.isAltDown());
\r
418 // case KeyEvent.VK_A:
\r
419 // if (viewport.cursorMode)
\r
421 // alignPanel.seqPanel.insertNucAtCursor(false,"A");
\r
422 // //System.out.println("A");
\r
426 * case KeyEvent.VK_CLOSE_BRACKET: if (viewport.cursorMode) {
\r
427 * System.out.println("closing bracket"); } break;
\r
429 case KeyEvent.VK_DELETE:
\r
430 case KeyEvent.VK_BACK_SPACE:
\r
431 if (!viewport.cursorMode)
\r
433 cut_actionPerformed(null);
\r
437 alignPanel.seqPanel.deleteGapAtCursor(evt.isControlDown()
\r
438 || evt.isShiftDown() || evt.isAltDown());
\r
443 case KeyEvent.VK_S:
\r
444 if (viewport.cursorMode)
\r
446 alignPanel.seqPanel.setCursorRow();
\r
449 case KeyEvent.VK_C:
\r
450 if (viewport.cursorMode && !evt.isControlDown())
\r
452 alignPanel.seqPanel.setCursorColumn();
\r
455 case KeyEvent.VK_P:
\r
456 if (viewport.cursorMode)
\r
458 alignPanel.seqPanel.setCursorPosition();
\r
462 case KeyEvent.VK_ENTER:
\r
463 case KeyEvent.VK_COMMA:
\r
464 if (viewport.cursorMode)
\r
466 alignPanel.seqPanel.setCursorRowAndColumn();
\r
470 case KeyEvent.VK_Q:
\r
471 if (viewport.cursorMode)
\r
473 alignPanel.seqPanel.setSelectionAreaAtCursor(true);
\r
476 case KeyEvent.VK_M:
\r
477 if (viewport.cursorMode)
\r
479 alignPanel.seqPanel.setSelectionAreaAtCursor(false);
\r
483 case KeyEvent.VK_F2:
\r
484 viewport.cursorMode = !viewport.cursorMode;
\r
485 statusBar.setText(MessageManager.formatMessage("label.keyboard_editing_mode", new String[]{(viewport.cursorMode ? "on" : "off")}));
\r
486 if (viewport.cursorMode)
\r
488 alignPanel.seqPanel.seqCanvas.cursorX = viewport.startRes;
\r
489 alignPanel.seqPanel.seqCanvas.cursorY = viewport.startSeq;
\r
491 alignPanel.seqPanel.seqCanvas.repaint();
\r
494 case KeyEvent.VK_F1:
\r
497 ClassLoader cl = jalview.gui.Desktop.class.getClassLoader();
\r
498 java.net.URL url = javax.help.HelpSet.findHelpSet(cl,
\r
500 javax.help.HelpSet hs = new javax.help.HelpSet(cl, url);
\r
502 javax.help.HelpBroker hb = hs.createHelpBroker();
\r
503 hb.setCurrentID("home");
\r
504 hb.setDisplayed(true);
\r
505 } catch (Exception ex)
\r
507 ex.printStackTrace();
\r
510 case KeyEvent.VK_H:
\r
512 boolean toggleSeqs = !evt.isControlDown();
\r
513 boolean toggleCols = !evt.isShiftDown();
\r
514 toggleHiddenRegions(toggleSeqs, toggleCols);
\r
517 case KeyEvent.VK_PAGE_UP:
\r
518 if (viewport.wrapAlignment)
\r
520 alignPanel.scrollUp(true);
\r
524 alignPanel.setScrollValues(viewport.startRes, viewport.startSeq
\r
525 - viewport.endSeq + viewport.startSeq);
\r
528 case KeyEvent.VK_PAGE_DOWN:
\r
529 if (viewport.wrapAlignment)
\r
531 alignPanel.scrollUp(false);
\r
535 alignPanel.setScrollValues(viewport.startRes, viewport.startSeq
\r
536 + viewport.endSeq - viewport.startSeq);
\r
543 public void keyReleased(KeyEvent evt)
\r
545 switch (evt.getKeyCode())
\r
547 case KeyEvent.VK_LEFT:
\r
548 if (evt.isAltDown() || !viewport.cursorMode)
\r
549 viewport.firePropertyChange("alignment", null, viewport
\r
550 .getAlignment().getSequences());
\r
553 case KeyEvent.VK_RIGHT:
\r
554 if (evt.isAltDown() || !viewport.cursorMode)
\r
555 viewport.firePropertyChange("alignment", null, viewport
\r
556 .getAlignment().getSequences());
\r
563 public void addAlignmentPanel(final AlignmentPanel ap, boolean newPanel)
\r
565 ap.alignFrame = this;
\r
566 avc = new jalview.controller.AlignViewController(viewport, alignPanel);
\r
568 alignPanels.addElement(ap);
\r
570 PaintRefresher.Register(ap, ap.av.getSequenceSetId());
\r
572 int aSize = alignPanels.size();
\r
574 tabbedPane.setVisible(aSize > 1 || ap.av.viewName != null);
\r
576 if (aSize == 1 && ap.av.viewName == null)
\r
578 this.getContentPane().add(ap, BorderLayout.CENTER);
\r
584 setInitialTabVisible();
\r
587 expandViews.setEnabled(true);
\r
588 gatherViews.setEnabled(true);
\r
589 tabbedPane.addTab(ap.av.viewName, ap);
\r
591 ap.setVisible(false);
\r
596 if (ap.av.isPadGaps())
\r
598 ap.av.getAlignment().padGaps();
\r
600 ap.av.updateConservation(ap);
\r
601 ap.av.updateConsensus(ap);
\r
602 ap.av.updateStrucConsensus(ap);
\r
606 public void setInitialTabVisible()
\r
608 expandViews.setEnabled(true);
\r
609 gatherViews.setEnabled(true);
\r
610 tabbedPane.setVisible(true);
\r
611 AlignmentPanel first = (AlignmentPanel) alignPanels.firstElement();
\r
612 tabbedPane.addTab(first.av.viewName, first);
\r
613 this.getContentPane().add(tabbedPane, BorderLayout.CENTER);
\r
616 public AlignViewport getViewport()
\r
621 /* Set up intrinsic listeners for dynamically generated GUI bits. */
\r
622 private void addServiceListeners()
\r
624 final java.beans.PropertyChangeListener thisListener;
\r
625 Desktop.instance.addJalviewPropertyChangeListener("services",
\r
626 thisListener = new java.beans.PropertyChangeListener()
\r
629 public void propertyChange(PropertyChangeEvent evt)
\r
631 // // System.out.println("Discoverer property change.");
\r
632 // if (evt.getPropertyName().equals("services"))
\r
634 SwingUtilities.invokeLater(new Runnable()
\r
641 .println("Rebuild WS Menu for service change");
\r
642 BuildWebServiceMenu();
\r
649 addInternalFrameListener(new javax.swing.event.InternalFrameAdapter()
\r
652 public void internalFrameClosed(
\r
653 javax.swing.event.InternalFrameEvent evt)
\r
655 System.out.println("deregistering discoverer listener");
\r
656 Desktop.instance.removeJalviewPropertyChangeListener("services",
\r
658 closeMenuItem_actionPerformed(true);
\r
661 // Finally, build the menu once to get current service state
\r
662 new Thread(new Runnable()
\r
667 BuildWebServiceMenu();
\r
672 public void setGUINucleotide(boolean nucleotide)
\r
674 showTranslation.setVisible(nucleotide);
\r
675 conservationMenuItem.setEnabled(!nucleotide);
\r
676 modifyConservation.setEnabled(!nucleotide);
\r
677 showGroupConservation.setEnabled(!nucleotide);
\r
678 rnahelicesColour.setEnabled(nucleotide);
\r
679 purinePyrimidineColour.setEnabled(nucleotide);
\r
680 // Remember AlignFrame always starts as protein
\r
681 // if (!nucleotide)
\r
684 // calculateMenu.remove(calculateMenu.getItemCount() - 2);
\r
689 * set up menus for the currently viewport. This may be called after any
\r
690 * operation that affects the data in the current view (selection changed,
\r
691 * etc) to update the menus to reflect the new state.
\r
693 public void setMenusForViewport()
\r
695 setMenusFromViewport(viewport);
\r
699 * Need to call this method when tabs are selected for multiple views, or when
\r
700 * loading from Jalview2XML.java
\r
705 void setMenusFromViewport(AlignViewport av)
\r
707 padGapsMenuitem.setSelected(av.isPadGaps());
\r
708 colourTextMenuItem.setSelected(av.showColourText);
\r
709 abovePIDThreshold.setSelected(av.getAbovePIDThreshold());
\r
710 conservationMenuItem.setSelected(av.getConservationSelected());
\r
711 seqLimits.setSelected(av.getShowJVSuffix());
\r
712 idRightAlign.setSelected(av.rightAlignIds);
\r
713 centreColumnLabelsMenuItem.setState(av.centreColumnLabels);
\r
714 renderGapsMenuItem.setSelected(av.renderGaps);
\r
715 wrapMenuItem.setSelected(av.wrapAlignment);
\r
716 scaleAbove.setVisible(av.wrapAlignment);
\r
717 scaleLeft.setVisible(av.wrapAlignment);
\r
718 scaleRight.setVisible(av.wrapAlignment);
\r
719 annotationPanelMenuItem.setState(av.showAnnotation);
\r
720 viewBoxesMenuItem.setSelected(av.showBoxes);
\r
721 viewTextMenuItem.setSelected(av.showText);
\r
722 showNonconservedMenuItem.setSelected(av.getShowUnconserved());
\r
723 showGroupConsensus.setSelected(av.isShowGroupConsensus());
\r
724 showGroupConservation.setSelected(av.isShowGroupConservation());
\r
725 showConsensusHistogram.setSelected(av.isShowConsensusHistogram());
\r
726 showSequenceLogo.setSelected(av.isShowSequenceLogo());
\r
727 normaliseSequenceLogo.setSelected(av.isNormaliseSequenceLogo());
\r
729 setColourSelected(ColourSchemeProperty.getColourName(av
\r
730 .getGlobalColourScheme()));
\r
732 showSeqFeatures.setSelected(av.showSequenceFeatures);
\r
733 hiddenMarkers.setState(av.showHiddenMarkers);
\r
734 applyToAllGroups.setState(av.getColourAppliesToAllGroups());
\r
735 showNpFeatsMenuitem.setSelected(av.isShowNpFeats());
\r
736 showDbRefsMenuitem.setSelected(av.isShowDbRefs());
\r
737 autoCalculate.setSelected(av.autoCalculateConsensus);
\r
738 sortByTree.setSelected(av.sortByTree);
\r
739 listenToViewSelections.setSelected(av.followSelection);
\r
740 rnahelicesColour.setEnabled(av.getAlignment().hasRNAStructure());
\r
742 .setSelected(av.getGlobalColourScheme() instanceof jalview.schemes.RNAHelicesColour);
\r
743 setShowProductsEnabled();
\r
744 updateEditMenuBar();
\r
747 // methods for implementing IProgressIndicator
\r
748 // need to refactor to a reusable stub class
\r
749 Hashtable progressBars, progressBarHandlers;
\r
754 * @see jalview.gui.IProgressIndicator#setProgressBar(java.lang.String, long)
\r
757 public void setProgressBar(String message, long id)
\r
759 if (progressBars == null)
\r
761 progressBars = new Hashtable();
\r
762 progressBarHandlers = new Hashtable();
\r
765 JPanel progressPanel;
\r
766 Long lId = new Long(id);
\r
767 GridLayout layout = (GridLayout) statusPanel.getLayout();
\r
768 if (progressBars.get(lId) != null)
\r
770 progressPanel = (JPanel) progressBars.get(new Long(id));
\r
771 statusPanel.remove(progressPanel);
\r
772 progressBars.remove(lId);
\r
773 progressPanel = null;
\r
774 if (message != null)
\r
776 statusBar.setText(message);
\r
778 if (progressBarHandlers.contains(lId))
\r
780 progressBarHandlers.remove(lId);
\r
782 layout.setRows(layout.getRows() - 1);
\r
786 progressPanel = new JPanel(new BorderLayout(10, 5));
\r
788 JProgressBar progressBar = new JProgressBar();
\r
789 progressBar.setIndeterminate(true);
\r
791 progressPanel.add(new JLabel(message), BorderLayout.WEST);
\r
792 progressPanel.add(progressBar, BorderLayout.CENTER);
\r
794 layout.setRows(layout.getRows() + 1);
\r
795 statusPanel.add(progressPanel);
\r
797 progressBars.put(lId, progressPanel);
\r
800 // setMenusForViewport();
\r
805 public void registerHandler(final long id,
\r
806 final IProgressIndicatorHandler handler)
\r
808 if (progressBarHandlers == null || !progressBars.contains(new Long(id)))
\r
811 "call setProgressBar before registering the progress bar's handler.");
\r
813 progressBarHandlers.put(new Long(id), handler);
\r
814 final JPanel progressPanel = (JPanel) progressBars.get(new Long(id));
\r
815 if (handler.canCancel())
\r
817 JButton cancel = new JButton(MessageManager.getString("action.cancel"));
\r
818 final IProgressIndicator us = this;
\r
819 cancel.addActionListener(new ActionListener()
\r
823 public void actionPerformed(ActionEvent e)
\r
825 handler.cancelActivity(id);
\r
828 + ((JLabel) progressPanel.getComponent(0))
\r
832 progressPanel.add(cancel, BorderLayout.EAST);
\r
838 * @return true if any progress bars are still active
\r
841 public boolean operationInProgress()
\r
843 if (progressBars != null && progressBars.size() > 0)
\r
851 * Added so Castor Mapping file can obtain Jalview Version
\r
853 public String getVersion()
\r
855 return jalview.bin.Cache.getProperty("VERSION");
\r
858 public FeatureRenderer getFeatureRenderer()
\r
860 return alignPanel.seqPanel.seqCanvas.getFeatureRenderer();
\r
864 public void fetchSequence_actionPerformed(ActionEvent e)
\r
866 new SequenceFetcher(this);
\r
870 public void addFromFile_actionPerformed(ActionEvent e)
\r
872 Desktop.instance.inputLocalFileMenuItem_actionPerformed(viewport);
\r
876 public void reload_actionPerformed(ActionEvent e)
\r
878 if (fileName != null)
\r
880 // TODO: JAL-1108 - ensure all associated frames are closed regardless of
\r
881 // originating file's format
\r
882 // TODO: work out how to recover feature settings for correct view(s) when
\r
883 // file is reloaded.
\r
884 if (currentFileFormat.equals("Jalview"))
\r
886 JInternalFrame[] frames = Desktop.desktop.getAllFrames();
\r
887 for (int i = 0; i < frames.length; i++)
\r
889 if (frames[i] instanceof AlignFrame && frames[i] != this
\r
890 && ((AlignFrame) frames[i]).fileName != null
\r
891 && ((AlignFrame) frames[i]).fileName.equals(fileName))
\r
895 frames[i].setSelected(true);
\r
896 Desktop.instance.closeAssociatedWindows();
\r
897 } catch (java.beans.PropertyVetoException ex)
\r
903 Desktop.instance.closeAssociatedWindows();
\r
905 FileLoader loader = new FileLoader();
\r
906 String protocol = fileName.startsWith("http:") ? "URL" : "File";
\r
907 loader.LoadFile(viewport, fileName, protocol, currentFileFormat);
\r
911 Rectangle bounds = this.getBounds();
\r
913 FileLoader loader = new FileLoader();
\r
914 String protocol = fileName.startsWith("http:") ? "URL" : "File";
\r
915 AlignFrame newframe = loader.LoadFileWaitTillLoaded(fileName,
\r
916 protocol, currentFileFormat);
\r
918 newframe.setBounds(bounds);
\r
919 if (featureSettings != null && featureSettings.isShowing())
\r
921 final Rectangle fspos = featureSettings.frame.getBounds();
\r
922 // TODO: need a 'show feature settings' function that takes bounds -
\r
923 // need to refactor Desktop.addFrame
\r
924 newframe.featureSettings_actionPerformed(null);
\r
925 final FeatureSettings nfs = newframe.featureSettings;
\r
926 SwingUtilities.invokeLater(new Runnable()
\r
931 nfs.frame.setBounds(fspos);
\r
934 this.featureSettings.close();
\r
935 this.featureSettings = null;
\r
937 this.closeMenuItem_actionPerformed(true);
\r
943 public void addFromText_actionPerformed(ActionEvent e)
\r
945 Desktop.instance.inputTextboxMenuItem_actionPerformed(viewport);
\r
949 public void addFromURL_actionPerformed(ActionEvent e)
\r
951 Desktop.instance.inputURLMenuItem_actionPerformed(viewport);
\r
955 public void save_actionPerformed(ActionEvent e)
\r
957 if (fileName == null
\r
958 || (currentFileFormat == null || !jalview.io.FormatAdapter
\r
959 .isValidIOFormat(currentFileFormat, true))
\r
960 || fileName.startsWith("http"))
\r
962 saveAs_actionPerformed(null);
\r
966 saveAlignment(fileName, currentFileFormat);
\r
977 public void saveAs_actionPerformed(ActionEvent e)
\r
979 JalviewFileChooser chooser = new JalviewFileChooser(
\r
980 jalview.bin.Cache.getProperty("LAST_DIRECTORY"),
\r
981 jalview.io.AppletFormatAdapter.WRITABLE_EXTENSIONS,
\r
982 jalview.io.AppletFormatAdapter.WRITABLE_FNAMES,
\r
983 currentFileFormat, false);
\r
985 chooser.setFileView(new JalviewFileView());
\r
986 chooser.setDialogTitle("Save Alignment to file");
\r
987 chooser.setToolTipText(MessageManager.getString("action.save"));
\r
989 int value = chooser.showSaveDialog(this);
\r
991 if (value == JalviewFileChooser.APPROVE_OPTION)
\r
993 currentFileFormat = chooser.getSelectedFormat();
\r
994 if (currentFileFormat == null)
\r
996 JOptionPane.showInternalMessageDialog(Desktop.desktop,
\r
997 MessageManager.getString("label.select_file_format_before_saving"),
\r
998 MessageManager.getString("label.file_format_not_specified"), JOptionPane.WARNING_MESSAGE);
\r
999 value = chooser.showSaveDialog(this);
\r
1003 fileName = chooser.getSelectedFile().getPath();
\r
1005 jalview.bin.Cache.setProperty("DEFAULT_FILE_FORMAT",
\r
1006 currentFileFormat);
\r
1008 jalview.bin.Cache.setProperty("LAST_DIRECTORY", fileName);
\r
1009 if (currentFileFormat.indexOf(" ") > -1)
\r
1011 currentFileFormat = currentFileFormat.substring(0,
\r
1012 currentFileFormat.indexOf(" "));
\r
1014 saveAlignment(fileName, currentFileFormat);
\r
1018 public boolean saveAlignment(String file, String format)
\r
1020 boolean success = true;
\r
1022 if (format.equalsIgnoreCase("Jalview"))
\r
1024 String shortName = title;
\r
1026 if (shortName.indexOf(java.io.File.separatorChar) > -1)
\r
1028 shortName = shortName.substring(shortName
\r
1029 .lastIndexOf(java.io.File.separatorChar) + 1);
\r
1032 success = new Jalview2XML().SaveAlignment(this, file, shortName);
\r
1034 statusBar.setText(MessageManager.formatMessage("label.successfully_saved_to_file_in_format",new String[]{fileName, format}));
\r
1040 if (!jalview.io.AppletFormatAdapter.isValidFormat(format, true))
\r
1042 warningMessage("Cannot save file " + fileName + " using format "
\r
1043 + format, "Alignment output format not supported");
\r
1044 saveAs_actionPerformed(null);
\r
1045 // JBPNote need to have a raise_gui flag here
\r
1049 String[] omitHidden = null;
\r
1051 if (viewport.hasHiddenColumns())
\r
1053 int reply = JOptionPane
\r
1054 .showInternalConfirmDialog(
\r
1056 MessageManager.getString("label.alignment_contains_hidden_columns"),
\r
1057 MessageManager.getString("action.save_omit_hidden_columns"),
\r
1058 JOptionPane.YES_NO_OPTION,
\r
1059 JOptionPane.QUESTION_MESSAGE);
\r
1061 if (reply == JOptionPane.YES_OPTION)
\r
1063 omitHidden = viewport.getViewAsString(false);
\r
1066 FormatAdapter f = new FormatAdapter();
\r
1067 String output = f.formatSequences(format,
\r
1068 viewport.getAlignment(), // class cast exceptions will
\r
1069 // occur in the distant future
\r
1070 omitHidden, f.getCacheSuffixDefault(format),
\r
1071 viewport.getColumnSelection());
\r
1073 if (output == null)
\r
1081 java.io.PrintWriter out = new java.io.PrintWriter(
\r
1082 new java.io.FileWriter(file));
\r
1084 out.print(output);
\r
1086 this.setTitle(file);
\r
1087 statusBar.setText(MessageManager.formatMessage("label.successfully_saved_to_file_in_format",new String[]{fileName, format}));
\r
1088 } catch (Exception ex)
\r
1091 ex.printStackTrace();
\r
1098 JOptionPane.showInternalMessageDialog(this, MessageManager.formatMessage("label.couldnt_save_file", new String[]{fileName}),
\r
1099 MessageManager.getString("label.error_saving_file"), JOptionPane.WARNING_MESSAGE);
\r
1105 private void warningMessage(String warning, String title)
\r
1107 if (new jalview.util.Platform().isHeadless())
\r
1109 System.err.println("Warning: " + title + "\nWarning: " + warning);
\r
1114 JOptionPane.showInternalMessageDialog(this, warning, title,
\r
1115 JOptionPane.WARNING_MESSAGE);
\r
1127 protected void outputText_actionPerformed(ActionEvent e)
\r
1129 String[] omitHidden = null;
\r
1131 if (viewport.hasHiddenColumns())
\r
1133 int reply = JOptionPane
\r
1134 .showInternalConfirmDialog(
\r
1136 MessageManager.getString("label.alignment_contains_hidden_columns"),
\r
1137 MessageManager.getString("action.save_omit_hidden_columns"),
\r
1138 JOptionPane.YES_NO_OPTION,
\r
1139 JOptionPane.QUESTION_MESSAGE);
\r
1141 if (reply == JOptionPane.YES_OPTION)
\r
1143 omitHidden = viewport.getViewAsString(false);
\r
1147 CutAndPasteTransfer cap = new CutAndPasteTransfer();
\r
1148 cap.setForInput(null);
\r
1152 cap.setText(new FormatAdapter().formatSequences(e.getActionCommand(),
\r
1153 viewport.getAlignment(), omitHidden,
\r
1154 viewport.getColumnSelection()));
\r
1155 Desktop.addInternalFrame(cap,
\r
1156 MessageManager.formatMessage("label.alignment_output_command", new String[]{e.getActionCommand()}), 600, 500);
\r
1157 } catch (OutOfMemoryError oom)
\r
1159 new OOMWarning("Outputting alignment as " + e.getActionCommand(), oom);
\r
1172 protected void htmlMenuItem_actionPerformed(ActionEvent e)
\r
1174 new HTMLOutput(alignPanel,
\r
1175 alignPanel.seqPanel.seqCanvas.getSequenceRenderer(),
\r
1176 alignPanel.seqPanel.seqCanvas.getFeatureRenderer());
\r
1179 public void createImageMap(File file, String image)
\r
1181 alignPanel.makePNGImageMap(file, image);
\r
1191 public void createPNG(File f)
\r
1193 alignPanel.makePNG(f);
\r
1203 public void createEPS(File f)
\r
1205 alignPanel.makeEPS(f);
\r
1209 public void pageSetup_actionPerformed(ActionEvent e)
\r
1211 PrinterJob printJob = PrinterJob.getPrinterJob();
\r
1212 PrintThread.pf = printJob.pageDialog(printJob.defaultPage());
\r
1222 public void printMenuItem_actionPerformed(ActionEvent e)
\r
1224 // Putting in a thread avoids Swing painting problems
\r
1225 PrintThread thread = new PrintThread(alignPanel);
\r
1230 public void exportFeatures_actionPerformed(ActionEvent e)
\r
1232 new AnnotationExporter().exportFeatures(alignPanel);
\r
1236 public void exportAnnotations_actionPerformed(ActionEvent e)
\r
1238 new AnnotationExporter().exportAnnotations(alignPanel,
\r
1239 viewport.showAnnotation ? viewport.getAlignment()
\r
1240 .getAlignmentAnnotation() : null, viewport
\r
1241 .getAlignment().getGroups(), ((Alignment) viewport
\r
1242 .getAlignment()).alignmentProperties);
\r
1246 public void associatedData_actionPerformed(ActionEvent e)
\r
1248 // Pick the tree file
\r
1249 JalviewFileChooser chooser = new JalviewFileChooser(
\r
1250 jalview.bin.Cache.getProperty("LAST_DIRECTORY"));
\r
1251 chooser.setFileView(new JalviewFileView());
\r
1252 chooser.setDialogTitle(MessageManager.getString("label.load_jalview_annotations"));
\r
1253 chooser.setToolTipText(MessageManager.getString("label.load_jalview_annotations"));
\r
1255 int value = chooser.showOpenDialog(null);
\r
1257 if (value == JalviewFileChooser.APPROVE_OPTION)
\r
1259 String choice = chooser.getSelectedFile().getPath();
\r
1260 jalview.bin.Cache.setProperty("LAST_DIRECTORY", choice);
\r
1261 loadJalviewDataFile(choice, null, null, null);
\r
1267 * Close the current view or all views in the alignment frame. If the frame
\r
1268 * only contains one view then the alignment will be removed from memory.
\r
1270 * @param closeAllTabs
\r
1273 public void closeMenuItem_actionPerformed(boolean closeAllTabs)
\r
1275 if (alignPanels != null && alignPanels.size() < 2)
\r
1277 closeAllTabs = true;
\r
1282 if (alignPanels != null)
\r
1286 if (this.isClosed())
\r
1288 // really close all the windows - otherwise wait till
\r
1289 // setClosed(true) is called
\r
1290 for (int i = 0; i < alignPanels.size(); i++)
\r
1292 AlignmentPanel ap = (AlignmentPanel) alignPanels.elementAt(i);
\r
1299 closeView(alignPanel);
\r
1305 this.setClosed(true);
\r
1307 } catch (Exception ex)
\r
1309 ex.printStackTrace();
\r
1314 * close alignPanel2 and shuffle tabs appropriately.
\r
1316 * @param alignPanel2
\r
1318 public void closeView(AlignmentPanel alignPanel2)
\r
1320 int index = tabbedPane.getSelectedIndex();
\r
1321 int closedindex = tabbedPane.indexOfComponent(alignPanel2);
\r
1322 alignPanels.removeElement(alignPanel2);
\r
1324 // if (viewport == alignPanel2.av)
\r
1326 // viewport = null;
\r
1328 alignPanel2.closePanel();
\r
1329 alignPanel2 = null;
\r
1331 tabbedPane.removeTabAt(closedindex);
\r
1332 tabbedPane.validate();
\r
1334 if (index > closedindex || index == tabbedPane.getTabCount())
\r
1336 // modify currently selected tab index if necessary.
\r
1340 this.tabSelectionChanged(index);
\r
1346 void updateEditMenuBar()
\r
1349 if (viewport.historyList.size() > 0)
\r
1351 undoMenuItem.setEnabled(true);
\r
1352 CommandI command = (CommandI) viewport.historyList.peek();
\r
1353 undoMenuItem.setText(MessageManager.formatMessage("label.undo_command", new String[]{command.getDescription()}));
\r
1357 undoMenuItem.setEnabled(false);
\r
1358 undoMenuItem.setText(MessageManager.getString("action.undo"));
\r
1361 if (viewport.redoList.size() > 0)
\r
1363 redoMenuItem.setEnabled(true);
\r
1365 CommandI command = (CommandI) viewport.redoList.peek();
\r
1366 redoMenuItem.setText(MessageManager.formatMessage("label.redo_command", new String[]{command.getDescription()}));
\r
1370 redoMenuItem.setEnabled(false);
\r
1371 redoMenuItem.setText(MessageManager.getString("action.redo"));
\r
1375 public void addHistoryItem(CommandI command)
\r
1377 if (command.getSize() > 0)
\r
1379 viewport.historyList.push(command);
\r
1380 viewport.redoList.clear();
\r
1381 updateEditMenuBar();
\r
1382 viewport.updateHiddenColumns();
\r
1383 // viewport.hasHiddenColumns = (viewport.getColumnSelection() != null
\r
1384 // && viewport.getColumnSelection().getHiddenColumns() != null &&
\r
1385 // viewport.getColumnSelection()
\r
1386 // .getHiddenColumns().size() > 0);
\r
1392 * @return alignment objects for all views
\r
1394 AlignmentI[] getViewAlignments()
\r
1396 if (alignPanels != null)
\r
1398 Enumeration e = alignPanels.elements();
\r
1399 AlignmentI[] als = new AlignmentI[alignPanels.size()];
\r
1400 for (int i = 0; e.hasMoreElements(); i++)
\r
1402 als[i] = ((AlignmentPanel) e.nextElement()).av.getAlignment();
\r
1406 if (viewport != null)
\r
1408 return new AlignmentI[]
\r
1409 { viewport.getAlignment() };
\r
1421 protected void undoMenuItem_actionPerformed(ActionEvent e)
\r
1423 if (viewport.historyList.empty())
\r
1425 CommandI command = (CommandI) viewport.historyList.pop();
\r
1426 viewport.redoList.push(command);
\r
1427 command.undoCommand(getViewAlignments());
\r
1429 AlignViewport originalSource = getOriginatingSource(command);
\r
1430 updateEditMenuBar();
\r
1432 if (originalSource != null)
\r
1434 if (originalSource != viewport)
\r
1437 .warn("Implementation worry: mismatch of viewport origin for undo");
\r
1439 originalSource.updateHiddenColumns();
\r
1440 // originalSource.hasHiddenColumns = (viewport.getColumnSelection() !=
\r
1442 // && viewport.getColumnSelection().getHiddenColumns() != null &&
\r
1443 // viewport.getColumnSelection()
\r
1444 // .getHiddenColumns().size() > 0);
\r
1445 originalSource.firePropertyChange("alignment", null, originalSource
\r
1446 .getAlignment().getSequences());
\r
1457 protected void redoMenuItem_actionPerformed(ActionEvent e)
\r
1459 if (viewport.redoList.size() < 1)
\r
1464 CommandI command = (CommandI) viewport.redoList.pop();
\r
1465 viewport.historyList.push(command);
\r
1466 command.doCommand(getViewAlignments());
\r
1468 AlignViewport originalSource = getOriginatingSource(command);
\r
1469 updateEditMenuBar();
\r
1471 if (originalSource != null)
\r
1474 if (originalSource != viewport)
\r
1477 .warn("Implementation worry: mismatch of viewport origin for redo");
\r
1479 originalSource.updateHiddenColumns();
\r
1480 // originalSource.hasHiddenColumns = (viewport.getColumnSelection() !=
\r
1482 // && viewport.getColumnSelection().getHiddenColumns() != null &&
\r
1483 // viewport.getColumnSelection()
\r
1484 // .getHiddenColumns().size() > 0);
\r
1485 originalSource.firePropertyChange("alignment", null, originalSource
\r
1486 .getAlignment().getSequences());
\r
1490 AlignViewport getOriginatingSource(CommandI command)
\r
1492 AlignViewport originalSource = null;
\r
1493 // For sequence removal and addition, we need to fire
\r
1494 // the property change event FROM the viewport where the
\r
1495 // original alignment was altered
\r
1496 AlignmentI al = null;
\r
1497 if (command instanceof EditCommand)
\r
1499 EditCommand editCommand = (EditCommand) command;
\r
1500 al = editCommand.getAlignment();
\r
1501 Vector comps = (Vector) PaintRefresher.components.get(viewport
\r
1502 .getSequenceSetId());
\r
1504 for (int i = 0; i < comps.size(); i++)
\r
1506 if (comps.elementAt(i) instanceof AlignmentPanel)
\r
1508 if (al == ((AlignmentPanel) comps.elementAt(i)).av.getAlignment())
\r
1510 originalSource = ((AlignmentPanel) comps.elementAt(i)).av;
\r
1517 if (originalSource == null)
\r
1519 // The original view is closed, we must validate
\r
1520 // the current view against the closed view first
\r
1523 PaintRefresher.validateSequences(al, viewport.getAlignment());
\r
1526 originalSource = viewport;
\r
1529 return originalSource;
\r
1538 public void moveSelectedSequences(boolean up)
\r
1540 SequenceGroup sg = viewport.getSelectionGroup();
\r
1546 viewport.getAlignment().moveSelectedSequencesByOne(sg,
\r
1547 viewport.getHiddenRepSequences(), up);
\r
1548 alignPanel.paintAlignment(true);
\r
1551 synchronized void slideSequences(boolean right, int size)
\r
1553 List<SequenceI> sg = new Vector();
\r
1554 if (viewport.cursorMode)
\r
1556 sg.add(viewport.getAlignment().getSequenceAt(
\r
1557 alignPanel.seqPanel.seqCanvas.cursorY));
\r
1559 else if (viewport.getSelectionGroup() != null
\r
1560 && viewport.getSelectionGroup().getSize() != viewport
\r
1561 .getAlignment().getHeight())
\r
1563 sg = viewport.getSelectionGroup().getSequences(
\r
1564 viewport.getHiddenRepSequences());
\r
1567 if (sg.size() < 1)
\r
1572 Vector invertGroup = new Vector();
\r
1574 for (int i = 0; i < viewport.getAlignment().getHeight(); i++)
\r
1576 if (!sg.contains(viewport.getAlignment().getSequenceAt(i)))
\r
1577 invertGroup.add(viewport.getAlignment().getSequenceAt(i));
\r
1580 SequenceI[] seqs1 = sg.toArray(new SequenceI[0]);
\r
1582 SequenceI[] seqs2 = new SequenceI[invertGroup.size()];
\r
1583 for (int i = 0; i < invertGroup.size(); i++)
\r
1584 seqs2[i] = (SequenceI) invertGroup.elementAt(i);
\r
1586 SlideSequencesCommand ssc;
\r
1588 ssc = new SlideSequencesCommand("Slide Sequences", seqs2, seqs1,
\r
1589 size, viewport.getGapCharacter());
\r
1591 ssc = new SlideSequencesCommand("Slide Sequences", seqs1, seqs2,
\r
1592 size, viewport.getGapCharacter());
\r
1594 int groupAdjustment = 0;
\r
1595 if (ssc.getGapsInsertedBegin() && right)
\r
1597 if (viewport.cursorMode)
\r
1598 alignPanel.seqPanel.moveCursor(size, 0);
\r
1600 groupAdjustment = size;
\r
1602 else if (!ssc.getGapsInsertedBegin() && !right)
\r
1604 if (viewport.cursorMode)
\r
1605 alignPanel.seqPanel.moveCursor(-size, 0);
\r
1607 groupAdjustment = -size;
\r
1610 if (groupAdjustment != 0)
\r
1612 viewport.getSelectionGroup().setStartRes(
\r
1613 viewport.getSelectionGroup().getStartRes() + groupAdjustment);
\r
1614 viewport.getSelectionGroup().setEndRes(
\r
1615 viewport.getSelectionGroup().getEndRes() + groupAdjustment);
\r
1618 boolean appendHistoryItem = false;
\r
1619 if (viewport.historyList != null && viewport.historyList.size() > 0
\r
1620 && viewport.historyList.peek() instanceof SlideSequencesCommand)
\r
1622 appendHistoryItem = ssc
\r
1623 .appendSlideCommand((SlideSequencesCommand) viewport.historyList
\r
1627 if (!appendHistoryItem)
\r
1628 addHistoryItem(ssc);
\r
1640 protected void copy_actionPerformed(ActionEvent e)
\r
1643 if (viewport.getSelectionGroup() == null)
\r
1647 // TODO: preserve the ordering of displayed alignment annotation in any
\r
1648 // internal paste (particularly sequence associated annotation)
\r
1649 SequenceI[] seqs = viewport.getSelectionAsNewSequence();
\r
1650 String[] omitHidden = null;
\r
1652 if (viewport.hasHiddenColumns())
\r
1654 omitHidden = viewport.getViewAsString(true);
\r
1657 String output = new FormatAdapter().formatSequences("Fasta", seqs,
\r
1660 StringSelection ss = new StringSelection(output);
\r
1664 jalview.gui.Desktop.internalCopy = true;
\r
1665 // Its really worth setting the clipboard contents
\r
1666 // to empty before setting the large StringSelection!!
\r
1667 Toolkit.getDefaultToolkit().getSystemClipboard()
\r
1668 .setContents(new StringSelection(""), null);
\r
1670 Toolkit.getDefaultToolkit().getSystemClipboard()
\r
1671 .setContents(ss, Desktop.instance);
\r
1672 } catch (OutOfMemoryError er)
\r
1674 new OOMWarning("copying region", er);
\r
1678 Vector hiddenColumns = null;
\r
1679 if (viewport.hasHiddenColumns())
\r
1681 hiddenColumns = new Vector();
\r
1682 int hiddenOffset = viewport.getSelectionGroup().getStartRes(), hiddenCutoff = viewport
\r
1683 .getSelectionGroup().getEndRes();
\r
1684 for (int i = 0; i < viewport.getColumnSelection().getHiddenColumns()
\r
1687 int[] region = (int[]) viewport.getColumnSelection()
\r
1688 .getHiddenColumns().elementAt(i);
\r
1689 if (region[0] >= hiddenOffset && region[1] <= hiddenCutoff)
\r
1691 hiddenColumns.addElement(new int[]
\r
1692 { region[0] - hiddenOffset, region[1] - hiddenOffset });
\r
1697 Desktop.jalviewClipboard = new Object[]
\r
1698 { seqs, viewport.getAlignment().getDataset(), hiddenColumns };
\r
1699 statusBar.setText(MessageManager.formatMessage("label.copied_sequences_to_clipboard", new String[]{Integer.valueOf(seqs.length).toString()}));
\r
1709 protected void pasteNew_actionPerformed(ActionEvent e)
\r
1721 protected void pasteThis_actionPerformed(ActionEvent e)
\r
1727 * Paste contents of Jalview clipboard
\r
1729 * @param newAlignment
\r
1730 * true to paste to a new alignment, otherwise add to this.
\r
1732 void paste(boolean newAlignment)
\r
1734 boolean externalPaste = true;
\r
1737 Clipboard c = Toolkit.getDefaultToolkit().getSystemClipboard();
\r
1738 Transferable contents = c.getContents(this);
\r
1740 if (contents == null)
\r
1745 String str, format;
\r
1748 str = (String) contents.getTransferData(DataFlavor.stringFlavor);
\r
1749 if (str.length() < 1)
\r
1754 format = new IdentifyFile().Identify(str, "Paste");
\r
1756 } catch (OutOfMemoryError er)
\r
1758 new OOMWarning("Out of memory pasting sequences!!", er);
\r
1762 SequenceI[] sequences;
\r
1763 boolean annotationAdded = false;
\r
1764 AlignmentI alignment = null;
\r
1766 if (Desktop.jalviewClipboard != null)
\r
1768 // The clipboard was filled from within Jalview, we must use the
\r
1770 // And dataset from the copied alignment
\r
1771 SequenceI[] newseq = (SequenceI[]) Desktop.jalviewClipboard[0];
\r
1772 // be doubly sure that we create *new* sequence objects.
\r
1773 sequences = new SequenceI[newseq.length];
\r
1774 for (int i = 0; i < newseq.length; i++)
\r
1776 sequences[i] = new Sequence(newseq[i]);
\r
1778 alignment = new Alignment(sequences);
\r
1779 externalPaste = false;
\r
1783 // parse the clipboard as an alignment.
\r
1784 alignment = new FormatAdapter().readFile(str, "Paste", format);
\r
1785 sequences = alignment.getSequencesArray();
\r
1789 ArrayList<Integer> newGraphGroups = new ArrayList<Integer>();
\r
1795 if (Desktop.jalviewClipboard != null)
\r
1797 // dataset is inherited
\r
1798 alignment.setDataset((Alignment) Desktop.jalviewClipboard[1]);
\r
1802 // new dataset is constructed
\r
1803 alignment.setDataset(null);
\r
1805 alwidth = alignment.getWidth() + 1;
\r
1809 AlignmentI pastedal = alignment; // preserve pasted alignment object
\r
1810 // Add pasted sequences and dataset into existing alignment.
\r
1811 alignment = viewport.getAlignment();
\r
1812 alwidth = alignment.getWidth() + 1;
\r
1813 // decide if we need to import sequences from an existing dataset
\r
1814 boolean importDs = Desktop.jalviewClipboard != null
\r
1815 && Desktop.jalviewClipboard[1] != alignment.getDataset();
\r
1816 // importDs==true instructs us to copy over new dataset sequences from
\r
1817 // an existing alignment
\r
1818 Vector newDs = (importDs) ? new Vector() : null; // used to create
\r
1819 // minimum dataset set
\r
1821 for (int i = 0; i < sequences.length; i++)
\r
1825 newDs.addElement(null);
\r
1827 SequenceI ds = sequences[i].getDatasetSequence(); // null for a simple
\r
1829 if (importDs && ds != null)
\r
1831 if (!newDs.contains(ds))
\r
1833 newDs.setElementAt(ds, i);
\r
1834 ds = new Sequence(ds);
\r
1835 // update with new dataset sequence
\r
1836 sequences[i].setDatasetSequence(ds);
\r
1840 ds = sequences[newDs.indexOf(ds)].getDatasetSequence();
\r
1845 // copy and derive new dataset sequence
\r
1846 sequences[i] = sequences[i].deriveSequence();
\r
1847 alignment.getDataset().addSequence(
\r
1848 sequences[i].getDatasetSequence());
\r
1849 // TODO: avoid creation of duplicate dataset sequences with a
\r
1850 // 'contains' method using SequenceI.equals()/SequenceI.contains()
\r
1852 alignment.addSequence(sequences[i]); // merges dataset
\r
1854 if (newDs != null)
\r
1856 newDs.clear(); // tidy up
\r
1858 if (alignment.getAlignmentAnnotation() != null)
\r
1860 for (AlignmentAnnotation alan : alignment
\r
1861 .getAlignmentAnnotation())
\r
1863 if (alan.graphGroup > fgroup)
\r
1865 fgroup = alan.graphGroup;
\r
1869 if (pastedal.getAlignmentAnnotation() != null)
\r
1871 // Add any annotation attached to alignment.
\r
1872 AlignmentAnnotation[] alann = pastedal.getAlignmentAnnotation();
\r
1873 for (int i = 0; i < alann.length; i++)
\r
1875 annotationAdded = true;
\r
1876 if (alann[i].sequenceRef == null && !alann[i].autoCalculated)
\r
1878 AlignmentAnnotation newann = new AlignmentAnnotation(alann[i]);
\r
1879 if (newann.graphGroup > -1)
\r
1881 if (newGraphGroups.size() <= newann.graphGroup
\r
1882 || newGraphGroups.get(newann.graphGroup) == null)
\r
1884 for (int q = newGraphGroups.size(); q <= newann.graphGroup; q++)
\r
1886 newGraphGroups.add(q, null);
\r
1888 newGraphGroups.set(newann.graphGroup, new Integer(
\r
1891 newann.graphGroup = newGraphGroups.get(newann.graphGroup)
\r
1895 newann.padAnnotation(alwidth);
\r
1896 alignment.addAnnotation(newann);
\r
1901 if (!newAlignment)
\r
1904 // ADD HISTORY ITEM
\r
1906 addHistoryItem(new EditCommand("Add sequences", EditCommand.PASTE,
\r
1907 sequences, 0, alignment.getWidth(), alignment));
\r
1909 // Add any annotations attached to sequences
\r
1910 for (int i = 0; i < sequences.length; i++)
\r
1912 if (sequences[i].getAnnotation() != null)
\r
1914 AlignmentAnnotation newann;
\r
1915 for (int a = 0; a < sequences[i].getAnnotation().length; a++)
\r
1917 annotationAdded = true;
\r
1918 newann = sequences[i].getAnnotation()[a];
\r
1919 newann.adjustForAlignment();
\r
1920 newann.padAnnotation(alwidth);
\r
1921 if (newann.graphGroup > -1)
\r
1923 if (newann.graphGroup > -1)
\r
1925 if (newGraphGroups.size() <= newann.graphGroup
\r
1926 || newGraphGroups.get(newann.graphGroup) == null)
\r
1928 for (int q = newGraphGroups.size(); q <= newann.graphGroup; q++)
\r
1930 newGraphGroups.add(q, null);
\r
1932 newGraphGroups.set(newann.graphGroup, new Integer(
\r
1935 newann.graphGroup = newGraphGroups.get(newann.graphGroup)
\r
1939 alignment.addAnnotation(sequences[i].getAnnotation()[a]); // annotation
\r
1944 .setAnnotationIndex(sequences[i].getAnnotation()[a], a);
\r
1948 if (!newAlignment)
\r
1951 // propagate alignment changed.
\r
1952 viewport.setEndSeq(alignment.getHeight());
\r
1953 if (annotationAdded)
\r
1955 // Duplicate sequence annotation in all views.
\r
1956 AlignmentI[] alview = this.getViewAlignments();
\r
1957 for (int i = 0; i < sequences.length; i++)
\r
1959 AlignmentAnnotation sann[] = sequences[i].getAnnotation();
\r
1962 for (int avnum = 0; avnum < alview.length; avnum++)
\r
1964 if (alview[avnum] != alignment)
\r
1966 // duplicate in a view other than the one with input focus
\r
1967 int avwidth = alview[avnum].getWidth() + 1;
\r
1968 // this relies on sann being preserved after we
\r
1969 // modify the sequence's annotation array for each duplication
\r
1970 for (int a = 0; a < sann.length; a++)
\r
1972 AlignmentAnnotation newann = new AlignmentAnnotation(
\r
1974 sequences[i].addAlignmentAnnotation(newann);
\r
1975 newann.padAnnotation(avwidth);
\r
1976 alview[avnum].addAnnotation(newann); // annotation was
\r
1977 // duplicated earlier
\r
1978 // TODO JAL-1145 graphGroups are not updated for sequence
\r
1979 // annotation added to several views. This may cause
\r
1981 alview[avnum].setAnnotationIndex(newann, a);
\r
1986 buildSortByAnnotationScoresMenu();
\r
1988 viewport.firePropertyChange("alignment", null,
\r
1989 alignment.getSequences());
\r
1990 if (alignPanels != null)
\r
1992 for (AlignmentPanel ap : ((Vector<AlignmentPanel>) alignPanels))
\r
1994 ap.validateAnnotationDimensions(false);
\r
1999 alignPanel.validateAnnotationDimensions(false);
\r
2005 AlignFrame af = new AlignFrame(alignment, DEFAULT_WIDTH,
\r
2007 String newtitle = new String("Copied sequences");
\r
2009 if (Desktop.jalviewClipboard != null
\r
2010 && Desktop.jalviewClipboard[2] != null)
\r
2012 Vector hc = (Vector) Desktop.jalviewClipboard[2];
\r
2013 for (int i = 0; i < hc.size(); i++)
\r
2015 int[] region = (int[]) hc.elementAt(i);
\r
2016 af.viewport.hideColumns(region[0], region[1]);
\r
2020 // >>>This is a fix for the moment, until a better solution is
\r
2022 af.alignPanel.seqPanel.seqCanvas.getFeatureRenderer()
\r
2023 .transferSettings(
\r
2024 alignPanel.seqPanel.seqCanvas.getFeatureRenderer());
\r
2026 // TODO: maintain provenance of an alignment, rather than just make the
\r
2027 // title a concatenation of operations.
\r
2028 if (!externalPaste)
\r
2030 if (title.startsWith("Copied sequences"))
\r
2036 newtitle = newtitle.concat("- from " + title);
\r
2041 newtitle = new String("Pasted sequences");
\r
2044 Desktop.addInternalFrame(af, newtitle, DEFAULT_WIDTH,
\r
2049 } catch (Exception ex)
\r
2051 ex.printStackTrace();
\r
2052 System.out.println("Exception whilst pasting: " + ex);
\r
2053 // could be anything being pasted in here
\r
2065 protected void cut_actionPerformed(ActionEvent e)
\r
2067 copy_actionPerformed(null);
\r
2068 delete_actionPerformed(null);
\r
2078 protected void delete_actionPerformed(ActionEvent evt)
\r
2081 SequenceGroup sg = viewport.getSelectionGroup();
\r
2087 Vector seqs = new Vector();
\r
2089 for (int i = 0; i < sg.getSize(); i++)
\r
2091 seq = sg.getSequenceAt(i);
\r
2092 seqs.addElement(seq);
\r
2095 // If the cut affects all sequences, remove highlighted columns
\r
2096 if (sg.getSize() == viewport.getAlignment().getHeight())
\r
2098 viewport.getColumnSelection().removeElements(sg.getStartRes(),
\r
2099 sg.getEndRes() + 1);
\r
2102 SequenceI[] cut = new SequenceI[seqs.size()];
\r
2103 for (int i = 0; i < seqs.size(); i++)
\r
2105 cut[i] = (SequenceI) seqs.elementAt(i);
\r
2109 * //ADD HISTORY ITEM
\r
2111 addHistoryItem(new EditCommand("Cut Sequences", EditCommand.CUT, cut,
\r
2112 sg.getStartRes(), sg.getEndRes() - sg.getStartRes() + 1,
\r
2113 viewport.getAlignment()));
\r
2115 viewport.setSelectionGroup(null);
\r
2116 viewport.sendSelection();
\r
2117 viewport.getAlignment().deleteGroup(sg);
\r
2119 viewport.firePropertyChange("alignment", null, viewport.getAlignment()
\r
2121 if (viewport.getAlignment().getHeight() < 1)
\r
2125 this.setClosed(true);
\r
2126 } catch (Exception ex)
\r
2139 protected void deleteGroups_actionPerformed(ActionEvent e)
\r
2141 if (avc.deleteGroups()) {
\r
2142 PaintRefresher.Refresh(this, viewport.getSequenceSetId());
\r
2143 alignPanel.updateAnnotation();
\r
2144 alignPanel.paintAlignment(true);
\r
2155 public void selectAllSequenceMenuItem_actionPerformed(ActionEvent e)
\r
2157 SequenceGroup sg = new SequenceGroup();
\r
2159 for (int i = 0; i < viewport.getAlignment().getSequences().size(); i++)
\r
2161 sg.addSequence(viewport.getAlignment().getSequenceAt(i), false);
\r
2164 sg.setEndRes(viewport.getAlignment().getWidth() - 1);
\r
2165 viewport.setSelectionGroup(sg);
\r
2166 viewport.sendSelection();
\r
2167 alignPanel.paintAlignment(true);
\r
2168 PaintRefresher.Refresh(alignPanel, viewport.getSequenceSetId());
\r
2178 public void deselectAllSequenceMenuItem_actionPerformed(ActionEvent e)
\r
2180 if (viewport.cursorMode)
\r
2182 alignPanel.seqPanel.keyboardNo1 = null;
\r
2183 alignPanel.seqPanel.keyboardNo2 = null;
\r
2185 viewport.setSelectionGroup(null);
\r
2186 viewport.getColumnSelection().clear();
\r
2187 viewport.setSelectionGroup(null);
\r
2188 alignPanel.seqPanel.seqCanvas.highlightSearchResults(null);
\r
2189 alignPanel.idPanel.idCanvas.searchResults = null;
\r
2190 alignPanel.paintAlignment(true);
\r
2191 PaintRefresher.Refresh(alignPanel, viewport.getSequenceSetId());
\r
2192 viewport.sendSelection();
\r
2202 public void invertSequenceMenuItem_actionPerformed(ActionEvent e)
\r
2204 SequenceGroup sg = viewport.getSelectionGroup();
\r
2208 selectAllSequenceMenuItem_actionPerformed(null);
\r
2213 for (int i = 0; i < viewport.getAlignment().getSequences().size(); i++)
\r
2215 sg.addOrRemove(viewport.getAlignment().getSequenceAt(i), false);
\r
2218 alignPanel.paintAlignment(true);
\r
2219 PaintRefresher.Refresh(alignPanel, viewport.getSequenceSetId());
\r
2220 viewport.sendSelection();
\r
2224 public void invertColSel_actionPerformed(ActionEvent e)
\r
2226 viewport.invertColumnSelection();
\r
2227 alignPanel.paintAlignment(true);
\r
2228 viewport.sendSelection();
\r
2238 public void remove2LeftMenuItem_actionPerformed(ActionEvent e)
\r
2240 trimAlignment(true);
\r
2250 public void remove2RightMenuItem_actionPerformed(ActionEvent e)
\r
2252 trimAlignment(false);
\r
2255 void trimAlignment(boolean trimLeft)
\r
2257 ColumnSelection colSel = viewport.getColumnSelection();
\r
2260 if (colSel.size() > 0)
\r
2264 column = colSel.getMin();
\r
2268 column = colSel.getMax();
\r
2272 if (viewport.getSelectionGroup() != null)
\r
2274 seqs = viewport.getSelectionGroup().getSequencesAsArray(
\r
2275 viewport.getHiddenRepSequences());
\r
2279 seqs = viewport.getAlignment().getSequencesArray();
\r
2282 TrimRegionCommand trimRegion;
\r
2285 trimRegion = new TrimRegionCommand("Remove Left",
\r
2286 TrimRegionCommand.TRIM_LEFT, seqs, column,
\r
2287 viewport.getAlignment(), viewport.getColumnSelection(),
\r
2288 viewport.getSelectionGroup());
\r
2289 viewport.setStartRes(0);
\r
2293 trimRegion = new TrimRegionCommand("Remove Right",
\r
2294 TrimRegionCommand.TRIM_RIGHT, seqs, column,
\r
2295 viewport.getAlignment(), viewport.getColumnSelection(),
\r
2296 viewport.getSelectionGroup());
\r
2299 statusBar.setText(MessageManager.formatMessage("label.removed_columns", new String[]{Integer.valueOf(trimRegion.getSize()).toString()}));
\r
2301 addHistoryItem(trimRegion);
\r
2303 for (SequenceGroup sg : viewport.getAlignment().getGroups())
\r
2305 if ((trimLeft && !sg.adjustForRemoveLeft(column))
\r
2306 || (!trimLeft && !sg.adjustForRemoveRight(column)))
\r
2308 viewport.getAlignment().deleteGroup(sg);
\r
2312 viewport.firePropertyChange("alignment", null, viewport
\r
2313 .getAlignment().getSequences());
\r
2324 public void removeGappedColumnMenuItem_actionPerformed(ActionEvent e)
\r
2326 int start = 0, end = viewport.getAlignment().getWidth() - 1;
\r
2329 if (viewport.getSelectionGroup() != null)
\r
2331 seqs = viewport.getSelectionGroup().getSequencesAsArray(
\r
2332 viewport.getHiddenRepSequences());
\r
2333 start = viewport.getSelectionGroup().getStartRes();
\r
2334 end = viewport.getSelectionGroup().getEndRes();
\r
2338 seqs = viewport.getAlignment().getSequencesArray();
\r
2341 RemoveGapColCommand removeGapCols = new RemoveGapColCommand(
\r
2342 "Remove Gapped Columns", seqs, start, end,
\r
2343 viewport.getAlignment());
\r
2345 addHistoryItem(removeGapCols);
\r
2347 statusBar.setText(MessageManager.formatMessage("label.removed_empty_columns", new String[]{Integer.valueOf(removeGapCols.getSize()).toString()}));
\r
2349 // This is to maintain viewport position on first residue
\r
2350 // of first sequence
\r
2351 SequenceI seq = viewport.getAlignment().getSequenceAt(0);
\r
2352 int startRes = seq.findPosition(viewport.startRes);
\r
2353 // ShiftList shifts;
\r
2354 // viewport.getAlignment().removeGaps(shifts=new ShiftList());
\r
2355 // edit.alColumnChanges=shifts.getInverse();
\r
2356 // if (viewport.hasHiddenColumns)
\r
2357 // viewport.getColumnSelection().compensateForEdits(shifts);
\r
2358 viewport.setStartRes(seq.findIndex(startRes) - 1);
\r
2359 viewport.firePropertyChange("alignment", null, viewport.getAlignment()
\r
2371 public void removeAllGapsMenuItem_actionPerformed(ActionEvent e)
\r
2373 int start = 0, end = viewport.getAlignment().getWidth() - 1;
\r
2376 if (viewport.getSelectionGroup() != null)
\r
2378 seqs = viewport.getSelectionGroup().getSequencesAsArray(
\r
2379 viewport.getHiddenRepSequences());
\r
2380 start = viewport.getSelectionGroup().getStartRes();
\r
2381 end = viewport.getSelectionGroup().getEndRes();
\r
2385 seqs = viewport.getAlignment().getSequencesArray();
\r
2388 // This is to maintain viewport position on first residue
\r
2389 // of first sequence
\r
2390 SequenceI seq = viewport.getAlignment().getSequenceAt(0);
\r
2391 int startRes = seq.findPosition(viewport.startRes);
\r
2393 addHistoryItem(new RemoveGapsCommand("Remove Gaps", seqs, start, end,
\r
2394 viewport.getAlignment()));
\r
2396 viewport.setStartRes(seq.findIndex(startRes) - 1);
\r
2398 viewport.firePropertyChange("alignment", null, viewport.getAlignment()
\r
2410 public void padGapsMenuitem_actionPerformed(ActionEvent e)
\r
2412 viewport.setPadGaps(padGapsMenuitem.isSelected());
\r
2413 viewport.firePropertyChange("alignment", null, viewport.getAlignment()
\r
2419 // if (justifySeqs>0)
\r
2421 // alignment.justify(justifySeqs!=RIGHT_JUSTIFY);
\r
2434 public void findMenuItem_actionPerformed(ActionEvent e)
\r
2440 public void newView_actionPerformed(ActionEvent e)
\r
2447 * @param copyAnnotation
\r
2448 * if true then duplicate all annnotation, groups and settings
\r
2449 * @return new alignment panel, already displayed.
\r
2451 public AlignmentPanel newView(boolean copyAnnotation)
\r
2453 return newView(null, copyAnnotation);
\r
2458 * @param viewTitle
\r
2459 * title of newly created view
\r
2460 * @return new alignment panel, already displayed.
\r
2462 public AlignmentPanel newView(String viewTitle)
\r
2464 return newView(viewTitle, true);
\r
2469 * @param viewTitle
\r
2470 * title of newly created view
\r
2471 * @param copyAnnotation
\r
2472 * if true then duplicate all annnotation, groups and settings
\r
2473 * @return new alignment panel, already displayed.
\r
2475 public AlignmentPanel newView(String viewTitle, boolean copyAnnotation)
\r
2477 AlignmentPanel newap = new Jalview2XML().copyAlignPanel(alignPanel,
\r
2479 if (!copyAnnotation)
\r
2481 // just remove all the current annotation except for the automatic stuff
\r
2482 newap.av.getAlignment().deleteAllGroups();
\r
2483 for (AlignmentAnnotation alan : newap.av.getAlignment()
\r
2484 .getAlignmentAnnotation())
\r
2486 if (!alan.autoCalculated)
\r
2488 newap.av.getAlignment().deleteAnnotation(alan);
\r
2494 newap.av.gatherViewsHere = false;
\r
2496 if (viewport.viewName == null)
\r
2498 viewport.viewName = "Original";
\r
2501 newap.av.historyList = viewport.historyList;
\r
2502 newap.av.redoList = viewport.redoList;
\r
2504 int index = Desktop.getViewCount(viewport.getSequenceSetId());
\r
2505 // make sure the new view has a unique name - this is essential for Jalview
\r
2507 boolean addFirstIndex = false;
\r
2508 if (viewTitle == null || viewTitle.trim().length() == 0)
\r
2510 viewTitle = "View";
\r
2511 addFirstIndex = true;
\r
2515 index = 1;// we count from 1 if given a specific name
\r
2517 String newViewName = viewTitle + ((addFirstIndex) ? " " + index : "");
\r
2518 Vector comps = (Vector) PaintRefresher.components.get(viewport
\r
2519 .getSequenceSetId());
\r
2520 Vector existingNames = new Vector();
\r
2521 for (int i = 0; i < comps.size(); i++)
\r
2523 if (comps.elementAt(i) instanceof AlignmentPanel)
\r
2525 AlignmentPanel ap = (AlignmentPanel) comps.elementAt(i);
\r
2526 if (!existingNames.contains(ap.av.viewName))
\r
2528 existingNames.addElement(ap.av.viewName);
\r
2533 while (existingNames.contains(newViewName))
\r
2535 newViewName = viewTitle + " " + (++index);
\r
2538 newap.av.viewName = newViewName;
\r
2540 addAlignmentPanel(newap, true);
\r
2541 newap.alignmentChanged();
\r
2543 if (alignPanels.size() == 2)
\r
2545 viewport.gatherViewsHere = true;
\r
2547 tabbedPane.setSelectedIndex(tabbedPane.getTabCount() - 1);
\r
2552 public void expandViews_actionPerformed(ActionEvent e)
\r
2554 Desktop.instance.explodeViews(this);
\r
2558 public void gatherViews_actionPerformed(ActionEvent e)
\r
2560 Desktop.instance.gatherViews(this);
\r
2570 public void font_actionPerformed(ActionEvent e)
\r
2572 new FontChooser(alignPanel);
\r
2582 protected void seqLimit_actionPerformed(ActionEvent e)
\r
2584 viewport.setShowJVSuffix(seqLimits.isSelected());
\r
2586 alignPanel.idPanel.idCanvas.setPreferredSize(alignPanel
\r
2587 .calculateIdWidth());
\r
2588 alignPanel.paintAlignment(true);
\r
2592 public void idRightAlign_actionPerformed(ActionEvent e)
\r
2594 viewport.rightAlignIds = idRightAlign.isSelected();
\r
2595 alignPanel.paintAlignment(true);
\r
2599 public void centreColumnLabels_actionPerformed(ActionEvent e)
\r
2601 viewport.centreColumnLabels = centreColumnLabelsMenuItem.getState();
\r
2602 alignPanel.paintAlignment(true);
\r
2608 * @see jalview.jbgui.GAlignFrame#followHighlight_actionPerformed()
\r
2611 protected void followHighlight_actionPerformed()
\r
2613 if (viewport.followHighlight = this.followHighlightMenuItem.getState())
\r
2615 alignPanel.scrollToPosition(
\r
2616 alignPanel.seqPanel.seqCanvas.searchResults, false);
\r
2627 protected void colourTextMenuItem_actionPerformed(ActionEvent e)
\r
2629 viewport.setColourText(colourTextMenuItem.isSelected());
\r
2630 alignPanel.paintAlignment(true);
\r
2640 public void wrapMenuItem_actionPerformed(ActionEvent e)
\r
2642 scaleAbove.setVisible(wrapMenuItem.isSelected());
\r
2643 scaleLeft.setVisible(wrapMenuItem.isSelected());
\r
2644 scaleRight.setVisible(wrapMenuItem.isSelected());
\r
2645 viewport.setWrapAlignment(wrapMenuItem.isSelected());
\r
2646 alignPanel.setWrapAlignment(wrapMenuItem.isSelected());
\r
2650 public void showAllSeqs_actionPerformed(ActionEvent e)
\r
2652 viewport.showAllHiddenSeqs();
\r
2656 public void showAllColumns_actionPerformed(ActionEvent e)
\r
2658 viewport.showAllHiddenColumns();
\r
2663 public void hideSelSequences_actionPerformed(ActionEvent e)
\r
2665 viewport.hideAllSelectedSeqs();
\r
2666 alignPanel.paintAlignment(true);
\r
2670 * called by key handler and the hide all/show all menu items
\r
2672 * @param toggleSeqs
\r
2673 * @param toggleCols
\r
2675 private void toggleHiddenRegions(boolean toggleSeqs, boolean toggleCols)
\r
2678 boolean hide = false;
\r
2679 SequenceGroup sg = viewport.getSelectionGroup();
\r
2680 if (!toggleSeqs && !toggleCols)
\r
2682 // Hide everything by the current selection - this is a hack - we do the
\r
2683 // invert and then hide
\r
2684 // first check that there will be visible columns after the invert.
\r
2685 if ((viewport.getColumnSelection() != null
\r
2686 && viewport.getColumnSelection().getSelected() != null && viewport
\r
2687 .getColumnSelection().getSelected().size() > 0)
\r
2688 || (sg != null && sg.getSize() > 0 && sg.getStartRes() <= sg
\r
2691 // now invert the sequence set, if required - empty selection implies
\r
2692 // that no hiding is required.
\r
2695 invertSequenceMenuItem_actionPerformed(null);
\r
2696 sg = viewport.getSelectionGroup();
\r
2697 toggleSeqs = true;
\r
2700 viewport.expandColSelection(sg, true);
\r
2701 // finally invert the column selection and get the new sequence
\r
2703 invertColSel_actionPerformed(null);
\r
2704 toggleCols = true;
\r
2710 if (sg != null && sg.getSize() != viewport.getAlignment().getHeight())
\r
2712 hideSelSequences_actionPerformed(null);
\r
2715 else if (!(toggleCols && viewport.getColumnSelection().getSelected()
\r
2718 showAllSeqs_actionPerformed(null);
\r
2724 if (viewport.getColumnSelection().getSelected().size() > 0)
\r
2726 hideSelColumns_actionPerformed(null);
\r
2729 viewport.setSelectionGroup(sg);
\r
2734 showAllColumns_actionPerformed(null);
\r
2743 * jalview.jbgui.GAlignFrame#hideAllButSelection_actionPerformed(java.awt.
\r
2744 * event.ActionEvent)
\r
2747 public void hideAllButSelection_actionPerformed(ActionEvent e)
\r
2749 toggleHiddenRegions(false, false);
\r
2756 * jalview.jbgui.GAlignFrame#hideAllSelection_actionPerformed(java.awt.event
\r
2760 public void hideAllSelection_actionPerformed(ActionEvent e)
\r
2762 SequenceGroup sg = viewport.getSelectionGroup();
\r
2763 viewport.expandColSelection(sg, false);
\r
2764 viewport.hideAllSelectedSeqs();
\r
2765 viewport.hideSelectedColumns();
\r
2766 alignPanel.paintAlignment(true);
\r
2773 * jalview.jbgui.GAlignFrame#showAllhidden_actionPerformed(java.awt.event.
\r
2777 public void showAllhidden_actionPerformed(ActionEvent e)
\r
2779 viewport.showAllHiddenColumns();
\r
2780 viewport.showAllHiddenSeqs();
\r
2781 alignPanel.paintAlignment(true);
\r
2785 public void hideSelColumns_actionPerformed(ActionEvent e)
\r
2787 viewport.hideSelectedColumns();
\r
2788 alignPanel.paintAlignment(true);
\r
2792 public void hiddenMarkers_actionPerformed(ActionEvent e)
\r
2794 viewport.setShowHiddenMarkers(hiddenMarkers.isSelected());
\r
2805 protected void scaleAbove_actionPerformed(ActionEvent e)
\r
2807 viewport.setScaleAboveWrapped(scaleAbove.isSelected());
\r
2808 alignPanel.paintAlignment(true);
\r
2818 protected void scaleLeft_actionPerformed(ActionEvent e)
\r
2820 viewport.setScaleLeftWrapped(scaleLeft.isSelected());
\r
2821 alignPanel.paintAlignment(true);
\r
2831 protected void scaleRight_actionPerformed(ActionEvent e)
\r
2833 viewport.setScaleRightWrapped(scaleRight.isSelected());
\r
2834 alignPanel.paintAlignment(true);
\r
2844 public void viewBoxesMenuItem_actionPerformed(ActionEvent e)
\r
2846 viewport.setShowBoxes(viewBoxesMenuItem.isSelected());
\r
2847 alignPanel.paintAlignment(true);
\r
2857 public void viewTextMenuItem_actionPerformed(ActionEvent e)
\r
2859 viewport.setShowText(viewTextMenuItem.isSelected());
\r
2860 alignPanel.paintAlignment(true);
\r
2870 protected void renderGapsMenuItem_actionPerformed(ActionEvent e)
\r
2872 viewport.setRenderGaps(renderGapsMenuItem.isSelected());
\r
2873 alignPanel.paintAlignment(true);
\r
2876 public FeatureSettings featureSettings;
\r
2879 public void featureSettings_actionPerformed(ActionEvent e)
\r
2881 if (featureSettings != null)
\r
2883 featureSettings.close();
\r
2884 featureSettings = null;
\r
2886 if (!showSeqFeatures.isSelected())
\r
2888 // make sure features are actually displayed
\r
2889 showSeqFeatures.setSelected(true);
\r
2890 showSeqFeatures_actionPerformed(null);
\r
2892 featureSettings = new FeatureSettings(this);
\r
2896 * Set or clear 'Show Sequence Features'
\r
2902 public void showSeqFeatures_actionPerformed(ActionEvent evt)
\r
2904 viewport.setShowSequenceFeatures(showSeqFeatures.isSelected());
\r
2905 alignPanel.paintAlignment(true);
\r
2906 if (alignPanel.getOverviewPanel() != null)
\r
2908 alignPanel.getOverviewPanel().updateOverviewImage();
\r
2913 * Set or clear 'Show Sequence Features'
\r
2919 public void showSeqFeaturesHeight_actionPerformed(ActionEvent evt)
\r
2921 viewport.setShowSequenceFeaturesHeight(showSeqFeaturesHeight
\r
2923 if (viewport.getShowSequenceFeaturesHeight())
\r
2925 // ensure we're actually displaying features
\r
2926 viewport.setShowSequenceFeatures(true);
\r
2927 showSeqFeatures.setSelected(true);
\r
2929 alignPanel.paintAlignment(true);
\r
2930 if (alignPanel.getOverviewPanel() != null)
\r
2932 alignPanel.getOverviewPanel().updateOverviewImage();
\r
2943 public void annotationPanelMenuItem_actionPerformed(ActionEvent e)
\r
2945 viewport.setShowAnnotation(annotationPanelMenuItem.isSelected());
\r
2946 alignPanel.setAnnotationVisible(annotationPanelMenuItem.isSelected());
\r
2950 public void alignmentProperties()
\r
2952 JEditorPane editPane = new JEditorPane("text/html", "");
\r
2953 editPane.setEditable(false);
\r
2954 StringBuffer contents = new AlignmentProperties(viewport.getAlignment())
\r
2956 editPane.setText(MessageManager.formatMessage("label.html_content", new String[]{contents.toString()}));
\r
2957 JInternalFrame frame = new JInternalFrame();
\r
2958 frame.getContentPane().add(new JScrollPane(editPane));
\r
2960 Desktop.instance.addInternalFrame(frame, MessageManager.formatMessage("label.alignment_properties", new String[]{getTitle()}), 500, 400);
\r
2970 public void overviewMenuItem_actionPerformed(ActionEvent e)
\r
2972 if (alignPanel.overviewPanel != null)
\r
2977 JInternalFrame frame = new JInternalFrame();
\r
2978 OverviewPanel overview = new OverviewPanel(alignPanel);
\r
2979 frame.setContentPane(overview);
\r
2980 Desktop.addInternalFrame(frame, MessageManager.formatMessage("label.overview_params", new String[]{this.getTitle()}),
\r
2981 frame.getWidth(), frame.getHeight());
\r
2983 frame.setLayer(JLayeredPane.PALETTE_LAYER);
\r
2984 frame.addInternalFrameListener(new javax.swing.event.InternalFrameAdapter()
\r
2987 public void internalFrameClosed(
\r
2988 javax.swing.event.InternalFrameEvent evt)
\r
2990 alignPanel.setOverviewPanel(null);
\r
2994 alignPanel.setOverviewPanel(overview);
\r
2998 public void textColour_actionPerformed(ActionEvent e)
\r
3000 new TextColourChooser().chooseColour(alignPanel, null);
\r
3010 protected void noColourmenuItem_actionPerformed(ActionEvent e)
\r
3012 changeColour(null);
\r
3022 public void clustalColour_actionPerformed(ActionEvent e)
\r
3024 changeColour(new ClustalxColourScheme(viewport.getAlignment(),
\r
3025 viewport.getHiddenRepSequences()));
\r
3035 public void zappoColour_actionPerformed(ActionEvent e)
\r
3037 changeColour(new ZappoColourScheme());
\r
3047 public void taylorColour_actionPerformed(ActionEvent e)
\r
3049 changeColour(new TaylorColourScheme());
\r
3059 public void hydrophobicityColour_actionPerformed(ActionEvent e)
\r
3061 changeColour(new HydrophobicColourScheme());
\r
3071 public void helixColour_actionPerformed(ActionEvent e)
\r
3073 changeColour(new HelixColourScheme());
\r
3083 public void strandColour_actionPerformed(ActionEvent e)
\r
3085 changeColour(new StrandColourScheme());
\r
3095 public void turnColour_actionPerformed(ActionEvent e)
\r
3097 changeColour(new TurnColourScheme());
\r
3107 public void buriedColour_actionPerformed(ActionEvent e)
\r
3109 changeColour(new BuriedColourScheme());
\r
3119 public void nucleotideColour_actionPerformed(ActionEvent e)
\r
3121 changeColour(new NucleotideColourScheme());
\r
3125 public void purinePyrimidineColour_actionPerformed(ActionEvent e)
\r
3127 changeColour(new PurinePyrimidineColourScheme());
\r
3131 * public void covariationColour_actionPerformed(ActionEvent e) {
\r
3132 * changeColour(new
\r
3133 * CovariationColourScheme(viewport.getAlignment().getAlignmentAnnotation
\r
3137 public void annotationColour_actionPerformed(ActionEvent e)
\r
3139 new AnnotationColourChooser(viewport, alignPanel);
\r
3143 public void rnahelicesColour_actionPerformed(ActionEvent e)
\r
3145 new RNAHelicesColourChooser(viewport, alignPanel);
\r
3155 protected void applyToAllGroups_actionPerformed(ActionEvent e)
\r
3157 viewport.setColourAppliesToAllGroups(applyToAllGroups.isSelected());
\r
3166 public void changeColour(ColourSchemeI cs)
\r
3168 // TODO: compare with applet and pull up to model method
\r
3169 int threshold = 0;
\r
3173 if (viewport.getAbovePIDThreshold())
\r
3175 threshold = SliderPanel.setPIDSliderSource(alignPanel, cs,
\r
3178 cs.setThreshold(threshold, viewport.getIgnoreGapsConsensus());
\r
3180 viewport.setGlobalColourScheme(cs);
\r
3184 cs.setThreshold(0, viewport.getIgnoreGapsConsensus());
\r
3187 if (viewport.getConservationSelected())
\r
3190 Alignment al = (Alignment) viewport.getAlignment();
\r
3191 Conservation c = new Conservation("All",
\r
3192 ResidueProperties.propHash, 3, al.getSequences(), 0,
\r
3193 al.getWidth() - 1);
\r
3196 c.verdict(false, viewport.getConsPercGaps());
\r
3198 cs.setConservation(c);
\r
3200 cs.setConservationInc(SliderPanel.setConservationSlider(alignPanel,
\r
3201 cs, "Background"));
\r
3205 cs.setConservation(null);
\r
3208 cs.setConsensus(viewport.getSequenceConsensusHash());
\r
3211 viewport.setGlobalColourScheme(cs);
\r
3213 if (viewport.getColourAppliesToAllGroups())
\r
3216 for (SequenceGroup sg : viewport.getAlignment().getGroups())
\r
3224 if (cs instanceof ClustalxColourScheme)
\r
3226 sg.cs = new ClustalxColourScheme(sg,
\r
3227 viewport.getHiddenRepSequences());
\r
3229 else if (cs instanceof UserColourScheme)
\r
3231 sg.cs = new UserColourScheme(((UserColourScheme) cs).getColours());
\r
3237 sg.cs = cs.getClass().newInstance();
\r
3238 } catch (Exception ex)
\r
3243 if (viewport.getAbovePIDThreshold()
\r
3244 || cs instanceof PIDColourScheme
\r
3245 || cs instanceof Blosum62ColourScheme)
\r
3247 sg.cs.setThreshold(threshold, viewport.getIgnoreGapsConsensus());
\r
3249 sg.cs.setConsensus(AAFrequency.calculate(
\r
3250 sg.getSequences(viewport.getHiddenRepSequences()),
\r
3251 sg.getStartRes(), sg.getEndRes() + 1));
\r
3255 sg.cs.setThreshold(0, viewport.getIgnoreGapsConsensus());
\r
3258 if (viewport.getConservationSelected())
\r
3260 Conservation c = new Conservation("Group",
\r
3261 ResidueProperties.propHash, 3, sg.getSequences(viewport
\r
3262 .getHiddenRepSequences()), sg.getStartRes(),
\r
3263 sg.getEndRes() + 1);
\r
3265 c.verdict(false, viewport.getConsPercGaps());
\r
3266 sg.cs.setConservation(c);
\r
3270 sg.cs.setConservation(null);
\r
3275 if (alignPanel.getOverviewPanel() != null)
\r
3277 alignPanel.getOverviewPanel().updateOverviewImage();
\r
3280 alignPanel.paintAlignment(true);
\r
3290 protected void modifyPID_actionPerformed(ActionEvent e)
\r
3292 if (viewport.getAbovePIDThreshold()
\r
3293 && viewport.getGlobalColourScheme() != null)
\r
3295 SliderPanel.setPIDSliderSource(alignPanel,
\r
3296 viewport.getGlobalColourScheme(), "Background");
\r
3297 SliderPanel.showPIDSlider();
\r
3308 protected void modifyConservation_actionPerformed(ActionEvent e)
\r
3310 if (viewport.getConservationSelected()
\r
3311 && viewport.getGlobalColourScheme() != null)
\r
3313 SliderPanel.setConservationSlider(alignPanel,
\r
3314 viewport.getGlobalColourScheme(), "Background");
\r
3315 SliderPanel.showConservationSlider();
\r
3326 protected void conservationMenuItem_actionPerformed(ActionEvent e)
\r
3328 viewport.setConservationSelected(conservationMenuItem.isSelected());
\r
3330 viewport.setAbovePIDThreshold(false);
\r
3331 abovePIDThreshold.setSelected(false);
\r
3333 changeColour(viewport.getGlobalColourScheme());
\r
3335 modifyConservation_actionPerformed(null);
\r
3345 public void abovePIDThreshold_actionPerformed(ActionEvent e)
\r
3347 viewport.setAbovePIDThreshold(abovePIDThreshold.isSelected());
\r
3349 conservationMenuItem.setSelected(false);
\r
3350 viewport.setConservationSelected(false);
\r
3352 changeColour(viewport.getGlobalColourScheme());
\r
3354 modifyPID_actionPerformed(null);
\r
3364 public void userDefinedColour_actionPerformed(ActionEvent e)
\r
3366 if (e.getActionCommand().equals(MessageManager.getString("action.user_defined")))
\r
3368 new UserDefinedColours(alignPanel, null);
\r
3372 UserColourScheme udc = (UserColourScheme) UserDefinedColours
\r
3373 .getUserColourSchemes().get(e.getActionCommand());
\r
3375 changeColour(udc);
\r
3379 public void updateUserColourMenu()
\r
3382 Component[] menuItems = colourMenu.getMenuComponents();
\r
3383 int i, iSize = menuItems.length;
\r
3384 for (i = 0; i < iSize; i++)
\r
3386 if (menuItems[i].getName() != null
\r
3387 && menuItems[i].getName().equals("USER_DEFINED"))
\r
3389 colourMenu.remove(menuItems[i]);
\r
3393 if (jalview.gui.UserDefinedColours.getUserColourSchemes() != null)
\r
3395 java.util.Enumeration userColours = jalview.gui.UserDefinedColours
\r
3396 .getUserColourSchemes().keys();
\r
3398 while (userColours.hasMoreElements())
\r
3400 final JRadioButtonMenuItem radioItem = new JRadioButtonMenuItem(
\r
3401 userColours.nextElement().toString());
\r
3402 radioItem.setName("USER_DEFINED");
\r
3403 radioItem.addMouseListener(new MouseAdapter()
\r
3406 public void mousePressed(MouseEvent evt)
\r
3408 if (evt.isControlDown()
\r
3409 || SwingUtilities.isRightMouseButton(evt))
\r
3411 radioItem.removeActionListener(radioItem.getActionListeners()[0]);
\r
3413 int option = JOptionPane.showInternalConfirmDialog(
\r
3414 jalview.gui.Desktop.desktop,
\r
3415 MessageManager.getString("label.remove_from_default_list"),
\r
3416 MessageManager.getString("label.remove_user_defined_colour"),
\r
3417 JOptionPane.YES_NO_OPTION);
\r
3418 if (option == JOptionPane.YES_OPTION)
\r
3420 jalview.gui.UserDefinedColours
\r
3421 .removeColourFromDefaults(radioItem.getText());
\r
3422 colourMenu.remove(radioItem);
\r
3426 radioItem.addActionListener(new ActionListener()
\r
3429 public void actionPerformed(ActionEvent evt)
\r
3431 userDefinedColour_actionPerformed(evt);
\r
3438 radioItem.addActionListener(new ActionListener()
\r
3441 public void actionPerformed(ActionEvent evt)
\r
3443 userDefinedColour_actionPerformed(evt);
\r
3447 colourMenu.insert(radioItem, 15);
\r
3448 colours.add(radioItem);
\r
3460 public void PIDColour_actionPerformed(ActionEvent e)
\r
3462 changeColour(new PIDColourScheme());
\r
3472 public void BLOSUM62Colour_actionPerformed(ActionEvent e)
\r
3474 changeColour(new Blosum62ColourScheme());
\r
3484 public void sortPairwiseMenuItem_actionPerformed(ActionEvent e)
\r
3486 SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
\r
3487 AlignmentSorter.sortByPID(viewport.getAlignment(), viewport
\r
3488 .getAlignment().getSequenceAt(0), null);
\r
3489 addHistoryItem(new OrderCommand("Pairwise Sort", oldOrder,
\r
3490 viewport.getAlignment()));
\r
3491 alignPanel.paintAlignment(true);
\r
3501 public void sortIDMenuItem_actionPerformed(ActionEvent e)
\r
3503 SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
\r
3504 AlignmentSorter.sortByID(viewport.getAlignment());
\r
3505 addHistoryItem(new OrderCommand("ID Sort", oldOrder,
\r
3506 viewport.getAlignment()));
\r
3507 alignPanel.paintAlignment(true);
\r
3517 public void sortLengthMenuItem_actionPerformed(ActionEvent e)
\r
3519 SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
\r
3520 AlignmentSorter.sortByLength(viewport.getAlignment());
\r
3521 addHistoryItem(new OrderCommand("Length Sort", oldOrder,
\r
3522 viewport.getAlignment()));
\r
3523 alignPanel.paintAlignment(true);
\r
3533 public void sortGroupMenuItem_actionPerformed(ActionEvent e)
\r
3535 SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
\r
3536 AlignmentSorter.sortByGroup(viewport.getAlignment());
\r
3537 addHistoryItem(new OrderCommand("Group Sort", oldOrder,
\r
3538 viewport.getAlignment()));
\r
3540 alignPanel.paintAlignment(true);
\r
3550 public void removeRedundancyMenuItem_actionPerformed(ActionEvent e)
\r
3552 new RedundancyPanel(alignPanel, this);
\r
3562 public void pairwiseAlignmentMenuItem_actionPerformed(ActionEvent e)
\r
3564 if ((viewport.getSelectionGroup() == null)
\r
3565 || (viewport.getSelectionGroup().getSize() < 2))
\r
3567 JOptionPane.showInternalMessageDialog(this,
\r
3568 MessageManager.getString("label.you_must_select_least_two_sequences"), MessageManager.getString("label.invalid_selection"),
\r
3569 JOptionPane.WARNING_MESSAGE);
\r
3573 JInternalFrame frame = new JInternalFrame();
\r
3574 frame.setContentPane(new PairwiseAlignPanel(viewport));
\r
3575 Desktop.addInternalFrame(frame, MessageManager.getString("action.pairwise_alignment"), 600, 500);
\r
3586 public void PCAMenuItem_actionPerformed(ActionEvent e)
\r
3588 if (((viewport.getSelectionGroup() != null)
\r
3589 && (viewport.getSelectionGroup().getSize() < 4) && (viewport
\r
3590 .getSelectionGroup().getSize() > 0))
\r
3591 || (viewport.getAlignment().getHeight() < 4))
\r
3593 JOptionPane.showInternalMessageDialog(this,
\r
3594 MessageManager.getString("label.principal_component_analysis_must_take_least_four_input_sequences"),
\r
3595 MessageManager.getString("label.sequence_selection_insufficient"),
\r
3596 JOptionPane.WARNING_MESSAGE);
\r
3601 new PCAPanel(alignPanel);
\r
3605 public void autoCalculate_actionPerformed(ActionEvent e)
\r
3607 viewport.autoCalculateConsensus = autoCalculate.isSelected();
\r
3608 if (viewport.autoCalculateConsensus)
\r
3610 viewport.firePropertyChange("alignment", null, viewport
\r
3611 .getAlignment().getSequences());
\r
3616 public void sortByTreeOption_actionPerformed(ActionEvent e)
\r
3618 viewport.sortByTree = sortByTree.isSelected();
\r
3622 protected void listenToViewSelections_actionPerformed(ActionEvent e)
\r
3624 viewport.followSelection = listenToViewSelections.isSelected();
\r
3634 public void averageDistanceTreeMenuItem_actionPerformed(ActionEvent e)
\r
3636 NewTreePanel("AV", "PID", "Average distance tree using PID");
\r
3646 public void neighbourTreeMenuItem_actionPerformed(ActionEvent e)
\r
3648 NewTreePanel("NJ", "PID", "Neighbour joining tree using PID");
\r
3658 protected void njTreeBlosumMenuItem_actionPerformed(ActionEvent e)
\r
3660 NewTreePanel("NJ", "BL", "Neighbour joining tree using BLOSUM62");
\r
3670 protected void avTreeBlosumMenuItem_actionPerformed(ActionEvent e)
\r
3672 NewTreePanel("AV", "BL", "Average distance tree using BLOSUM62");
\r
3685 void NewTreePanel(String type, String pwType, String title)
\r
3689 if (viewport.getSelectionGroup() != null
\r
3690 && viewport.getSelectionGroup().getSize() > 0)
\r
3692 if (viewport.getSelectionGroup().getSize() < 3)
\r
3695 .showMessageDialog(
\r
3697 MessageManager.getString("label.you_need_more_two_sequences_selected_build_tree"),
\r
3698 MessageManager.getString("label.not_enough_sequences"), JOptionPane.WARNING_MESSAGE);
\r
3702 SequenceGroup sg = viewport.getSelectionGroup();
\r
3704 /* Decide if the selection is a column region */
\r
3705 for (SequenceI _s : sg.getSequences())
\r
3707 if (_s.getLength() < sg.getEndRes())
\r
3710 .showMessageDialog(
\r
3712 MessageManager.getString("label.selected_region_to_tree_may_only_contain_residues_or_gaps"),
\r
3713 MessageManager.getString("label.sequences_selection_not_aligned"),
\r
3714 JOptionPane.WARNING_MESSAGE);
\r
3720 title = title + " on region";
\r
3721 tp = new TreePanel(alignPanel, type, pwType);
\r
3725 // are the visible sequences aligned?
\r
3726 if (!viewport.getAlignment().isAligned(false))
\r
3729 .showMessageDialog(
\r
3731 MessageManager.getString("label.sequences_must_be_aligned_before_creating_tree"),
\r
3732 MessageManager.getString("label.sequences_not_aligned"),
\r
3733 JOptionPane.WARNING_MESSAGE);
\r
3738 if (viewport.getAlignment().getHeight() < 2)
\r
3743 tp = new TreePanel(alignPanel, type, pwType);
\r
3746 title += " from ";
\r
3748 if (viewport.viewName != null)
\r
3750 title += viewport.viewName + " of ";
\r
3753 title += this.title;
\r
3755 Desktop.addInternalFrame(tp, title, 600, 500);
\r
3766 public void addSortByOrderMenuItem(String title,
\r
3767 final AlignmentOrder order)
\r
3769 final JMenuItem item = new JMenuItem("by " + title);
\r
3771 item.addActionListener(new java.awt.event.ActionListener()
\r
3774 public void actionPerformed(ActionEvent e)
\r
3776 SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
\r
3778 // TODO: JBPNote - have to map order entries to curent SequenceI
\r
3780 AlignmentSorter.sortBy(viewport.getAlignment(), order);
\r
3782 addHistoryItem(new OrderCommand(order.getName(), oldOrder, viewport
\r
3783 .getAlignment()));
\r
3785 alignPanel.paintAlignment(true);
\r
3791 * Add a new sort by annotation score menu item
\r
3794 * the menu to add the option to
\r
3795 * @param scoreLabel
\r
3796 * the label used to retrieve scores for each sequence on the
\r
3799 public void addSortByAnnotScoreMenuItem(JMenu sort,
\r
3800 final String scoreLabel)
\r
3802 final JMenuItem item = new JMenuItem(scoreLabel);
\r
3804 item.addActionListener(new java.awt.event.ActionListener()
\r
3807 public void actionPerformed(ActionEvent e)
\r
3809 SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
\r
3810 AlignmentSorter.sortByAnnotationScore(scoreLabel,
\r
3811 viewport.getAlignment());// ,viewport.getSelectionGroup());
\r
3812 addHistoryItem(new OrderCommand("Sort by " + scoreLabel, oldOrder,
\r
3813 viewport.getAlignment()));
\r
3814 alignPanel.paintAlignment(true);
\r
3820 * last hash for alignment's annotation array - used to minimise cost of
\r
3823 protected int _annotationScoreVectorHash;
\r
3826 * search the alignment and rebuild the sort by annotation score submenu the
\r
3827 * last alignment annotation vector hash is stored to minimize cost of
\r
3828 * rebuilding in subsequence calls.
\r
3832 public void buildSortByAnnotationScoresMenu()
\r
3834 if (viewport.getAlignment().getAlignmentAnnotation() == null)
\r
3839 if (viewport.getAlignment().getAlignmentAnnotation().hashCode() != _annotationScoreVectorHash)
\r
3841 sortByAnnotScore.removeAll();
\r
3842 // almost certainly a quicker way to do this - but we keep it simple
\r
3843 Hashtable scoreSorts = new Hashtable();
\r
3844 AlignmentAnnotation aann[];
\r
3845 for (SequenceI sqa : viewport.getAlignment().getSequences())
\r
3847 aann = sqa.getAnnotation();
\r
3848 for (int i = 0; aann != null && i < aann.length; i++)
\r
3850 if (aann[i].hasScore() && aann[i].sequenceRef != null)
\r
3852 scoreSorts.put(aann[i].label, aann[i].label);
\r
3856 Enumeration labels = scoreSorts.keys();
\r
3857 while (labels.hasMoreElements())
\r
3859 addSortByAnnotScoreMenuItem(sortByAnnotScore,
\r
3860 (String) labels.nextElement());
\r
3862 sortByAnnotScore.setVisible(scoreSorts.size() > 0);
\r
3863 scoreSorts.clear();
\r
3865 _annotationScoreVectorHash = viewport.getAlignment()
\r
3866 .getAlignmentAnnotation().hashCode();
\r
3871 * Maintain the Order by->Displayed Tree menu. Creates a new menu item for a
\r
3872 * TreePanel with an appropriate <code>jalview.analysis.AlignmentSorter</code>
\r
3873 * call. Listeners are added to remove the menu item when the treePanel is
\r
3874 * closed, and adjust the tree leaf to sequence mapping when the alignment is
\r
3877 * @param treePanel
\r
3878 * Displayed tree window.
\r
3880 * SortBy menu item title.
\r
3883 public void buildTreeMenu()
\r
3885 sortByTreeMenu.removeAll();
\r
3887 Vector comps = (Vector) PaintRefresher.components.get(viewport
\r
3888 .getSequenceSetId());
\r
3889 Vector treePanels = new Vector();
\r
3890 int i, iSize = comps.size();
\r
3891 for (i = 0; i < iSize; i++)
\r
3893 if (comps.elementAt(i) instanceof TreePanel)
\r
3895 treePanels.add(comps.elementAt(i));
\r
3899 iSize = treePanels.size();
\r
3903 sortByTreeMenu.setVisible(false);
\r
3907 sortByTreeMenu.setVisible(true);
\r
3909 for (i = 0; i < treePanels.size(); i++)
\r
3911 final TreePanel tp = (TreePanel) treePanels.elementAt(i);
\r
3912 final JMenuItem item = new JMenuItem(tp.getTitle());
\r
3913 final NJTree tree = ((TreePanel) treePanels.elementAt(i)).getTree();
\r
3914 item.addActionListener(new java.awt.event.ActionListener()
\r
3917 public void actionPerformed(ActionEvent e)
\r
3919 tp.sortByTree_actionPerformed(null);
\r
3920 addHistoryItem(tp.sortAlignmentIn(alignPanel));
\r
3925 sortByTreeMenu.add(item);
\r
3929 public boolean sortBy(AlignmentOrder alorder, String undoname)
\r
3931 SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
\r
3932 AlignmentSorter.sortBy(viewport.getAlignment(), alorder);
\r
3933 if (undoname != null)
\r
3935 addHistoryItem(new OrderCommand(undoname, oldOrder,
\r
3936 viewport.getAlignment()));
\r
3938 alignPanel.paintAlignment(true);
\r
3943 * Work out whether the whole set of sequences or just the selected set will
\r
3944 * be submitted for multiple alignment.
\r
3947 public jalview.datamodel.AlignmentView gatherSequencesForAlignment()
\r
3949 // Now, check we have enough sequences
\r
3950 AlignmentView msa = null;
\r
3952 if ((viewport.getSelectionGroup() != null)
\r
3953 && (viewport.getSelectionGroup().getSize() > 1))
\r
3955 // JBPNote UGLY! To prettify, make SequenceGroup and Alignment conform to
\r
3956 // some common interface!
\r
3958 * SequenceGroup seqs = viewport.getSelectionGroup(); int sz; msa = new
\r
3959 * SequenceI[sz = seqs.getSize(false)];
\r
3961 * for (int i = 0; i < sz; i++) { msa[i] = (SequenceI)
\r
3962 * seqs.getSequenceAt(i); }
\r
3964 msa = viewport.getAlignmentView(true);
\r
3969 * Vector seqs = viewport.getAlignment().getSequences();
\r
3971 * if (seqs.size() > 1) { msa = new SequenceI[seqs.size()];
\r
3973 * for (int i = 0; i < seqs.size(); i++) { msa[i] = (SequenceI)
\r
3974 * seqs.elementAt(i); } }
\r
3976 msa = viewport.getAlignmentView(false);
\r
3982 * Decides what is submitted to a secondary structure prediction service: the
\r
3983 * first sequence in the alignment, or in the current selection, or, if the
\r
3984 * alignment is 'aligned' (ie padded with gaps), then the currently selected
\r
3985 * region or the whole alignment. (where the first sequence in the set is the
\r
3986 * one that the prediction will be for).
\r
3988 public AlignmentView gatherSeqOrMsaForSecStrPrediction()
\r
3990 AlignmentView seqs = null;
\r
3992 if ((viewport.getSelectionGroup() != null)
\r
3993 && (viewport.getSelectionGroup().getSize() > 0))
\r
3995 seqs = viewport.getAlignmentView(true);
\r
3999 seqs = viewport.getAlignmentView(false);
\r
4001 // limit sequences - JBPNote in future - could spawn multiple prediction
\r
4003 // TODO: viewport.getAlignment().isAligned is a global state - the local
\r
4004 // selection may well be aligned - we preserve 2.0.8 behaviour for moment.
\r
4005 if (!viewport.getAlignment().isAligned(false))
\r
4007 seqs.setSequences(new SeqCigar[]
\r
4008 { seqs.getSequences()[0] });
\r
4009 // TODO: if seqs.getSequences().length>1 then should really have warned
\r
4023 protected void LoadtreeMenuItem_actionPerformed(ActionEvent e)
\r
4025 // Pick the tree file
\r
4026 JalviewFileChooser chooser = new JalviewFileChooser(
\r
4027 jalview.bin.Cache.getProperty("LAST_DIRECTORY"));
\r
4028 chooser.setFileView(new JalviewFileView());
\r
4029 chooser.setDialogTitle(MessageManager.getString("label.select_newick_like_tree_file"));
\r
4030 chooser.setToolTipText(MessageManager.getString("label.load_tree_file"));
\r
4032 int value = chooser.showOpenDialog(null);
\r
4034 if (value == JalviewFileChooser.APPROVE_OPTION)
\r
4036 String choice = chooser.getSelectedFile().getPath();
\r
4037 jalview.bin.Cache.setProperty("LAST_DIRECTORY", choice);
\r
4038 jalview.io.NewickFile fin = null;
\r
4041 fin = new jalview.io.NewickFile(choice, "File");
\r
4042 viewport.setCurrentTree(ShowNewickTree(fin, choice).getTree());
\r
4043 } catch (Exception ex)
\r
4045 JOptionPane.showMessageDialog(Desktop.desktop, ex.getMessage(),
\r
4046 MessageManager.getString("label.problem_reading_tree_file"), JOptionPane.WARNING_MESSAGE);
\r
4047 ex.printStackTrace();
\r
4049 if (fin != null && fin.hasWarningMessage())
\r
4051 JOptionPane.showMessageDialog(Desktop.desktop,
\r
4052 fin.getWarningMessage(), MessageManager.getString("label.possible_problem_with_tree_file"),
\r
4053 JOptionPane.WARNING_MESSAGE);
\r
4059 protected void tcoffeeColorScheme_actionPerformed(ActionEvent e)
\r
4061 changeColour(new TCoffeeColourScheme(alignPanel.getAlignment()));
\r
4064 public TreePanel ShowNewickTree(NewickFile nf, String title)
\r
4066 return ShowNewickTree(nf, title, 600, 500, 4, 5);
\r
4069 public TreePanel ShowNewickTree(NewickFile nf, String title,
\r
4070 AlignmentView input)
\r
4072 return ShowNewickTree(nf, title, input, 600, 500, 4, 5);
\r
4075 public TreePanel ShowNewickTree(NewickFile nf, String title, int w,
\r
4076 int h, int x, int y)
\r
4078 return ShowNewickTree(nf, title, null, w, h, x, y);
\r
4082 * Add a treeviewer for the tree extracted from a newick file object to the
\r
4083 * current alignment view
\r
4088 * tree viewer title
\r
4090 * Associated alignment input data (or null)
\r
4099 * @return TreePanel handle
\r
4101 public TreePanel ShowNewickTree(NewickFile nf, String title,
\r
4102 AlignmentView input, int w, int h, int x, int y)
\r
4104 TreePanel tp = null;
\r
4110 if (nf.getTree() != null)
\r
4112 tp = new TreePanel(alignPanel, "FromFile", title, nf, input);
\r
4116 if (x > 0 && y > 0)
\r
4118 tp.setLocation(x, y);
\r
4121 Desktop.addInternalFrame(tp, title, w, h);
\r
4123 } catch (Exception ex)
\r
4125 ex.printStackTrace();
\r
4131 private boolean buildingMenu = false;
\r
4134 * Generates menu items and listener event actions for web service clients
\r
4137 public void BuildWebServiceMenu()
\r
4139 while (buildingMenu)
\r
4143 System.err.println("Waiting for building menu to finish.");
\r
4145 } catch (Exception e)
\r
4150 final AlignFrame me = this;
\r
4151 buildingMenu = true;
\r
4152 new Thread(new Runnable()
\r
4157 final List<JMenuItem> legacyItems=new ArrayList<JMenuItem>();
\r
4160 System.err.println("Building ws menu again "
\r
4161 + Thread.currentThread());
\r
4162 // TODO: add support for context dependent disabling of services based
\r
4164 // alignment and current selection
\r
4165 // TODO: add additional serviceHandle parameter to specify abstract
\r
4167 // class independently of AbstractName
\r
4168 // TODO: add in rediscovery GUI function to restart discoverer
\r
4169 // TODO: group services by location as well as function and/or
\r
4171 // object broker mechanism.
\r
4172 final Vector<JMenu> wsmenu = new Vector<JMenu>();
\r
4173 final IProgressIndicator af = me;
\r
4174 final JMenu msawsmenu = new JMenu("Alignment");
\r
4175 final JMenu secstrmenu = new JMenu(
\r
4176 "Secondary Structure Prediction");
\r
4177 final JMenu seqsrchmenu = new JMenu("Sequence Database Search");
\r
4178 final JMenu analymenu = new JMenu("Analysis");
\r
4179 final JMenu dismenu = new JMenu("Protein Disorder");
\r
4180 // JAL-940 - only show secondary structure prediction services from
\r
4181 // the legacy server
\r
4182 if (// Cache.getDefault("SHOW_JWS1_SERVICES", true)
\r
4184 Discoverer.services != null && (Discoverer.services.size() > 0))
\r
4186 // TODO: refactor to allow list of AbstractName/Handler bindings to
\r
4188 // stored or retrieved from elsewhere
\r
4189 // No MSAWS used any more:
\r
4190 // Vector msaws = null; // (Vector) Discoverer.services.get("MsaWS");
\r
4191 Vector secstrpr = (Vector) Discoverer.services
\r
4192 .get("SecStrPred");
\r
4193 if (secstrpr != null)
\r
4195 // Add any secondary structure prediction services
\r
4196 for (int i = 0, j = secstrpr.size(); i < j; i++)
\r
4198 final ext.vamsas.ServiceHandle sh = (ext.vamsas.ServiceHandle) secstrpr
\r
4200 jalview.ws.WSMenuEntryProviderI impl = jalview.ws.jws1.Discoverer
\r
4201 .getServiceClient(sh);
\r
4202 int p=secstrmenu.getItemCount();
\r
4203 impl.attachWSMenuEntry(secstrmenu, me);
\r
4204 int q=secstrmenu.getItemCount();
\r
4205 for (int litm=p;litm<q; litm++)
\r
4207 legacyItems.add(secstrmenu.getItem(litm));
\r
4213 // Add all submenus in the order they should appear on the web
\r
4215 wsmenu.add(msawsmenu);
\r
4216 wsmenu.add(secstrmenu);
\r
4217 wsmenu.add(dismenu);
\r
4218 wsmenu.add(analymenu);
\r
4219 // No search services yet
\r
4220 // wsmenu.add(seqsrchmenu);
\r
4222 javax.swing.SwingUtilities.invokeLater(new Runnable()
\r
4229 webService.removeAll();
\r
4230 // first, add discovered services onto the webservices menu
\r
4231 if (wsmenu.size() > 0)
\r
4233 for (int i = 0, j = wsmenu.size(); i < j; i++)
\r
4235 webService.add(wsmenu.get(i));
\r
4240 webService.add(me.webServiceNoServices);
\r
4242 // TODO: move into separate menu builder class.
\r
4243 boolean new_sspred=false;
\r
4244 if (Cache.getDefault("SHOW_JWS2_SERVICES", true))
\r
4246 Jws2Discoverer jws2servs = Jws2Discoverer.getDiscoverer();
\r
4247 if (jws2servs != null)
\r
4249 if (jws2servs.hasServices())
\r
4251 jws2servs.attachWSMenuEntry(webService, me);
\r
4252 for (Jws2Instance sv:jws2servs.getServices()) {
\r
4253 if (sv.description.toLowerCase().contains("jpred"))
\r
4255 for (JMenuItem jmi:legacyItems)
\r
4257 jmi.setVisible(false);
\r
4263 if (jws2servs.isRunning())
\r
4265 JMenuItem tm = new JMenuItem(
\r
4266 "Still discovering JABA Services");
\r
4267 tm.setEnabled(false);
\r
4268 webService.add(tm);
\r
4272 build_urlServiceMenu(me.webService);
\r
4273 build_fetchdbmenu(webService);
\r
4274 for (JMenu item : wsmenu)
\r
4276 if (item.getItemCount() == 0)
\r
4278 item.setEnabled(false);
\r
4282 item.setEnabled(true);
\r
4285 } catch (Exception e)
\r
4288 .debug("Exception during web service menu building process.",
\r
4294 } catch (Exception e)
\r
4299 buildingMenu = false;
\r
4306 * construct any groupURL type service menu entries.
\r
4308 * @param webService
\r
4310 private void build_urlServiceMenu(JMenu webService)
\r
4312 // TODO: remove this code when 2.7 is released
\r
4313 // DEBUG - alignmentView
\r
4315 * JMenuItem testAlView = new JMenuItem("Test AlignmentView"); final
\r
4316 * AlignFrame af = this; testAlView.addActionListener(new ActionListener() {
\r
4318 * @Override public void actionPerformed(ActionEvent e) {
\r
4319 * jalview.datamodel.AlignmentView
\r
4320 * .testSelectionViews(af.viewport.getAlignment(),
\r
4321 * af.viewport.getColumnSelection(), af.viewport.selectionGroup); }
\r
4323 * }); webService.add(testAlView);
\r
4325 // TODO: refactor to RestClient discoverer and merge menu entries for
\r
4326 // rest-style services with other types of analysis/calculation service
\r
4327 // SHmmr test client - still being implemented.
\r
4328 // DEBUG - alignmentView
\r
4330 for (jalview.ws.rest.RestClient client : jalview.ws.rest.RestClient
\r
4331 .getRestClients())
\r
4333 client.attachWSMenuEntry(
\r
4334 JvSwingUtils.findOrCreateMenu(webService, client.getAction()),
\r
4338 if (Cache.getDefault("SHOW_ENFIN_SERVICES", true))
\r
4340 jalview.ws.EnfinEnvision2OneWay.getInstance().attachWSMenuEntry(
\r
4341 webService, this);
\r
4346 * public void vamsasStore_actionPerformed(ActionEvent e) { JalviewFileChooser
\r
4347 * chooser = new JalviewFileChooser(jalview.bin.Cache.
\r
4348 * getProperty("LAST_DIRECTORY"));
\r
4350 * chooser.setFileView(new JalviewFileView()); chooser.setDialogTitle("Export
\r
4351 * to Vamsas file"); chooser.setToolTipText("Export");
\r
4353 * int value = chooser.showSaveDialog(this);
\r
4355 * if (value == JalviewFileChooser.APPROVE_OPTION) {
\r
4356 * jalview.io.VamsasDatastore vs = new jalview.io.VamsasDatastore(viewport);
\r
4357 * //vs.store(chooser.getSelectedFile().getAbsolutePath() ); vs.storeJalview(
\r
4358 * chooser.getSelectedFile().getAbsolutePath(), this); } }
\r
4361 * prototype of an automatically enabled/disabled analysis function
\r
4364 protected void setShowProductsEnabled()
\r
4366 SequenceI[] selection = viewport.getSequenceSelection();
\r
4367 if (canShowProducts(selection, viewport.getSelectionGroup() != null,
\r
4368 viewport.getAlignment().getDataset()))
\r
4370 showProducts.setEnabled(true);
\r
4375 showProducts.setEnabled(false);
\r
4380 * search selection for sequence xRef products and build the show products
\r
4383 * @param selection
\r
4385 * @return true if showProducts menu should be enabled.
\r
4387 public boolean canShowProducts(SequenceI[] selection,
\r
4388 boolean isRegionSelection, Alignment dataset)
\r
4390 boolean showp = false;
\r
4393 showProducts.removeAll();
\r
4394 final boolean dna = viewport.getAlignment().isNucleotide();
\r
4395 final Alignment ds = dataset;
\r
4396 String[] ptypes = (selection == null || selection.length == 0) ? null
\r
4397 : CrossRef.findSequenceXrefTypes(dna, selection, dataset);
\r
4398 // Object[] prods =
\r
4399 // CrossRef.buildXProductsList(viewport.getAlignment().isNucleotide(),
\r
4400 // selection, dataset, true);
\r
4401 final SequenceI[] sel = selection;
\r
4402 for (int t = 0; ptypes != null && t < ptypes.length; t++)
\r
4405 final boolean isRegSel = isRegionSelection;
\r
4406 final AlignFrame af = this;
\r
4407 final String source = ptypes[t];
\r
4408 JMenuItem xtype = new JMenuItem(ptypes[t]);
\r
4409 xtype.addActionListener(new ActionListener()
\r
4413 public void actionPerformed(ActionEvent e)
\r
4415 // TODO: new thread for this call with vis-delay
\r
4416 af.showProductsFor(af.viewport.getSequenceSelection(), ds,
\r
4417 isRegSel, dna, source);
\r
4421 showProducts.add(xtype);
\r
4423 showProducts.setVisible(showp);
\r
4424 showProducts.setEnabled(showp);
\r
4425 } catch (Exception e)
\r
4427 jalview.bin.Cache.log
\r
4428 .warn("canTranslate threw an exception - please report to help@jalview.org",
\r
4435 protected void showProductsFor(SequenceI[] sel, Alignment ds,
\r
4436 boolean isRegSel, boolean dna, String source)
\r
4438 final boolean fisRegSel = isRegSel;
\r
4439 final boolean fdna = dna;
\r
4440 final String fsrc = source;
\r
4441 final AlignFrame ths = this;
\r
4442 final SequenceI[] fsel = sel;
\r
4443 Runnable foo = new Runnable()
\r
4449 final long sttime = System.currentTimeMillis();
\r
4450 ths.setProgressBar("Searching for sequences from " + fsrc, sttime);
\r
4453 Alignment ds = ths.getViewport().getAlignment().getDataset(); // update
\r
4457 Alignment prods = CrossRef
\r
4458 .findXrefSequences(fsel, fdna, fsrc, ds);
\r
4459 if (prods != null)
\r
4461 SequenceI[] sprods = new SequenceI[prods.getHeight()];
\r
4462 for (int s = 0; s < sprods.length; s++)
\r
4464 sprods[s] = (prods.getSequenceAt(s)).deriveSequence();
\r
4465 if (ds.getSequences() == null
\r
4466 || !ds.getSequences().contains(
\r
4467 sprods[s].getDatasetSequence()))
\r
4468 ds.addSequence(sprods[s].getDatasetSequence());
\r
4469 sprods[s].updatePDBIds();
\r
4471 Alignment al = new Alignment(sprods);
\r
4472 AlignedCodonFrame[] cf = prods.getCodonFrames();
\r
4473 al.setDataset(ds);
\r
4474 for (int s = 0; cf != null && s < cf.length; s++)
\r
4476 al.addCodonFrame(cf[s]);
\r
4479 AlignFrame naf = new AlignFrame(al, DEFAULT_WIDTH,
\r
4481 String newtitle = "" + ((fdna) ? "Proteins " : "Nucleotides ")
\r
4482 + " for " + ((fisRegSel) ? "selected region of " : "")
\r
4484 Desktop.addInternalFrame(naf, newtitle, DEFAULT_WIDTH,
\r
4489 System.err.println("No Sequences generated for xRef type "
\r
4492 } catch (Exception e)
\r
4494 jalview.bin.Cache.log.error(
\r
4495 "Exception when finding crossreferences", e);
\r
4496 } catch (OutOfMemoryError e)
\r
4498 new OOMWarning("whilst fetching crossreferences", e);
\r
4501 jalview.bin.Cache.log.error("Error when finding crossreferences",
\r
4504 ths.setProgressBar("Finished searching for sequences from " + fsrc,
\r
4509 Thread frunner = new Thread(foo);
\r
4513 public boolean canShowTranslationProducts(SequenceI[] selection,
\r
4514 AlignmentI alignment)
\r
4519 return (jalview.analysis.Dna.canTranslate(selection,
\r
4520 viewport.getViewAsVisibleContigs(true)));
\r
4521 } catch (Exception e)
\r
4523 jalview.bin.Cache.log
\r
4524 .warn("canTranslate threw an exception - please report to help@jalview.org",
\r
4531 public void showProducts_actionPerformed(ActionEvent e)
\r
4533 // /////////////////////////////
\r
4534 // Collect Data to be translated/transferred
\r
4536 SequenceI[] selection = viewport.getSequenceSelection();
\r
4537 AlignmentI al = null;
\r
4540 al = jalview.analysis.Dna.CdnaTranslate(selection, viewport
\r
4541 .getViewAsVisibleContigs(true), viewport.getGapCharacter(),
\r
4542 viewport.getAlignment().getDataset());
\r
4543 } catch (Exception ex)
\r
4546 jalview.bin.Cache.log.debug("Exception during translation.", ex);
\r
4551 .showMessageDialog(
\r
4553 MessageManager.getString("label.select_at_least_three_bases_in_at_least_one_sequence_to_cDNA_translation"),
\r
4554 MessageManager.getString("label.translation_failed"), JOptionPane.WARNING_MESSAGE);
\r
4558 AlignFrame af = new AlignFrame(al, DEFAULT_WIDTH, DEFAULT_HEIGHT);
\r
4559 Desktop.addInternalFrame(af, MessageManager.formatMessage("label.translation_of_params", new String[]{this.getTitle()}),
\r
4560 DEFAULT_WIDTH, DEFAULT_HEIGHT);
\r
4565 public void showTranslation_actionPerformed(ActionEvent e)
\r
4567 // /////////////////////////////
\r
4568 // Collect Data to be translated/transferred
\r
4570 SequenceI[] selection = viewport.getSequenceSelection();
\r
4571 String[] seqstring = viewport.getViewAsString(true);
\r
4572 AlignmentI al = null;
\r
4575 al = jalview.analysis.Dna.CdnaTranslate(selection, seqstring,
\r
4576 viewport.getViewAsVisibleContigs(true), viewport
\r
4577 .getGapCharacter(), viewport.getAlignment()
\r
4578 .getAlignmentAnnotation(), viewport.getAlignment()
\r
4579 .getWidth(), viewport.getAlignment().getDataset());
\r
4580 } catch (Exception ex)
\r
4583 jalview.bin.Cache.log.error("Exception during translation. Please report this !", ex);
\r
4585 .showMessageDialog(
\r
4587 MessageManager.getString("label.error_when_translating_sequences_submit_bug_report"),
\r
4588 MessageManager.getString("label.implementation_error") + MessageManager.getString("translation_failed"), JOptionPane.ERROR_MESSAGE);
\r
4594 .showMessageDialog(
\r
4596 MessageManager.getString("label.select_at_least_three_bases_in_at_least_one_sequence_to_cDNA_translation"),
\r
4597 MessageManager.getString("label.translation_failed"), JOptionPane.WARNING_MESSAGE);
\r
4601 AlignFrame af = new AlignFrame(al, DEFAULT_WIDTH, DEFAULT_HEIGHT);
\r
4602 Desktop.addInternalFrame(af, MessageManager.formatMessage("label.translation_of_params", new String[]{this.getTitle()}),
\r
4603 DEFAULT_WIDTH, DEFAULT_HEIGHT);
\r
4608 * Try to load a features file onto the alignment.
\r
4611 * contents or path to retrieve file
\r
4613 * access mode of file (see jalview.io.AlignFile)
\r
4614 * @return true if features file was parsed corectly.
\r
4616 public boolean parseFeaturesFile(String file, String type)
\r
4618 boolean featuresFile = false;
\r
4621 featuresFile = new FeaturesFile(file, type).parse(viewport
\r
4622 .getAlignment().getDataset(), alignPanel.seqPanel.seqCanvas
\r
4623 .getFeatureRenderer().featureColours, false,
\r
4624 jalview.bin.Cache.getDefault("RELAXEDSEQIDMATCHING", false));
\r
4625 } catch (Exception ex)
\r
4627 ex.printStackTrace();
\r
4632 viewport.showSequenceFeatures = true;
\r
4633 showSeqFeatures.setSelected(true);
\r
4634 if (alignPanel.seqPanel.seqCanvas.fr != null)
\r
4636 // update the min/max ranges where necessary
\r
4637 alignPanel.seqPanel.seqCanvas.fr.findAllFeatures(true);
\r
4639 if (featureSettings != null)
\r
4641 featureSettings.setTableData();
\r
4643 alignPanel.paintAlignment(true);
\r
4646 return featuresFile;
\r
4650 public void dragEnter(DropTargetDragEvent evt)
\r
4655 public void dragExit(DropTargetEvent evt)
\r
4660 public void dragOver(DropTargetDragEvent evt)
\r
4665 public void dropActionChanged(DropTargetDragEvent evt)
\r
4670 public void drop(DropTargetDropEvent evt)
\r
4672 Transferable t = evt.getTransferable();
\r
4673 java.util.List files = null;
\r
4677 DataFlavor uriListFlavor = new DataFlavor(
\r
4678 "text/uri-list;class=java.lang.String");
\r
4679 if (t.isDataFlavorSupported(DataFlavor.javaFileListFlavor))
\r
4681 // Works on Windows and MacOSX
\r
4682 evt.acceptDrop(DnDConstants.ACTION_COPY_OR_MOVE);
\r
4683 files = (java.util.List) t
\r
4684 .getTransferData(DataFlavor.javaFileListFlavor);
\r
4686 else if (t.isDataFlavorSupported(uriListFlavor))
\r
4688 // This is used by Unix drag system
\r
4689 evt.acceptDrop(DnDConstants.ACTION_COPY_OR_MOVE);
\r
4690 String data = (String) t.getTransferData(uriListFlavor);
\r
4691 files = new java.util.ArrayList(1);
\r
4692 for (java.util.StringTokenizer st = new java.util.StringTokenizer(
\r
4693 data, "\r\n"); st.hasMoreTokens();)
\r
4695 String s = st.nextToken();
\r
4696 if (s.startsWith("#"))
\r
4698 // the line is a comment (as per the RFC 2483)
\r
4702 java.net.URI uri = new java.net.URI(s);
\r
4703 // check to see if we can handle this kind of URI
\r
4704 if (uri.getScheme().toLowerCase().startsWith("http"))
\r
4706 files.add(uri.toString());
\r
4710 // otherwise preserve old behaviour: catch all for file objects
\r
4711 java.io.File file = new java.io.File(uri);
\r
4712 files.add(file.toString());
\r
4716 } catch (Exception e)
\r
4718 e.printStackTrace();
\r
4720 if (files != null)
\r
4724 // check to see if any of these files have names matching sequences in
\r
4726 SequenceIdMatcher idm = new SequenceIdMatcher(viewport
\r
4727 .getAlignment().getSequencesArray());
\r
4729 * Object[] { String,SequenceI}
\r
4731 ArrayList<Object[]> filesmatched = new ArrayList<Object[]>();
\r
4732 ArrayList<String> filesnotmatched = new ArrayList<String>();
\r
4733 for (int i = 0; i < files.size(); i++)
\r
4735 String file = files.get(i).toString();
\r
4736 String pdbfn = "";
\r
4737 String protocol = FormatAdapter.checkProtocol(file);
\r
4738 if (protocol == jalview.io.FormatAdapter.FILE)
\r
4740 File fl = new File(file);
\r
4741 pdbfn = fl.getName();
\r
4743 else if (protocol == jalview.io.FormatAdapter.URL)
\r
4745 URL url = new URL(file);
\r
4746 pdbfn = url.getFile();
\r
4748 if (pdbfn.length() > 0)
\r
4750 // attempt to find a match in the alignment
\r
4751 SequenceI[] mtch = idm.findAllIdMatches(pdbfn);
\r
4752 int l = 0, c = pdbfn.indexOf(".");
\r
4753 while (mtch == null && c != -1)
\r
4758 } while ((c = pdbfn.indexOf(".", l)) > l);
\r
4761 pdbfn = pdbfn.substring(0, l);
\r
4763 mtch = idm.findAllIdMatches(pdbfn);
\r
4767 String type = null;
\r
4770 type = new IdentifyFile().Identify(file, protocol);
\r
4771 } catch (Exception ex)
\r
4777 if (type.equalsIgnoreCase("PDB"))
\r
4779 filesmatched.add(new Object[]
\r
4780 { file, protocol, mtch });
\r
4785 // File wasn't named like one of the sequences or wasn't a PDB file.
\r
4786 filesnotmatched.add(file);
\r
4789 int assocfiles = 0;
\r
4790 if (filesmatched.size() > 0)
\r
4792 if (Cache.getDefault("AUTOASSOCIATE_PDBANDSEQS", false)
\r
4794 .showConfirmDialog(
\r
4796 MessageManager.formatMessage("label.automatically_associate_pdb_files_with_sequences_same_name",
\r
4797 new String[]{Integer.valueOf(filesmatched.size()).toString()}),
\r
4798 MessageManager.getString("label.automatically_associate_pdb_files_by_name"),
\r
4799 JOptionPane.YES_NO_OPTION) == JOptionPane.YES_OPTION)
\r
4802 for (Object[] fm : filesmatched)
\r
4804 // try and associate
\r
4805 // TODO: may want to set a standard ID naming formalism for
\r
4806 // associating PDB files which have no IDs.
\r
4807 for (SequenceI toassoc : (SequenceI[]) fm[2])
\r
4809 PDBEntry pe = new AssociatePdbFileWithSeq()
\r
4810 .associatePdbWithSeq((String) fm[0],
\r
4811 (String) fm[1], toassoc, false);
\r
4814 System.err.println("Associated file : "
\r
4815 + ((String) fm[0]) + " with "
\r
4816 + toassoc.getDisplayId(true));
\r
4820 alignPanel.paintAlignment(true);
\r
4824 if (filesnotmatched.size() > 0)
\r
4826 if (assocfiles > 0
\r
4827 && (Cache.getDefault(
\r
4828 "AUTOASSOCIATE_PDBANDSEQS_IGNOREOTHERS", false) || JOptionPane
\r
4829 .showConfirmDialog(
\r
4831 MessageManager.formatMessage("label.ignore_unmatched_dropped_files_info", new String[]{Integer.valueOf(filesnotmatched.size()).toString()}),
\r
4832 MessageManager.getString("label.ignore_unmatched_dropped_files"),
\r
4833 JOptionPane.YES_NO_OPTION) == JOptionPane.YES_OPTION))
\r
4837 for (String fn : filesnotmatched)
\r
4839 loadJalviewDataFile(fn, null, null, null);
\r
4843 } catch (Exception ex)
\r
4845 ex.printStackTrace();
\r
4851 * Attempt to load a "dropped" file or URL string: First by testing whether
\r
4852 * it's and Annotation file, then a JNet file, and finally a features file. If
\r
4853 * all are false then the user may have dropped an alignment file onto this
\r
4857 * either a filename or a URL string.
\r
4859 public void loadJalviewDataFile(String file, String protocol,
\r
4860 String format, SequenceI assocSeq)
\r
4864 if (protocol == null)
\r
4866 protocol = jalview.io.FormatAdapter.checkProtocol(file);
\r
4868 // if the file isn't identified, or not positively identified as some
\r
4869 // other filetype (PFAM is default unidentified alignment file type) then
\r
4870 // try to parse as annotation.
\r
4871 boolean isAnnotation = (format == null || format
\r
4872 .equalsIgnoreCase("PFAM")) ? new AnnotationFile()
\r
4873 .readAnnotationFile(viewport.getAlignment(), file, protocol)
\r
4876 if (!isAnnotation)
\r
4878 // first see if its a T-COFFEE score file
\r
4879 TCoffeeScoreFile tcf = null;
\r
4882 tcf = new TCoffeeScoreFile(file, protocol);
\r
4883 if (tcf.isValid())
\r
4885 if (tcf.annotateAlignment(viewport.getAlignment(), true))
\r
4887 tcoffeeColour.setEnabled(true);
\r
4888 tcoffeeColour.setSelected(true);
\r
4889 changeColour(new TCoffeeColourScheme(viewport.getAlignment()));
\r
4890 isAnnotation = true;
\r
4891 statusBar.setText(MessageManager.getString("label.successfully_pasted_tcoffee_scores_to_alignment"));
\r
4895 // some problem - if no warning its probable that the ID matching
\r
4896 // process didn't work
\r
4898 .showMessageDialog(
\r
4900 tcf.getWarningMessage() == null ? MessageManager.getString("label.check_file_matches_sequence_ids_alignment")
\r
4901 : tcf.getWarningMessage(),
\r
4902 MessageManager.getString("label.problem_reading_tcoffee_score_file"),
\r
4903 JOptionPane.WARNING_MESSAGE);
\r
4910 } catch (Exception x)
\r
4913 .debug("Exception when processing data source as T-COFFEE score file",
\r
4919 // try to see if its a JNet 'concise' style annotation file *before*
\r
4921 // try to parse it as a features file
\r
4922 if (format == null)
\r
4924 format = new IdentifyFile().Identify(file, protocol);
\r
4926 if (format.equalsIgnoreCase("JnetFile"))
\r
4928 jalview.io.JPredFile predictions = new jalview.io.JPredFile(
\r
4930 new JnetAnnotationMaker().add_annotation(predictions,
\r
4931 viewport.getAlignment(), 0, false);
\r
4932 isAnnotation = true;
\r
4937 * if (format.equalsIgnoreCase("PDB")) {
\r
4939 * String pdbfn = ""; // try to match up filename with sequence id
\r
4940 * try { if (protocol == jalview.io.FormatAdapter.FILE) { File fl =
\r
4941 * new File(file); pdbfn = fl.getName(); } else if (protocol ==
\r
4942 * jalview.io.FormatAdapter.URL) { URL url = new URL(file); pdbfn =
\r
4943 * url.getFile(); } } catch (Exception e) { } ; if (assocSeq ==
\r
4944 * null) { SequenceIdMatcher idm = new SequenceIdMatcher(viewport
\r
4945 * .getAlignment().getSequencesArray()); if (pdbfn.length() > 0) {
\r
4946 * // attempt to find a match in the alignment SequenceI mtch =
\r
4947 * idm.findIdMatch(pdbfn); int l = 0, c = pdbfn.indexOf("."); while
\r
4948 * (mtch == null && c != -1) { while ((c = pdbfn.indexOf(".", l)) >
\r
4949 * l) { l = c; } if (l > -1) { pdbfn = pdbfn.substring(0, l); } mtch
\r
4950 * = idm.findIdMatch(pdbfn); } if (mtch != null) { // try and
\r
4951 * associate // prompt ? PDBEntry pe = new AssociatePdbFileWithSeq()
\r
4952 * .associatePdbWithSeq(file, protocol, mtch, true); if (pe != null)
\r
4953 * { System.err.println("Associated file : " + file + " with " +
\r
4954 * mtch.getDisplayId(true)); alignPanel.paintAlignment(true); } } //
\r
4955 * TODO: maybe need to load as normal otherwise return; } }
\r
4957 // try to parse it as a features file
\r
4958 boolean isGroupsFile = parseFeaturesFile(file, protocol);
\r
4959 // if it wasn't a features file then we just treat it as a general
\r
4960 // alignment file to load into the current view.
\r
4961 if (!isGroupsFile)
\r
4963 new FileLoader().LoadFile(viewport, file, protocol, format);
\r
4967 alignPanel.paintAlignment(true);
\r
4975 alignPanel.adjustAnnotationHeight();
\r
4976 viewport.updateSequenceIdColours();
\r
4977 buildSortByAnnotationScoresMenu();
\r
4978 alignPanel.paintAlignment(true);
\r
4980 } catch (Exception ex)
\r
4982 ex.printStackTrace();
\r
4983 } catch (OutOfMemoryError oom)
\r
4988 } catch (Exception x)
\r
4994 + (protocol != null ? (protocol.equals(FormatAdapter.PASTE) ? "from clipboard."
\r
4995 : "using " + protocol + " from " + file)
\r
4997 + (format != null ? "(parsing as '" + format
\r
4998 + "' file)" : ""), oom, Desktop.desktop);
\r
5003 public void tabSelectionChanged(int index)
\r
5007 alignPanel = (AlignmentPanel) alignPanels.elementAt(index);
\r
5008 viewport = alignPanel.av;
\r
5009 avc.setViewportAndAlignmentPanel(viewport, alignPanel);
\r
5010 setMenusFromViewport(viewport);
\r
5015 public void tabbedPane_mousePressed(MouseEvent e)
\r
5017 if (SwingUtilities.isRightMouseButton(e))
\r
5019 String reply = JOptionPane.showInternalInputDialog(this,
\r
5020 MessageManager.getString("label.enter_view_name"), MessageManager.getString("label.enter_view_name"),
\r
5021 JOptionPane.QUESTION_MESSAGE);
\r
5023 if (reply != null)
\r
5025 viewport.viewName = reply;
\r
5026 tabbedPane.setTitleAt(tabbedPane.getSelectedIndex(), reply);
\r
5031 public AlignViewport getCurrentView()
\r
5037 * Open the dialog for regex description parsing.
\r
5040 protected void extractScores_actionPerformed(ActionEvent e)
\r
5042 ParseProperties pp = new jalview.analysis.ParseProperties(
\r
5043 viewport.getAlignment());
\r
5044 // TODO: verify regex and introduce GUI dialog for version 2.5
\r
5045 // if (pp.getScoresFromDescription("col", "score column ",
\r
5046 // "\\W*([-+]?\\d*\\.?\\d*e?-?\\d*)\\W+([-+]?\\d*\\.?\\d*e?-?\\d*)",
\r
5048 if (pp.getScoresFromDescription("description column",
\r
5049 "score in description column ", "\\W*([-+eE0-9.]+)", true) > 0)
\r
5051 buildSortByAnnotationScoresMenu();
\r
5059 * jalview.jbgui.GAlignFrame#showDbRefs_actionPerformed(java.awt.event.ActionEvent
\r
5063 protected void showDbRefs_actionPerformed(ActionEvent e)
\r
5065 viewport.setShowDbRefs(showDbRefsMenuitem.isSelected());
\r
5071 * @seejalview.jbgui.GAlignFrame#showNpFeats_actionPerformed(java.awt.event.
\r
5075 protected void showNpFeats_actionPerformed(ActionEvent e)
\r
5077 viewport.setShowNpFeats(showNpFeatsMenuitem.isSelected());
\r
5081 * find the viewport amongst the tabs in this alignment frame and close that
\r
5086 public boolean closeView(AlignViewport av)
\r
5088 if (viewport == av)
\r
5090 this.closeMenuItem_actionPerformed(false);
\r
5093 Component[] comp = tabbedPane.getComponents();
\r
5094 for (int i = 0; comp != null && i < comp.length; i++)
\r
5096 if (comp[i] instanceof AlignmentPanel)
\r
5098 if (((AlignmentPanel) comp[i]).av == av)
\r
5100 // close the view.
\r
5101 closeView((AlignmentPanel) comp[i]);
\r
5109 protected void build_fetchdbmenu(JMenu webService)
\r
5111 // Temporary hack - DBRef Fetcher always top level ws entry.
\r
5112 // TODO We probably want to store a sequence database checklist in
\r
5113 // preferences and have checkboxes.. rather than individual sources selected
\r
5115 final JMenu rfetch = new JMenu(MessageManager.getString("action.fetch_db_references"));
\r
5116 rfetch.setToolTipText(MessageManager.getString("label.retrieve_parse_sequence_database_records_alignment_or_selected_sequences"));
\r
5117 webService.add(rfetch);
\r
5119 JMenuItem fetchr = new JMenuItem(MessageManager.getString("label.standard_databases"));
\r
5120 fetchr.setToolTipText(MessageManager.getString("label.fetch_embl_uniprot"));
\r
5121 fetchr.addActionListener(new ActionListener()
\r
5125 public void actionPerformed(ActionEvent e)
\r
5127 new Thread(new Runnable()
\r
5133 new jalview.ws.DBRefFetcher(alignPanel.av
\r
5134 .getSequenceSelection(), alignPanel.alignFrame)
\r
5135 .fetchDBRefs(false);
\r
5142 rfetch.add(fetchr);
\r
5143 final AlignFrame me = this;
\r
5144 new Thread(new Runnable()
\r
5149 final jalview.ws.SequenceFetcher sf = SequenceFetcher
\r
5150 .getSequenceFetcherSingleton(me);
\r
5151 javax.swing.SwingUtilities.invokeLater(new Runnable()
\r
5156 String[] dbclasses = sf.getOrderedSupportedSources();
\r
5157 // sf.getDbInstances(jalview.ws.dbsources.DasSequenceSource.class);
\r
5158 // jalview.util.QuickSort.sort(otherdb, otherdb);
\r
5159 List<DbSourceProxy> otherdb;
\r
5160 JMenu dfetch = new JMenu();
\r
5161 JMenu ifetch = new JMenu();
\r
5162 JMenuItem fetchr = null;
\r
5163 int comp = 0, icomp = 0, mcomp = 15;
\r
5164 String mname = null;
\r
5166 for (String dbclass : dbclasses)
\r
5168 otherdb = sf.getSourceProxy(dbclass);
\r
5169 // add a single entry for this class, or submenu allowing 'fetch
\r
5170 // all' or pick one
\r
5171 if (otherdb == null || otherdb.size() < 1)
\r
5175 // List<DbSourceProxy> dbs=otherdb;
\r
5176 // otherdb=new ArrayList<DbSourceProxy>();
\r
5177 // for (DbSourceProxy db:dbs)
\r
5179 // if (!db.isA(DBRefSource.ALIGNMENTDB)
\r
5181 if (mname == null)
\r
5183 mname = "From " + dbclass;
\r
5185 if (otherdb.size() == 1)
\r
5187 final DbSourceProxy[] dassource = otherdb
\r
5188 .toArray(new DbSourceProxy[0]);
\r
5189 DbSourceProxy src = otherdb.get(0);
\r
5190 fetchr = new JMenuItem(src.getDbSource());
\r
5191 fetchr.addActionListener(new ActionListener()
\r
5195 public void actionPerformed(ActionEvent e)
\r
5197 new Thread(new Runnable()
\r
5203 new jalview.ws.DBRefFetcher(alignPanel.av
\r
5204 .getSequenceSelection(),
\r
5205 alignPanel.alignFrame, dassource)
\r
5206 .fetchDBRefs(false);
\r
5212 fetchr.setToolTipText("<html>"
\r
5213 + JvSwingUtils.wrapTooltip("Retrieve from "
\r
5214 + src.getDbName()) + "<html>");
\r
5215 dfetch.add(fetchr);
\r
5220 final DbSourceProxy[] dassource = otherdb
\r
5221 .toArray(new DbSourceProxy[0]);
\r
5222 // fetch all entry
\r
5223 DbSourceProxy src = otherdb.get(0);
\r
5224 fetchr = new JMenuItem(MessageManager.formatMessage("label.fetch_all_param", new String[]{src.getDbSource()}));
\r
5225 fetchr.addActionListener(new ActionListener()
\r
5228 public void actionPerformed(ActionEvent e)
\r
5230 new Thread(new Runnable()
\r
5236 new jalview.ws.DBRefFetcher(alignPanel.av
\r
5237 .getSequenceSelection(),
\r
5238 alignPanel.alignFrame, dassource)
\r
5239 .fetchDBRefs(false);
\r
5245 fetchr.setToolTipText("<html>"
\r
5246 + JvSwingUtils.wrapTooltip("Retrieve from all "
\r
5247 + otherdb.size() + " sources in "
\r
5248 + src.getDbSource() + "<br>First is :"
\r
5249 + src.getDbName()) + "<html>");
\r
5250 dfetch.add(fetchr);
\r
5252 // and then build the rest of the individual menus
\r
5253 ifetch = new JMenu("Sources from " + src.getDbSource());
\r
5255 String imname = null;
\r
5257 for (DbSourceProxy sproxy : otherdb)
\r
5259 String dbname = sproxy.getDbName();
\r
5260 String sname = dbname.length() > 5 ? dbname.substring(0,
\r
5261 5) + "..." : dbname;
\r
5262 String msname = dbname.length() > 10 ? dbname.substring(
\r
5263 0, 10) + "..." : dbname;
\r
5264 if (imname == null)
\r
5266 imname = "from '" + sname + "'";
\r
5268 fetchr = new JMenuItem(msname);
\r
5269 final DbSourceProxy[] dassrc =
\r
5271 fetchr.addActionListener(new ActionListener()
\r
5275 public void actionPerformed(ActionEvent e)
\r
5277 new Thread(new Runnable()
\r
5283 new jalview.ws.DBRefFetcher(alignPanel.av
\r
5284 .getSequenceSelection(),
\r
5285 alignPanel.alignFrame, dassrc)
\r
5286 .fetchDBRefs(false);
\r
5292 fetchr.setToolTipText("<html>"
\r
5293 + JvSwingUtils.wrapTooltip("Retrieve from "
\r
5294 + dbname) + "</html>");
\r
5295 ifetch.add(fetchr);
\r
5297 if (++icomp >= mcomp || i == (otherdb.size()))
\r
5299 ifetch.setText(MessageManager.formatMessage("label.source_to_target",new String[]{imname,sname}));
\r
5300 dfetch.add(ifetch);
\r
5301 ifetch = new JMenu();
\r
5309 if (comp >= mcomp || dbi >= (dbclasses.length))
\r
5311 dfetch.setText(MessageManager.formatMessage("label.source_to_target",new String[]{mname,dbclass}));
\r
5312 rfetch.add(dfetch);
\r
5313 dfetch = new JMenu();
\r
5326 * Left justify the whole alignment.
\r
5329 protected void justifyLeftMenuItem_actionPerformed(ActionEvent e)
\r
5331 AlignmentI al = viewport.getAlignment();
\r
5332 al.justify(false);
\r
5333 viewport.firePropertyChange("alignment", null, al);
\r
5337 * Right justify the whole alignment.
\r
5340 protected void justifyRightMenuItem_actionPerformed(ActionEvent e)
\r
5342 AlignmentI al = viewport.getAlignment();
\r
5344 viewport.firePropertyChange("alignment", null, al);
\r
5347 public void setShowSeqFeatures(boolean b)
\r
5349 showSeqFeatures.setSelected(true);
\r
5350 viewport.setShowSequenceFeatures(true);
\r
5357 * jalview.jbgui.GAlignFrame#showUnconservedMenuItem_actionPerformed(java.
\r
5358 * awt.event.ActionEvent)
\r
5361 protected void showUnconservedMenuItem_actionPerformed(ActionEvent e)
\r
5363 viewport.setShowUnconserved(showNonconservedMenuItem.getState());
\r
5364 alignPanel.paintAlignment(true);
\r
5371 * jalview.jbgui.GAlignFrame#showGroupConsensus_actionPerformed(java.awt.event
\r
5375 protected void showGroupConsensus_actionPerformed(ActionEvent e)
\r
5377 viewport.setShowGroupConsensus(showGroupConsensus.getState());
\r
5378 alignPanel.updateAnnotation(applyAutoAnnotationSettings.getState());
\r
5386 * jalview.jbgui.GAlignFrame#showGroupConservation_actionPerformed(java.awt
\r
5387 * .event.ActionEvent)
\r
5390 protected void showGroupConservation_actionPerformed(ActionEvent e)
\r
5392 viewport.setShowGroupConservation(showGroupConservation.getState());
\r
5393 alignPanel.updateAnnotation(applyAutoAnnotationSettings.getState());
\r
5400 * jalview.jbgui.GAlignFrame#showConsensusHistogram_actionPerformed(java.awt
\r
5401 * .event.ActionEvent)
\r
5404 protected void showConsensusHistogram_actionPerformed(ActionEvent e)
\r
5406 viewport.setShowConsensusHistogram(showConsensusHistogram.getState());
\r
5407 alignPanel.updateAnnotation(applyAutoAnnotationSettings.getState());
\r
5414 * jalview.jbgui.GAlignFrame#showConsensusProfile_actionPerformed(java.awt
\r
5415 * .event.ActionEvent)
\r
5418 protected void showSequenceLogo_actionPerformed(ActionEvent e)
\r
5420 viewport.setShowSequenceLogo(showSequenceLogo.getState());
\r
5421 alignPanel.updateAnnotation(applyAutoAnnotationSettings.getState());
\r
5425 protected void normaliseSequenceLogo_actionPerformed(ActionEvent e)
\r
5427 showSequenceLogo.setState(true);
\r
5428 viewport.setShowSequenceLogo(true);
\r
5429 viewport.setNormaliseSequenceLogo(normaliseSequenceLogo.getState());
\r
5430 alignPanel.updateAnnotation(applyAutoAnnotationSettings.getState());
\r
5434 protected void applyAutoAnnotationSettings_actionPerformed(ActionEvent e)
\r
5436 alignPanel.updateAnnotation(applyAutoAnnotationSettings.getState());
\r
5443 * jalview.jbgui.GAlignFrame#makeGrpsFromSelection_actionPerformed(java.awt
\r
5444 * .event.ActionEvent)
\r
5447 protected void makeGrpsFromSelection_actionPerformed(ActionEvent e)
\r
5449 if (avc.makeGroupsFromSelection()) {
\r
5450 PaintRefresher.Refresh(this, viewport.getSequenceSetId());
\r
5451 alignPanel.updateAnnotation();
\r
5452 alignPanel.paintAlignment(true);
\r
5457 protected void createGroup_actionPerformed(ActionEvent e)
\r
5459 if (avc.createGroup())
\r
5461 alignPanel.alignmentChanged();
\r
5466 protected void unGroup_actionPerformed(ActionEvent e)
\r
5468 if (avc.unGroup())
\r
5470 alignPanel.alignmentChanged();
\r
5475 * make the given alignmentPanel the currently selected tab
\r
5477 * @param alignmentPanel
\r
5479 public void setDisplayedView(AlignmentPanel alignmentPanel)
\r
5481 if (!viewport.getSequenceSetId().equals(
\r
5482 alignmentPanel.av.getSequenceSetId()))
\r
5485 "Implementation error: cannot show a view from another alignment in an AlignFrame.");
\r
5487 if (tabbedPane != null
\r
5488 & alignPanels.indexOf(alignmentPanel) != tabbedPane
\r
5489 .getSelectedIndex())
\r
5491 tabbedPane.setSelectedIndex(alignPanels.indexOf(alignmentPanel));
\r
5496 class PrintThread extends Thread
\r
5498 AlignmentPanel ap;
\r
5500 public PrintThread(AlignmentPanel ap)
\r
5505 static PageFormat pf;
\r
5510 PrinterJob printJob = PrinterJob.getPrinterJob();
\r
5514 printJob.setPrintable(ap, pf);
\r
5518 printJob.setPrintable(ap);
\r
5521 if (printJob.printDialog())
\r
5526 } catch (Exception PrintException)
\r
5528 PrintException.printStackTrace();
\r