Clover icon

Coverage Report

  1. Project Clover database Thu Dec 4 2025 14:43:25 GMT
  2. Package jalview.appletgui

File AlignFrame.java

 

Coverage histogram

../../img/srcFileCovDistChart0.png
60% of files have more coverage

Code metrics

686
1,723
133
2
4,399
3,512
572
0.33
12.95
66.5
4.3

Classes

Class Line # Actions
AlignFrame 123 1,701 570
0.00%
AlignFrame.AboutPanel 3024 22 2
0.00%
 

Contributing tests

No tests hitting this source file were found.

Source view

1    /*
2    * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
3    * Copyright (C) $$Year-Rel$$ The Jalview Authors
4    *
5    * This file is part of Jalview.
6    *
7    * Jalview is free software: you can redistribute it and/or
8    * modify it under the terms of the GNU General Public License
9    * as published by the Free Software Foundation, either version 3
10    * of the License, or (at your option) any later version.
11    *
12    * Jalview is distributed in the hope that it will be useful, but
13    * WITHOUT ANY WARRANTY; without even the implied warranty
14    * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
15    * PURPOSE. See the GNU General Public License for more details.
16    *
17    * You should have received a copy of the GNU General Public License
18    * along with Jalview. If not, see <http://www.gnu.org/licenses/>.
19    * The Jalview Authors are detailed in the 'AUTHORS' file.
20    */
21    package jalview.appletgui;
22   
23    import java.awt.BorderLayout;
24    import java.awt.Canvas;
25    import java.awt.CheckboxMenuItem;
26    import java.awt.Color;
27    import java.awt.FlowLayout;
28    import java.awt.Font;
29    import java.awt.FontMetrics;
30    import java.awt.Frame;
31    import java.awt.Graphics;
32    import java.awt.Label;
33    import java.awt.Menu;
34    import java.awt.MenuBar;
35    import java.awt.MenuItem;
36    import java.awt.Panel;
37    import java.awt.Rectangle;
38    import java.awt.event.ActionEvent;
39    import java.awt.event.ActionListener;
40    import java.awt.event.FocusEvent;
41    import java.awt.event.FocusListener;
42    import java.awt.event.ItemEvent;
43    import java.awt.event.ItemListener;
44    import java.awt.event.KeyEvent;
45    import java.awt.event.KeyListener;
46    import java.awt.event.WindowAdapter;
47    import java.awt.event.WindowEvent;
48    import java.io.IOException;
49    import java.io.UnsupportedEncodingException;
50    import java.net.URL;
51    import java.net.URLEncoder;
52    import java.util.Arrays;
53    import java.util.Deque;
54    import java.util.HashMap;
55    import java.util.List;
56    import java.util.Map;
57    import java.util.StringTokenizer;
58    import java.util.Vector;
59   
60    import org.jmol.viewer.Viewer;
61   
62    import jalview.analysis.AlignmentSorter;
63    import jalview.analysis.AnnotationSorter.SequenceAnnotationOrder;
64    import jalview.analysis.TreeBuilder;
65    import jalview.analysis.scoremodels.PIDModel;
66    import jalview.analysis.scoremodels.ScoreModels;
67    import jalview.api.AlignViewControllerGuiI;
68    import jalview.api.AlignViewControllerI;
69    import jalview.api.AlignViewportI;
70    import jalview.api.FeatureColourI;
71    import jalview.api.FeatureRenderer;
72    import jalview.api.FeatureSettingsControllerI;
73    import jalview.api.SequenceStructureBinding;
74    import jalview.bin.JalviewLite;
75    import jalview.commands.CommandI;
76    import jalview.commands.EditCommand;
77    import jalview.commands.EditCommand.Action;
78    import jalview.commands.OrderCommand;
79    import jalview.commands.RemoveGapColCommand;
80    import jalview.commands.RemoveGapsCommand;
81    import jalview.commands.SlideSequencesCommand;
82    import jalview.commands.TrimRegionCommand;
83    import jalview.datamodel.Alignment;
84    import jalview.datamodel.AlignmentAnnotation;
85    import jalview.datamodel.AlignmentI;
86    import jalview.datamodel.AlignmentOrder;
87    import jalview.datamodel.ColumnSelection;
88    import jalview.datamodel.HiddenColumns;
89    import jalview.datamodel.PDBEntry;
90    import jalview.datamodel.Sequence;
91    import jalview.datamodel.SequenceGroup;
92    import jalview.datamodel.SequenceI;
93    import jalview.io.AnnotationFile;
94    import jalview.io.AppletFormatAdapter;
95    import jalview.io.DataSourceType;
96    import jalview.io.FeaturesFile;
97    import jalview.io.FileFormat;
98    import jalview.io.FileFormatI;
99    import jalview.io.FileFormats;
100    import jalview.io.TCoffeeScoreFile;
101    import jalview.schemes.Blosum62ColourScheme;
102    import jalview.schemes.BuriedColourScheme;
103    import jalview.schemes.ClustalxColourScheme;
104    import jalview.schemes.ColourSchemeI;
105    import jalview.schemes.HelixColourScheme;
106    import jalview.schemes.HydrophobicColourScheme;
107    import jalview.schemes.NucleotideColourScheme;
108    import jalview.schemes.PIDColourScheme;
109    import jalview.schemes.PurinePyrimidineColourScheme;
110    import jalview.schemes.RNAHelicesColour;
111    import jalview.schemes.StrandColourScheme;
112    import jalview.schemes.TCoffeeColourScheme;
113    import jalview.schemes.TaylorColourScheme;
114    import jalview.schemes.TurnColourScheme;
115    import jalview.schemes.ZappoColourScheme;
116    import jalview.structure.StructureSelectionManager;
117    import jalview.structures.models.AAStructureBindingModel;
118    import jalview.util.MappingUtils;
119    import jalview.util.MessageManager;
120    import jalview.viewmodel.AlignmentViewport;
121    import jalview.viewmodel.ViewportRanges;
122   
 
123    public class AlignFrame extends EmbmenuFrame implements ActionListener,
124    ItemListener, KeyListener, AlignViewControllerGuiI
125    {
126    public AlignViewControllerI avc;
127   
128    public AlignmentPanel alignPanel;
129   
130    public AlignViewport viewport;
131   
132    // width and height may be overridden by applet parameters
133    int frameWidth = 700;
134   
135    int frameHeight = 500;
136   
137    String jalviewServletURL;
138   
139    /*
140    * Flag for showing autocalculated consensus above or below other consensus
141    * rows
142    */
143    private boolean showAutoCalculatedAbove;
144   
145    private SequenceAnnotationOrder annotationSortOrder;
146   
147    /**
148    * Constructor that creates the frame and adds it to the display.
149    *
150    * @param al
151    * @param applet
152    * @param title
153    * @param embedded
154    */
 
155  0 toggle public AlignFrame(AlignmentI al, JalviewLite applet, String title,
156    boolean embedded)
157    {
158  0 this(al, applet, title, embedded, true);
159    }
160   
161    /**
162    * Constructor that optionally allows the frame to be displayed or only
163    * created.
164    *
165    * @param al
166    * @param applet
167    * @param title
168    * @param embedded
169    * @param addToDisplay
170    */
 
171  0 toggle public AlignFrame(AlignmentI al, JalviewLite applet, String title,
172    boolean embedded, boolean addToDisplay)
173    {
174  0 this(al, null, null, applet, title, embedded, addToDisplay);
175    }
176   
 
177  0 toggle public AlignFrame(AlignmentI al, SequenceI[] hiddenSeqs,
178    HiddenColumns hidden, JalviewLite applet, String title,
179    boolean embedded)
180    {
181  0 this(al, hiddenSeqs, hidden, applet, title, embedded, true);
182    }
183   
 
184  0 toggle public AlignFrame(AlignmentI al, SequenceI[] hiddenSeqs,
185    HiddenColumns hidden, JalviewLite applet, String title,
186    boolean embedded, boolean addToDisplay)
187    {
188  0 if (applet != null)
189    {
190  0 jalviewServletURL = applet.getParameter("APPLICATION_URL");
191    }
192   
193  0 try
194    {
195  0 jbInit();
196    } catch (Exception ex)
197    {
198  0 ex.printStackTrace();
199    }
200    // need to get window geometry before we calculate alignment layout
201  0 if (applet != null)
202    {
203  0 String param;
204  0 try
205    {
206  0 param = applet.getParameter("windowWidth");
207  0 if (param != null)
208    {
209  0 int width = Integer.parseInt(param);
210  0 frameWidth = width;
211    }
212  0 param = applet.getParameter("windowHeight");
213  0 if (param != null)
214    {
215  0 int height = Integer.parseInt(param);
216  0 frameHeight = height;
217    }
218    } catch (Exception ex)
219    {
220    }
221    }
222  0 viewport = new AlignViewport(al, applet);
223   
224  0 if (hiddenSeqs != null && hiddenSeqs.length > 0)
225    {
226  0 viewport.hideSequence(hiddenSeqs);
227    }
228  0 if (hidden != null)
229    {
230  0 viewport.getAlignment().setHiddenColumns(hidden);
231    }
232  0 viewport.setScaleAboveWrapped(scaleAbove.getState());
233   
234  0 alignPanel = new AlignmentPanel(this, viewport);
235  0 avc = new jalview.controller.AlignViewController(this, viewport,
236    alignPanel);
237  0 viewport.updateConservation(alignPanel);
238  0 viewport.updateConsensus(alignPanel);
239  0 viewport.initInformationWorker(alignPanel);
240   
241  0 displayNonconservedMenuItem.setState(viewport.getShowUnconserved());
242  0 followMouseOverFlag.setState(viewport.isFollowHighlight());
243  0 showGroupConsensus.setState(viewport.isShowGroupConsensus());
244  0 showGroupConservation.setState(viewport.isShowGroupConservation());
245  0 showConsensusHistogram.setState(viewport.isShowConsensusHistogram());
246  0 showSequenceLogo.setState(viewport.isShowSequenceLogo());
247  0 normSequenceLogo.setState(viewport.isNormaliseSequenceLogo());
248  0 applyToAllGroups.setState(viewport.getColourAppliesToAllGroups());
249  0 annotationPanelMenuItem.setState(viewport.isShowAnnotation());
250  0 showAlignmentAnnotations.setEnabled(annotationPanelMenuItem.getState());
251  0 showSequenceAnnotations.setEnabled(annotationPanelMenuItem.getState());
252  0 showAlignmentAnnotations.setState(true);
253  0 showSequenceAnnotations.setState(false);
254   
255  0 seqLimits.setState(viewport.getShowJVSuffix());
256   
257  0 if (applet != null)
258    {
259  0 String param = applet.getParameter("sortBy");
260  0 if (param != null)
261    {
262  0 if (param.equalsIgnoreCase("Id"))
263    {
264  0 sortIDMenuItem_actionPerformed();
265    }
266  0 else if (param.equalsIgnoreCase("Pairwise Identity"))
267    {
268  0 sortPairwiseMenuItem_actionPerformed();
269    }
270  0 else if (param.equalsIgnoreCase("Length"))
271    {
272  0 sortLengthMenuItem_actionPerformed();
273    }
274    }
275   
276  0 param = applet.getParameter("wrap");
277  0 if (param != null)
278    {
279  0 if (param.equalsIgnoreCase("true"))
280    {
281  0 wrapMenuItem.setState(true);
282  0 wrapMenuItem_actionPerformed();
283    }
284    }
285  0 param = applet.getParameter("centrecolumnlabels");
286  0 if (param != null)
287    {
288  0 centreColumnLabelFlag.setState(true);
289  0 centreColumnLabelFlag_stateChanged();
290    }
291   
292    }
293  0 if (viewport.getAlignment().isNucleotide())
294    {
295  0 conservationMenuItem.setEnabled(false);
296  0 clustalColour.setEnabled(false);
297  0 BLOSUM62Colour.setEnabled(false);
298  0 zappoColour.setEnabled(false);
299  0 taylorColour.setEnabled(false);
300  0 hydrophobicityColour.setEnabled(false);
301  0 helixColour.setEnabled(false);
302  0 strandColour.setEnabled(false);
303  0 turnColour.setEnabled(false);
304  0 buriedColour.setEnabled(false);
305  0 viewport.updateStrucConsensus(alignPanel);
306  0 if (viewport.getAlignment().hasRNAStructure())
307    {
308  0 RNAHelixColour.setEnabled(true);
309    }
310    else
311    {
312  0 RNAHelixColour.setEnabled(false);
313    }
314    }
315    else
316    {
317  0 RNAHelixColour.setEnabled(false);
318  0 purinePyrimidineColour.setEnabled(false);
319  0 nucleotideColour.setEnabled(false);
320    }
321    // Some JVMS send keyevents to Top frame or lowest panel,
322    // Havent worked out why yet. So add to both this frame and seqCanvas for
323    // now
324  0 this.addKeyListener(this);
325  0 alignPanel.seqPanel.seqCanvas.addKeyListener(this);
326  0 alignPanel.idPanel.idCanvas.addKeyListener(this);
327  0 alignPanel.scalePanel.addKeyListener(this);
328  0 alignPanel.annotationPanel.addKeyListener(this);
329  0 alignPanel.annotationPanelHolder.addKeyListener(this);
330  0 alignPanel.annotationSpaceFillerHolder.addKeyListener(this);
331  0 alignPanel.alabels.addKeyListener(this);
332   
333  0 setAnnotationsVisibility();
334   
335  0 if (addToDisplay)
336    {
337  0 addToDisplay(embedded);
338    }
339    }
340   
341    /**
342    * @param embedded
343    */
 
344  0 toggle public void addToDisplay(boolean embedded)
345    {
346  0 createAlignFrameWindow(embedded);
347  0 validate();
348  0 alignPanel.adjustAnnotationHeight();
349  0 alignPanel.paintAlignment(true, true);
350    }
351   
 
352  0 toggle public AlignViewport getAlignViewport()
353    {
354  0 return viewport;
355    }
356   
 
357  0 toggle public SeqCanvas getSeqcanvas()
358    {
359  0 return alignPanel.seqPanel.seqCanvas;
360    }
361   
362    /**
363    * Load a features file onto the alignment
364    *
365    * @param file
366    * file URL, content, or other resolvable path
367    * @param type
368    * is protocol for accessing data referred to by file
369    */
370   
 
371  0 toggle public boolean parseFeaturesFile(String file, DataSourceType type)
372    {
373  0 return parseFeaturesFile(file, type, true);
374    }
375   
376    /**
377    * Load a features file onto the alignment
378    *
379    * @param file
380    * file URL, content, or other resolvable path
381    * @param sourceType
382    * is protocol for accessing data referred to by file
383    * @param autoenabledisplay
384    * when true, display features flag will be automatically enabled if
385    * features are loaded
386    * @return true if data parsed as a features file
387    */
 
388  0 toggle public boolean parseFeaturesFile(String file, DataSourceType sourceType,
389    boolean autoenabledisplay)
390    {
391  0 boolean featuresFile = false;
392  0 try
393    {
394  0 Map<String, FeatureColourI> colours = alignPanel.seqPanel.seqCanvas
395    .getFeatureRenderer().getFeatureColours();
396  0 boolean relaxedIdMatching = viewport.applet
397    .getDefaultParameter("relaxedidmatch", false);
398  0 featuresFile = new FeaturesFile(file, sourceType).parse(
399    viewport.getAlignment(), colours, true, relaxedIdMatching);
400    } catch (Exception ex)
401    {
402  0 ex.printStackTrace();
403    }
404   
405  0 if (featuresFile)
406    {
407  0 if (autoenabledisplay)
408    {
409  0 viewport.setShowSequenceFeatures(true);
410  0 sequenceFeatures.setState(true);
411    }
412  0 if (alignPanel.seqPanel.seqCanvas.fr != null)
413    {
414    // update the min/max ranges where necessary
415  0 alignPanel.seqPanel.seqCanvas.fr.findAllFeatures(true);
416    }
417  0 if (viewport.featureSettings != null)
418    {
419  0 viewport.featureSettings.refreshTable();
420    }
421  0 alignPanel.paintAlignment(true, true);
422  0 setStatus(MessageManager
423    .getString("label.successfully_added_features_alignment"));
424    }
425  0 return featuresFile;
426    }
427   
 
428  0 toggle @Override
429    public void keyPressed(KeyEvent evt)
430    {
431  0 ViewportRanges ranges = viewport.getRanges();
432   
433  0 if (viewport.cursorMode
434    && ((evt.getKeyCode() >= KeyEvent.VK_0
435    && evt.getKeyCode() <= KeyEvent.VK_9)
436    || (evt.getKeyCode() >= KeyEvent.VK_NUMPAD0
437    && evt.getKeyCode() <= KeyEvent.VK_NUMPAD9))
438    && Character.isDigit(evt.getKeyChar()))
439    {
440  0 alignPanel.seqPanel.numberPressed(evt.getKeyChar());
441    }
442   
443  0 switch (evt.getKeyCode())
444    {
445  0 case 27: // escape key
446  0 deselectAllSequenceMenuItem_actionPerformed();
447   
448  0 alignPanel.alabels.cancelDrag();
449  0 break;
450  0 case KeyEvent.VK_X:
451  0 if (evt.isControlDown() || evt.isMetaDown())
452    {
453  0 cut_actionPerformed();
454    }
455  0 break;
456  0 case KeyEvent.VK_C:
457  0 if (viewport.cursorMode && !evt.isControlDown())
458    {
459  0 alignPanel.seqPanel.setCursorColumn();
460    }
461  0 if (evt.isControlDown() || evt.isMetaDown())
462    {
463  0 copy_actionPerformed();
464    }
465  0 break;
466  0 case KeyEvent.VK_V:
467  0 if (evt.isControlDown())
468    {
469  0 paste(evt.isShiftDown());
470    }
471  0 break;
472  0 case KeyEvent.VK_A:
473  0 if (evt.isControlDown() || evt.isMetaDown())
474    {
475  0 selectAllSequenceMenuItem_actionPerformed();
476    }
477  0 break;
478  0 case KeyEvent.VK_DOWN:
479  0 if (viewport.cursorMode)
480    {
481  0 alignPanel.seqPanel.moveCursor(0, 1);
482    }
483    else
484    {
485  0 moveSelectedSequences(false);
486    }
487  0 break;
488   
489  0 case KeyEvent.VK_UP:
490  0 if (viewport.cursorMode)
491    {
492  0 alignPanel.seqPanel.moveCursor(0, -1);
493    }
494    else
495    {
496  0 moveSelectedSequences(true);
497    }
498  0 break;
499   
500  0 case KeyEvent.VK_LEFT:
501  0 if (evt.isAltDown() || !viewport.cursorMode)
502    {
503  0 slideSequences(false, alignPanel.seqPanel.getKeyboardNo1());
504    }
505    else
506    {
507  0 alignPanel.seqPanel.moveCursor(-1, 0);
508    }
509  0 break;
510   
511  0 case KeyEvent.VK_RIGHT:
512  0 if (evt.isAltDown() || !viewport.cursorMode)
513    {
514  0 slideSequences(true, alignPanel.seqPanel.getKeyboardNo1());
515    }
516    else
517    {
518  0 alignPanel.seqPanel.moveCursor(1, 0);
519    }
520  0 break;
521   
522  0 case KeyEvent.VK_SPACE:
523  0 if (viewport.cursorMode)
524    {
525  0 alignPanel.seqPanel.insertGapAtCursor(evt.isControlDown()
526    || evt.isShiftDown() || evt.isAltDown());
527    }
528  0 break;
529   
530  0 case KeyEvent.VK_DELETE:
531  0 case KeyEvent.VK_BACK_SPACE:
532  0 if (viewport.cursorMode)
533    {
534  0 alignPanel.seqPanel.deleteGapAtCursor(evt.isControlDown()
535    || evt.isShiftDown() || evt.isAltDown());
536    }
537    else
538    {
539  0 cut_actionPerformed();
540  0 alignPanel.seqPanel.seqCanvas.repaint();
541    }
542  0 break;
543   
544  0 case KeyEvent.VK_S:
545  0 if (viewport.cursorMode)
546    {
547  0 alignPanel.seqPanel.setCursorRow();
548    }
549  0 break;
550  0 case KeyEvent.VK_P:
551  0 if (viewport.cursorMode)
552    {
553  0 alignPanel.seqPanel.setCursorPosition();
554    }
555  0 break;
556   
557  0 case KeyEvent.VK_ENTER:
558  0 case KeyEvent.VK_COMMA:
559  0 if (viewport.cursorMode)
560    {
561  0 alignPanel.seqPanel.setCursorRowAndColumn();
562    }
563  0 break;
564   
565  0 case KeyEvent.VK_Q:
566  0 if (viewport.cursorMode)
567    {
568  0 alignPanel.seqPanel.setSelectionAreaAtCursor(true);
569    }
570  0 break;
571  0 case KeyEvent.VK_M:
572  0 if (viewport.cursorMode)
573    {
574  0 alignPanel.seqPanel.setSelectionAreaAtCursor(false);
575    }
576  0 break;
577   
578  0 case KeyEvent.VK_F2:
579  0 viewport.cursorMode = !viewport.cursorMode;
580  0 setStatus(MessageManager.formatMessage("label.keyboard_editing_mode",
581    new String[]
582  0 { (viewport.cursorMode ? "on" : "off") }));
583  0 if (viewport.cursorMode)
584    {
585  0 alignPanel.seqPanel.seqCanvas.cursorX = ranges.getStartRes();
586  0 alignPanel.seqPanel.seqCanvas.cursorY = ranges.getStartSeq();
587    }
588  0 break;
589   
590  0 case KeyEvent.VK_F:
591  0 if (evt.isControlDown())
592    {
593  0 findMenuItem_actionPerformed();
594    }
595  0 break;
596   
597  0 case KeyEvent.VK_H:
598    {
599  0 boolean toggleSeqs = !evt.isControlDown();
600  0 boolean toggleCols = !evt.isShiftDown();
601  0 toggleHiddenRegions(toggleSeqs, toggleCols);
602  0 break;
603    }
604   
605  0 case KeyEvent.VK_PAGE_UP:
606  0 ranges.pageUp();
607  0 break;
608   
609  0 case KeyEvent.VK_PAGE_DOWN:
610  0 ranges.pageDown();
611  0 break;
612   
613  0 case KeyEvent.VK_Z:
614  0 if (evt.isControlDown())
615    {
616  0 undoMenuItem_actionPerformed();
617    }
618  0 break;
619   
620  0 case KeyEvent.VK_Y:
621  0 if (evt.isControlDown())
622    {
623  0 redoMenuItem_actionPerformed();
624    }
625  0 break;
626   
627  0 case KeyEvent.VK_L:
628  0 if (evt.isControlDown())
629    {
630  0 trimAlignment(true);
631    }
632  0 break;
633   
634  0 case KeyEvent.VK_R:
635  0 if (evt.isControlDown())
636    {
637  0 trimAlignment(false);
638    }
639  0 break;
640   
641  0 case KeyEvent.VK_E:
642  0 if (evt.isControlDown())
643    {
644  0 if (evt.isShiftDown())
645    {
646  0 this.removeAllGapsMenuItem_actionPerformed();
647    }
648    else
649    {
650  0 removeGappedColumnMenuItem_actionPerformed();
651    }
652    }
653  0 break;
654  0 case KeyEvent.VK_I:
655  0 if (evt.isControlDown())
656    {
657  0 if (evt.isAltDown())
658    {
659  0 invertColSel_actionPerformed();
660    }
661    else
662    {
663  0 invertSequenceMenuItem_actionPerformed();
664    }
665    }
666  0 break;
667   
668  0 case KeyEvent.VK_G:
669  0 if (evt.isControlDown())
670    {
671  0 if (evt.isShiftDown())
672    {
673  0 this.unGroup_actionPerformed();
674    }
675    else
676    {
677  0 this.createGroup_actionPerformed();
678    }
679    }
680  0 break;
681   
682  0 case KeyEvent.VK_U:
683  0 if (evt.isControlDown())
684    {
685  0 this.deleteGroups_actionPerformed();
686    }
687  0 break;
688   
689  0 case KeyEvent.VK_T:
690  0 if (evt.isControlDown())
691    {
692  0 newView(null);
693    }
694  0 break;
695   
696    }
697    // TODO: repaint flags set only if the keystroke warrants it
698  0 alignPanel.paintAlignment(true, true);
699    }
700   
701    /**
702    * called by key handler and the hide all/show all menu items
703    *
704    * @param toggleSeqs
705    * @param toggleCols
706    */
 
707  0 toggle private void toggleHiddenRegions(boolean toggleSeqs, boolean toggleCols)
708    {
709  0 boolean hide = false;
710  0 SequenceGroup sg = viewport.getSelectionGroup();
711  0 if (!toggleSeqs && !toggleCols)
712    {
713    // Hide everything by the current selection - this is a hack - we do the
714    // invert and then hide
715    // first check that there will be visible columns after the invert.
716  0 if (viewport.hasSelectedColumns() || (sg != null && sg.getSize() > 0
717    && sg.getStartRes() <= sg.getEndRes()))
718    {
719    // now invert the sequence set, if required - empty selection implies
720    // that no hiding is required.
721  0 if (sg != null)
722    {
723  0 invertSequenceMenuItem_actionPerformed();
724  0 sg = viewport.getSelectionGroup();
725  0 toggleSeqs = true;
726   
727    }
728  0 viewport.expandColSelection(sg, true);
729    // finally invert the column selection and get the new sequence
730    // selection and indicate it should be hidden.
731  0 invertColSel_actionPerformed();
732  0 toggleCols = true;
733    }
734    }
735   
736  0 if (toggleSeqs)
737    {
738  0 if (sg != null && sg.getSize() != viewport.getAlignment().getHeight())
739    {
740  0 hide = true;
741  0 viewport.hideAllSelectedSeqs();
742    }
743  0 else if (!(toggleCols && viewport.hasSelectedColumns()))
744    {
745  0 viewport.showAllHiddenSeqs();
746    }
747    }
748   
749  0 if (toggleCols)
750    {
751  0 if (viewport.hasSelectedColumns())
752    {
753  0 viewport.hideSelectedColumns();
754  0 if (!toggleSeqs)
755    {
756  0 viewport.setSelectionGroup(sg);
757    }
758    }
759  0 else if (!hide)
760    {
761  0 viewport.showAllHiddenColumns();
762    }
763  0 viewport.sendSelection();
764    }
765    }
766   
 
767  0 toggle @Override
768    public void keyReleased(KeyEvent evt)
769    {
770    }
771   
 
772  0 toggle @Override
773    public void keyTyped(KeyEvent evt)
774    {
775    }
776   
 
777  0 toggle @Override
778    public void itemStateChanged(ItemEvent evt)
779    {
780  0 final Object source = evt.getSource();
781  0 if (source == displayNonconservedMenuItem)
782    {
783  0 displayNonconservedMenuItem_actionPerformed();
784    }
785  0 else if (source == colourTextMenuItem)
786    {
787  0 colourTextMenuItem_actionPerformed();
788    }
789  0 else if (source == wrapMenuItem)
790    {
791  0 wrapMenuItem_actionPerformed();
792    }
793  0 else if (source == scaleAbove)
794    {
795  0 viewport.setScaleAboveWrapped(scaleAbove.getState());
796    }
797  0 else if (source == scaleLeft)
798    {
799  0 viewport.setScaleLeftWrapped(scaleLeft.getState());
800    }
801  0 else if (source == scaleRight)
802    {
803  0 viewport.setScaleRightWrapped(scaleRight.getState());
804    }
805  0 else if (source == seqLimits)
806    {
807  0 seqLimits_itemStateChanged();
808    }
809  0 else if (source == viewBoxesMenuItem)
810    {
811  0 viewport.setShowBoxes(viewBoxesMenuItem.getState());
812    }
813  0 else if (source == viewTextMenuItem)
814    {
815  0 viewport.setShowText(viewTextMenuItem.getState());
816    }
817  0 else if (source == renderGapsMenuItem)
818    {
819  0 viewport.setRenderGaps(renderGapsMenuItem.getState());
820    }
821  0 else if (source == annotationPanelMenuItem)
822    {
823  0 boolean showAnnotations = annotationPanelMenuItem.getState();
824  0 showAlignmentAnnotations.setEnabled(showAnnotations);
825  0 showSequenceAnnotations.setEnabled(showAnnotations);
826  0 viewport.setShowAnnotation(showAnnotations);
827  0 alignPanel.setAnnotationVisible(showAnnotations);
828    }
829  0 else if (source == sequenceFeatures)
830    {
831  0 viewport.setShowSequenceFeatures(sequenceFeatures.getState());
832  0 alignPanel.seqPanel.seqCanvas.repaint();
833    }
834  0 else if (source == showAlignmentAnnotations)
835    {
836  0 setAnnotationsVisibility();
837    }
838  0 else if (source == showSequenceAnnotations)
839    {
840  0 setAnnotationsVisibility();
841    }
842  0 else if (source == sortAnnBySequence)
843    {
844  0 boolean newState = sortAnnBySequence.getState();
845  0 sortAnnByLabel.setState(false);
846  0 setAnnotationSortOrder(
847  0 newState ? SequenceAnnotationOrder.SEQUENCE_AND_LABEL
848    : SequenceAnnotationOrder.NONE);
849  0 setViewportAnnotationOrder();
850    }
851  0 else if (source == sortAnnByLabel)
852    {
853  0 boolean newState = sortAnnByLabel.getState();
854  0 sortAnnBySequence.setState(false);
855  0 setAnnotationSortOrder(
856  0 newState ? SequenceAnnotationOrder.LABEL_AND_SEQUENCE
857    : SequenceAnnotationOrder.NONE);
858  0 setViewportAnnotationOrder();
859    }
860  0 else if (source == showAutoFirst)
861    {
862  0 showAutoLast.setState(!showAutoFirst.getState());
863  0 setShowAutoCalculatedAbove(showAutoFirst.getState());
864  0 setViewportAnnotationOrder();
865    }
866  0 else if (source == showAutoLast)
867    {
868  0 showAutoFirst.setState(!showAutoLast.getState());
869  0 setShowAutoCalculatedAbove(showAutoFirst.getState());
870  0 setViewportAnnotationOrder();
871    }
872  0 else if (source == conservationMenuItem)
873    {
874  0 conservationMenuItem_actionPerformed();
875    }
876  0 else if (source == abovePIDThreshold)
877    {
878  0 abovePIDThreshold_actionPerformed();
879    }
880  0 else if (source == applyToAllGroups)
881    {
882  0 viewport.setColourAppliesToAllGroups(applyToAllGroups.getState());
883    }
884  0 else if (source == autoCalculate)
885    {
886  0 viewport.setAutoCalculateConsensusAndConservation(autoCalculate.getState());
887    }
888  0 else if (source == sortByTree)
889    {
890  0 viewport.sortByTree = sortByTree.getState();
891    }
892  0 else if (source == this.centreColumnLabelFlag)
893    {
894  0 centreColumnLabelFlag_stateChanged();
895    }
896  0 else if (source == this.followMouseOverFlag)
897    {
898  0 mouseOverFlag_stateChanged();
899    }
900  0 else if (source == showGroupConsensus)
901    {
902  0 showGroupConsensus_actionPerformed();
903    }
904  0 else if (source == showGroupConservation)
905    {
906  0 showGroupConservation_actionPerformed();
907    }
908  0 else if (source == showSequenceLogo)
909    {
910  0 showSequenceLogo_actionPerformed();
911    }
912  0 else if (source == normSequenceLogo)
913    {
914  0 normSequenceLogo_actionPerformed();
915    }
916  0 else if (source == showConsensusHistogram)
917    {
918  0 showConsensusHistogram_actionPerformed();
919    }
920  0 else if (source == applyAutoAnnotationSettings)
921    {
922  0 applyAutoAnnotationSettings_actionPerformed();
923    }
924    // TODO: repaint flags set only if warranted
925  0 alignPanel.paintAlignment(true, true);
926    }
927   
928    /**
929    * Set the visibility state of sequence-related and/or alignment-related
930    * annotations depending on checkbox selections, and repaint.
931    *
932    * @param visible
933    */
 
934  0 toggle private void setAnnotationsVisibility()
935    {
936  0 boolean showForAlignment = showAlignmentAnnotations.getState();
937  0 boolean showForSequences = showSequenceAnnotations.getState();
938  0 if (alignPanel.getAlignment().getAlignmentAnnotation() != null)
939    {
940  0 for (AlignmentAnnotation aa : alignPanel.getAlignment()
941    .getAlignmentAnnotation())
942    {
943  0 boolean visible = (aa.sequenceRef == null ? showForAlignment
944    : showForSequences);
945  0 aa.visible = visible;
946    }
947    }
948  0 alignPanel.validateAnnotationDimensions(true);
949  0 validate();
950  0 repaint();
951    }
952   
 
953  0 toggle private void setAnnotationSortOrder(SequenceAnnotationOrder order)
954    {
955  0 this.annotationSortOrder = order;
956    }
957   
958    /**
959    * Set flags on the viewport that control annotation ordering
960    */
 
961  0 toggle private void setViewportAnnotationOrder()
962    {
963  0 this.alignPanel.av.setSortAnnotationsBy(this.annotationSortOrder);
964  0 this.alignPanel.av
965    .setShowAutocalculatedAbove(this.showAutoCalculatedAbove);
966    }
967   
 
968  0 toggle private void setShowAutoCalculatedAbove(boolean showAbove)
969    {
970  0 this.showAutoCalculatedAbove = showAbove;
971    }
972   
 
973  0 toggle private void mouseOverFlag_stateChanged()
974    {
975  0 viewport.setFollowHighlight(followMouseOverFlag.getState());
976    // TODO: could kick the scrollTo mechanism to reset view for current
977    // searchresults.
978    }
979   
 
980  0 toggle private void centreColumnLabelFlag_stateChanged()
981    {
982  0 viewport.centreColumnLabels = centreColumnLabelFlag.getState();
983  0 this.alignPanel.annotationPanel.repaint();
984    }
985   
 
986  0 toggle @Override
987    public void actionPerformed(ActionEvent evt)
988    {
989  0 viewport.applet.currentAlignFrame = this;
990   
991  0 Object source = evt.getSource();
992   
993  0 if (source == inputText)
994    {
995  0 inputText_actionPerformed();
996    }
997  0 else if (source == loadTree)
998    {
999  0 loadTree_actionPerformed();
1000    }
1001  0 else if (source == loadApplication)
1002    {
1003  0 launchFullApplication();
1004    }
1005  0 else if (source == loadAnnotations)
1006    {
1007  0 loadAnnotations();
1008    }
1009  0 else if (source == outputAnnotations)
1010    {
1011  0 outputAnnotations(true);
1012    }
1013  0 else if (source == outputFeatures)
1014    {
1015  0 outputFeatures(true, "Jalview");
1016    }
1017  0 else if (source == closeMenuItem)
1018    {
1019  0 closeMenuItem_actionPerformed();
1020    }
1021  0 else if (source == copy)
1022    {
1023  0 copy_actionPerformed();
1024    }
1025  0 else if (source == undoMenuItem)
1026    {
1027  0 undoMenuItem_actionPerformed();
1028    }
1029  0 else if (source == redoMenuItem)
1030    {
1031  0 redoMenuItem_actionPerformed();
1032    }
1033  0 else if (source == inputText)
1034    {
1035  0 inputText_actionPerformed();
1036    }
1037  0 else if (source == closeMenuItem)
1038    {
1039  0 closeMenuItem_actionPerformed();
1040    }
1041  0 else if (source == undoMenuItem)
1042    {
1043  0 undoMenuItem_actionPerformed();
1044    }
1045  0 else if (source == redoMenuItem)
1046    {
1047  0 redoMenuItem_actionPerformed();
1048    }
1049  0 else if (source == copy)
1050    {
1051  0 copy_actionPerformed();
1052    }
1053  0 else if (source == pasteNew)
1054    {
1055  0 pasteNew_actionPerformed();
1056    }
1057  0 else if (source == pasteThis)
1058    {
1059  0 pasteThis_actionPerformed();
1060    }
1061  0 else if (source == cut)
1062    {
1063  0 cut_actionPerformed();
1064    }
1065  0 else if (source == delete)
1066    {
1067  0 delete_actionPerformed();
1068    }
1069  0 else if (source == createGroup)
1070    {
1071  0 createGroup_actionPerformed();
1072    }
1073  0 else if (source == unGroup)
1074    {
1075  0 unGroup_actionPerformed();
1076    }
1077  0 else if (source == grpsFromSelection)
1078    {
1079  0 makeGrpsFromSelection_actionPerformed();
1080    }
1081  0 else if (source == deleteGroups)
1082    {
1083  0 deleteGroups_actionPerformed();
1084    }
1085  0 else if (source == selectAllSequenceMenuItem)
1086    {
1087  0 selectAllSequenceMenuItem_actionPerformed();
1088    }
1089  0 else if (source == deselectAllSequenceMenuItem)
1090    {
1091  0 deselectAllSequenceMenuItem_actionPerformed();
1092    }
1093  0 else if (source == invertSequenceMenuItem)
1094    {
1095  0 invertSequenceMenuItem_actionPerformed();
1096    // uncomment to slave sequence selections in split frame
1097    // viewport.sendSelection();
1098    }
1099  0 else if (source == invertColSel)
1100    {
1101  0 viewport.invertColumnSelection();
1102  0 alignPanel.paintAlignment(false, false);
1103  0 viewport.sendSelection();
1104    }
1105  0 else if (source == remove2LeftMenuItem)
1106    {
1107  0 trimAlignment(true);
1108    }
1109  0 else if (source == remove2RightMenuItem)
1110    {
1111  0 trimAlignment(false);
1112    }
1113  0 else if (source == removeGappedColumnMenuItem)
1114    {
1115  0 removeGappedColumnMenuItem_actionPerformed();
1116    }
1117  0 else if (source == removeAllGapsMenuItem)
1118    {
1119  0 removeAllGapsMenuItem_actionPerformed();
1120    }
1121  0 else if (source == findMenuItem)
1122    {
1123  0 findMenuItem_actionPerformed();
1124    }
1125  0 else if (source == font)
1126    {
1127  0 new FontChooser(alignPanel);
1128    }
1129  0 else if (source == newView)
1130    {
1131  0 newView(null);
1132    }
1133  0 else if (source == showColumns)
1134    {
1135  0 viewport.showAllHiddenColumns();
1136  0 alignPanel.paintAlignment(true, true);
1137  0 viewport.sendSelection();
1138    }
1139  0 else if (source == showSeqs)
1140    {
1141  0 viewport.showAllHiddenSeqs();
1142  0 alignPanel.paintAlignment(true, true);
1143    // uncomment if we want to slave sequence selections in split frame
1144    // viewport.sendSelection();
1145    }
1146  0 else if (source == hideColumns)
1147    {
1148  0 viewport.hideSelectedColumns();
1149  0 alignPanel.paintAlignment(true, true);
1150  0 viewport.sendSelection();
1151    }
1152  0 else if (source == hideSequences
1153    && viewport.getSelectionGroup() != null)
1154    {
1155  0 viewport.hideAllSelectedSeqs();
1156  0 alignPanel.paintAlignment(true, true);
1157    // uncomment if we want to slave sequence selections in split frame
1158    // viewport.sendSelection();
1159    }
1160  0 else if (source == hideAllButSelection)
1161    {
1162  0 toggleHiddenRegions(false, false);
1163  0 alignPanel.paintAlignment(true, true);
1164  0 viewport.sendSelection();
1165    }
1166  0 else if (source == hideAllSelection)
1167    {
1168  0 SequenceGroup sg = viewport.getSelectionGroup();
1169  0 viewport.expandColSelection(sg, false);
1170  0 viewport.hideAllSelectedSeqs();
1171  0 viewport.hideSelectedColumns();
1172  0 alignPanel.paintAlignment(true, true);
1173  0 viewport.sendSelection();
1174    }
1175  0 else if (source == showAllHidden)
1176    {
1177  0 viewport.showAllHiddenColumns();
1178  0 viewport.showAllHiddenSeqs();
1179  0 alignPanel.paintAlignment(true, true);
1180  0 viewport.sendSelection();
1181    }
1182  0 else if (source == showGroupConsensus)
1183    {
1184  0 showGroupConsensus_actionPerformed();
1185    }
1186  0 else if (source == showGroupConservation)
1187    {
1188  0 showGroupConservation_actionPerformed();
1189    }
1190  0 else if (source == showSequenceLogo)
1191    {
1192  0 showSequenceLogo_actionPerformed();
1193    }
1194  0 else if (source == normSequenceLogo)
1195    {
1196  0 normSequenceLogo_actionPerformed();
1197    }
1198  0 else if (source == showConsensusHistogram)
1199    {
1200  0 showConsensusHistogram_actionPerformed();
1201    }
1202  0 else if (source == applyAutoAnnotationSettings)
1203    {
1204  0 applyAutoAnnotationSettings_actionPerformed();
1205    }
1206  0 else if (source == featureSettings)
1207    {
1208  0 showFeatureSettingsUI();
1209    }
1210  0 else if (source == alProperties)
1211    {
1212  0 StringBuffer contents = new jalview.io.AlignmentProperties(
1213    viewport.getAlignment()).formatAsString();
1214  0 CutAndPasteTransfer cap = new CutAndPasteTransfer(false, this);
1215  0 cap.setText(contents.toString());
1216  0 Frame frame = new Frame();
1217  0 frame.add(cap);
1218  0 jalview.bin.JalviewLite.addFrame(frame, MessageManager
1219    .formatMessage("label.alignment_properties", new String[]
1220    { getTitle() }), 400, 250);
1221    }
1222  0 else if (source == overviewMenuItem)
1223    {
1224  0 overviewMenuItem_actionPerformed();
1225    }
1226  0 else if (source == noColourmenuItem)
1227    {
1228  0 changeColour(null);
1229    }
1230  0 else if (source == clustalColour)
1231    {
1232  0 abovePIDThreshold.setState(false);
1233  0 changeColour(new ClustalxColourScheme(viewport.getAlignment(), null));
1234    }
1235  0 else if (source == zappoColour)
1236    {
1237  0 changeColour(new ZappoColourScheme());
1238    }
1239  0 else if (source == taylorColour)
1240    {
1241  0 changeColour(new TaylorColourScheme());
1242    }
1243  0 else if (source == hydrophobicityColour)
1244    {
1245  0 changeColour(new HydrophobicColourScheme());
1246    }
1247  0 else if (source == helixColour)
1248    {
1249  0 changeColour(new HelixColourScheme());
1250    }
1251  0 else if (source == strandColour)
1252    {
1253  0 changeColour(new StrandColourScheme());
1254    }
1255  0 else if (source == turnColour)
1256    {
1257  0 changeColour(new TurnColourScheme());
1258    }
1259  0 else if (source == buriedColour)
1260    {
1261  0 changeColour(new BuriedColourScheme());
1262    }
1263  0 else if (source == nucleotideColour)
1264    {
1265  0 changeColour(new NucleotideColourScheme());
1266    }
1267  0 else if (source == purinePyrimidineColour)
1268    {
1269  0 changeColour(new PurinePyrimidineColourScheme());
1270    }
1271    // else if (source == RNAInteractionColour)
1272    // {
1273    // changeColour(new RNAInteractionColourScheme());
1274    // }
1275  0 else if (source == RNAHelixColour)
1276    {
1277  0 changeColour(new RNAHelicesColour(viewport.getAlignment()));
1278    // new RNAHelicesColourChooser(viewport, alignPanel);
1279    }
1280  0 else if (source == modifyPID)
1281    {
1282  0 modifyPID_actionPerformed();
1283    }
1284  0 else if (source == modifyConservation)
1285    {
1286  0 modifyConservation_actionPerformed();
1287    }
1288  0 else if (source == userDefinedColour)
1289    {
1290  0 new UserDefinedColours(alignPanel, null);
1291    }
1292  0 else if (source == PIDColour)
1293    {
1294  0 changeColour(new PIDColourScheme());
1295    }
1296  0 else if (source == BLOSUM62Colour)
1297    {
1298  0 changeColour(new Blosum62ColourScheme());
1299    }
1300  0 else if (source == tcoffeeColour)
1301    {
1302  0 changeColour(new TCoffeeColourScheme(alignPanel.getAlignment()));
1303    }
1304  0 else if (source == annotationColour)
1305    {
1306  0 new AnnotationColourChooser(viewport, alignPanel);
1307    }
1308  0 else if (source == annotationColumnSelection)
1309    {
1310  0 new AnnotationColumnChooser(viewport, alignPanel);
1311    }
1312  0 else if (source == sortPairwiseMenuItem)
1313    {
1314  0 sortPairwiseMenuItem_actionPerformed();
1315    }
1316  0 else if (source == sortIDMenuItem)
1317    {
1318  0 sortIDMenuItem_actionPerformed();
1319    }
1320  0 else if (source == sortLengthMenuItem)
1321    {
1322  0 sortLengthMenuItem_actionPerformed();
1323    }
1324  0 else if (source == sortGroupMenuItem)
1325    {
1326  0 sortGroupMenuItem_actionPerformed();
1327    }
1328  0 else if (source == sortEValueMenuItem)
1329    {
1330  0 sortEValueMenuItem_actionPerformed();
1331    }
1332  0 else if (source == sortBitScoreMenuItem)
1333    {
1334  0 sortBitScoreMenuItem_actionPerformed();
1335    }
1336  0 else if (source == removeRedundancyMenuItem)
1337    {
1338  0 removeRedundancyMenuItem_actionPerformed();
1339    }
1340  0 else if (source == pairwiseAlignmentMenuItem)
1341    {
1342  0 pairwiseAlignmentMenuItem_actionPerformed();
1343    }
1344  0 else if (source == PCAMenuItem)
1345    {
1346  0 PCAMenuItem_actionPerformed();
1347    }
1348  0 else if (source == averageDistanceTreeMenuItem)
1349    {
1350  0 averageDistanceTreeMenuItem_actionPerformed();
1351    }
1352  0 else if (source == neighbourTreeMenuItem)
1353    {
1354  0 neighbourTreeMenuItem_actionPerformed();
1355    }
1356  0 else if (source == njTreeBlosumMenuItem)
1357    {
1358  0 njTreeBlosumMenuItem_actionPerformed();
1359    }
1360  0 else if (source == avDistanceTreeBlosumMenuItem)
1361    {
1362  0 avTreeBlosumMenuItem_actionPerformed();
1363    }
1364  0 else if (source == documentation)
1365    {
1366  0 documentation_actionPerformed();
1367    }
1368  0 else if (source == about)
1369    {
1370  0 about_actionPerformed();
1371    }
1372   
1373    }
1374   
 
1375  0 toggle public void inputText_actionPerformed()
1376    {
1377  0 CutAndPasteTransfer cap = new CutAndPasteTransfer(true, this);
1378  0 Frame frame = new Frame();
1379  0 frame.add(cap);
1380  0 jalview.bin.JalviewLite.addFrame(frame,
1381    MessageManager.getString("label.input_cut_paste"), 500, 500);
1382    }
1383   
 
1384  0 toggle protected void outputText_actionPerformed(ActionEvent e)
1385    {
1386  0 CutAndPasteTransfer cap = new CutAndPasteTransfer(true, this);
1387  0 Frame frame = new Frame();
1388  0 frame.add(cap);
1389  0 JalviewLite.addFrame(frame, MessageManager
1390    .formatMessage("label.alignment_output_command", new Object[]
1391    { e.getActionCommand() }), 600, 500);
1392   
1393  0 FileFormatI fileFormat = FileFormats.getInstance()
1394    .forName(e.getActionCommand());
1395  0 cap.setText(
1396    new AppletFormatAdapter(alignPanel).formatSequences(fileFormat,
1397    viewport.getAlignment(), viewport.getShowJVSuffix()));
1398    }
1399   
 
1400  0 toggle public void loadAnnotations()
1401    {
1402  0 CutAndPasteTransfer cap = new CutAndPasteTransfer(true, this);
1403  0 cap.setText(MessageManager
1404    .getString("label.paste_features_annotations_Tcoffee_here"));
1405  0 cap.setAnnotationImport();
1406  0 Frame frame = new Frame();
1407  0 frame.add(cap);
1408  0 jalview.bin.JalviewLite.addFrame(frame,
1409    MessageManager.getString("action.paste_annotations"), 400, 300);
1410   
1411    }
1412   
 
1413  0 toggle public String outputAnnotations(boolean displayTextbox)
1414    {
1415  0 String annotation = new AnnotationFile()
1416    .printAnnotationsForView(viewport);
1417   
1418  0 if (displayTextbox)
1419    {
1420  0 CutAndPasteTransfer cap = new CutAndPasteTransfer(false, this);
1421  0 Frame frame = new Frame();
1422  0 frame.add(cap);
1423  0 jalview.bin.JalviewLite.addFrame(frame,
1424    MessageManager.getString("label.annotations"), 600, 500);
1425  0 cap.setText(annotation);
1426    }
1427   
1428  0 return annotation;
1429    }
1430   
 
1431  0 toggle private Map<String, FeatureColourI> getDisplayedFeatureCols()
1432    {
1433  0 if (alignPanel.getFeatureRenderer() != null
1434    && viewport.getFeaturesDisplayed() != null)
1435    {
1436  0 return alignPanel.getFeatureRenderer().getDisplayedFeatureCols();
1437   
1438    }
1439  0 return null;
1440    }
1441   
 
1442  0 toggle private List<String> getDisplayedFeatureGroups()
1443    {
1444  0 if (alignPanel.getFeatureRenderer() != null
1445    && viewport.getFeaturesDisplayed() != null)
1446    {
1447  0 return alignPanel.getFeatureRenderer().getDisplayedFeatureGroups();
1448   
1449    }
1450  0 return null;
1451    }
1452   
 
1453  0 toggle public String outputFeatures(boolean displayTextbox, String format)
1454    {
1455  0 String features;
1456  0 FeaturesFile formatter = new FeaturesFile();
1457  0 if (format.equalsIgnoreCase("Jalview"))
1458    {
1459  0 features = formatter.printJalviewFormat(
1460    viewport.getAlignment().getSequencesArray(),
1461    alignPanel.getFeatureRenderer(), true, false);
1462    }
1463    else
1464    {
1465  0 features = formatter.printGffFormat(
1466    viewport.getAlignment().getSequencesArray(),
1467    alignPanel.getFeatureRenderer(), true, false);
1468    }
1469   
1470  0 if (displayTextbox)
1471    {
1472  0 boolean frimport = false;
1473  0 if (features == null || features.equals("No Features Visible"))
1474    {
1475  0 features = "# No features visible - paste some and import them here.";
1476  0 frimport = true;
1477    }
1478   
1479  0 CutAndPasteTransfer cap = new CutAndPasteTransfer(frimport, this);
1480  0 if (frimport)
1481    {
1482  0 cap.setAnnotationImport();
1483    }
1484  0 Frame frame = new Frame();
1485  0 frame.add(cap);
1486  0 jalview.bin.JalviewLite.addFrame(frame,
1487    MessageManager.getString("label.features"), 600, 500);
1488  0 cap.setText(features);
1489    }
1490    else
1491    {
1492  0 if (features == null)
1493    {
1494  0 features = "";
1495    }
1496    }
1497   
1498  0 return features;
1499    }
1500   
 
1501  0 toggle void launchFullApplication()
1502    {
1503  0 StringBuffer url = new StringBuffer(jalviewServletURL);
1504   
1505    // allow servlet parameters to be passed in applet parameter
1506  0 String firstSep = url.lastIndexOf("?") > url.lastIndexOf("/") ? "&"
1507    : "?";
1508  0 url.append(firstSep);
1509   
1510  0 url.append(
1511    "open=" + appendProtocol(viewport.applet.getParameter("file")));
1512   
1513  0 if (viewport.applet.getParameter("features") != null)
1514    {
1515  0 url.append("&features=");
1516  0 url.append(appendProtocol(viewport.applet.getParameter("features")));
1517    }
1518   
1519  0 if (viewport.applet.getParameter("annotations") != null)
1520    {
1521  0 url.append("&annotations=");
1522  0 url.append(
1523    appendProtocol(viewport.applet.getParameter("annotations")));
1524    }
1525   
1526  0 if (viewport.applet.getParameter("jnetfile") != null
1527    || viewport.applet.getParameter("jpredfile") != null)
1528    {
1529  0 url.append("&annotations=");
1530  0 url.append(appendProtocol(
1531  0 viewport.applet.getParameter("jnetfile") != null
1532    ? viewport.applet.getParameter("jnetfile")
1533    : viewport.applet.getParameter("jpredfile")));
1534    }
1535   
1536  0 if (viewport.applet.getParameter("defaultColour") != null)
1537    {
1538  0 url.append("&colour=" + removeWhiteSpace(
1539    viewport.applet.getParameter("defaultColour")));
1540    }
1541   
1542  0 if (viewport.applet.getParameter("userDefinedColour") != null)
1543    {
1544  0 url.append("&colour=" + removeWhiteSpace(
1545    viewport.applet.getParameter("userDefinedColour")));
1546    }
1547  0 if (viewport.applet.getParameter("tree") != null)
1548    {
1549  0 url.append("&tree="
1550    + appendProtocol(viewport.applet.getParameter("tree")));
1551    }
1552  0 if (viewport.applet.getParameter("treeFile") != null)
1553    {
1554  0 url.append("&tree="
1555    + appendProtocol(viewport.applet.getParameter("treeFile")));
1556    }
1557   
1558  0 showURL(url.toString(), "FULL_APP");
1559    }
1560   
 
1561  0 toggle String removeWhiteSpace(String colour)
1562    {
1563  0 StringBuffer sb = new StringBuffer();
1564  0 for (int i = 0; i < colour.length(); i++)
1565    {
1566  0 if (Character.isWhitespace(colour.charAt(i)))
1567    {
1568  0 sb.append("%20");
1569    }
1570    else
1571    {
1572  0 sb.append(colour.charAt(i));
1573    }
1574    }
1575   
1576  0 return sb.toString();
1577    }
1578   
 
1579  0 toggle String appendProtocol(String url)
1580    {
1581  0 try
1582    {
1583  0 new URL(url);
1584  0 url = URLEncoder.encode(url, "UTF-8");
1585    }
1586    /*
1587    * When we finally deprecate 1.1 compatibility, we can start to use
1588    * URLEncoder.encode(url,"UTF-8") and then we'll need this catch: catch
1589    * (UnsupportedEncodingException ex) { jalview.bin.Console.errPrintln("WARNING -
1590    * IMPLEMENTATION ERROR - UNSUPPORTED ENCODING EXCEPTION FOR "+url);
1591    * ex.printStackTrace(); }
1592    */
1593    catch (java.net.MalformedURLException ex)
1594    {
1595  0 url = viewport.applet.getCodeBase() + url;
1596    } catch (UnsupportedEncodingException ex)
1597    {
1598  0 jalview.bin.Console.errPrintln(
1599    "WARNING = IMPLEMENTATION ERROR - UNSUPPORTED ENCODING EXCEPTION FOR "
1600    + url);
1601  0 ex.printStackTrace();
1602    }
1603  0 return url;
1604    }
1605   
 
1606  0 toggle public void closeMenuItem_actionPerformed()
1607    {
1608  0 PaintRefresher.RemoveComponent(alignPanel);
1609  0 if (alignPanel.seqPanel != null
1610    && alignPanel.seqPanel.seqCanvas != null)
1611    {
1612  0 PaintRefresher.RemoveComponent(alignPanel.seqPanel.seqCanvas);
1613    }
1614  0 if (alignPanel.idPanel != null && alignPanel.idPanel.idCanvas != null)
1615    {
1616  0 PaintRefresher.RemoveComponent(alignPanel.idPanel.idCanvas);
1617    }
1618   
1619  0 if (PaintRefresher.components.size() == 0 && viewport.applet == null)
1620    {
1621  0 System.exit(0);
1622    }
1623   
1624  0 viewport = null;
1625  0 if (alignPanel != null && alignPanel.overviewPanel != null)
1626    {
1627  0 alignPanel.overviewPanel.dispose();
1628    }
1629  0 alignPanel = null;
1630  0 this.dispose();
1631    }
1632   
1633    /**
1634    * TODO: JAL-1104
1635    */
 
1636  0 toggle void updateEditMenuBar()
1637    {
1638   
1639  0 if (viewport.getHistoryList().size() > 0)
1640    {
1641  0 undoMenuItem.setEnabled(true);
1642  0 CommandI command = viewport.getHistoryList().peek();
1643  0 undoMenuItem.setLabel(MessageManager
1644    .formatMessage("label.undo_command", new Object[]
1645    { command.getDescription() }));
1646    }
1647    else
1648    {
1649  0 undoMenuItem.setEnabled(false);
1650  0 undoMenuItem.setLabel(MessageManager.getString("action.undo"));
1651    }
1652   
1653  0 if (viewport.getRedoList().size() > 0)
1654    {
1655  0 redoMenuItem.setEnabled(true);
1656   
1657  0 CommandI command = viewport.getRedoList().peek();
1658  0 redoMenuItem.setLabel(MessageManager
1659    .formatMessage("label.redo_command", new Object[]
1660    { command.getDescription() }));
1661    }
1662    else
1663    {
1664  0 redoMenuItem.setEnabled(false);
1665  0 redoMenuItem.setLabel(MessageManager.getString("action.redo"));
1666    }
1667    }
1668   
1669    /**
1670    * TODO: JAL-1104
1671    */
 
1672  0 toggle @Override
1673    public void addHistoryItem(CommandI command)
1674    {
1675  0 if (command.getSize() > 0)
1676    {
1677  0 viewport.addToHistoryList(command);
1678  0 viewport.clearRedoList();
1679  0 updateEditMenuBar();
1680  0 viewport.updateHiddenColumns();
1681    }
1682    }
1683   
1684    /**
1685    * TODO: JAL-1104 DOCUMENT ME!
1686    *
1687    * @param e
1688    * DOCUMENT ME!
1689    */
 
1690  0 toggle protected void undoMenuItem_actionPerformed()
1691    {
1692  0 if (viewport.getHistoryList().isEmpty())
1693    {
1694  0 return;
1695    }
1696   
1697  0 CommandI command = viewport.getHistoryList().pop();
1698  0 viewport.addToRedoList(command);
1699  0 command.undoCommand(null);
1700   
1701  0 AlignmentViewport originalSource = getOriginatingSource(command);
1702    // JBPNote Test
1703  0 if (originalSource != viewport)
1704    {
1705  0 System.err
1706    .println("Warning: Viewport object mismatch whilst undoing");
1707    }
1708  0 originalSource.updateHiddenColumns(); // originalSource.hasHiddenColumns =
1709    // viewport.getColumnSelection().getHiddenColumns()
1710    // != null;
1711  0 updateEditMenuBar();
1712  0 originalSource.notifyAlignment();
1713    }
1714   
1715    /**
1716    * TODO: JAL-1104 DOCUMENT ME!
1717    *
1718    * @param e
1719    * DOCUMENT ME!
1720    */
 
1721  0 toggle protected void redoMenuItem_actionPerformed()
1722    {
1723  0 if (viewport.getRedoList().isEmpty())
1724    {
1725  0 return;
1726    }
1727   
1728  0 CommandI command = viewport.getRedoList().pop();
1729  0 viewport.addToHistoryList(command);
1730  0 command.doCommand(null);
1731   
1732  0 AlignmentViewport originalSource = getOriginatingSource(command);
1733    // JBPNote Test
1734  0 if (originalSource != viewport)
1735    {
1736  0 System.err
1737    .println("Warning: Viewport object mismatch whilst re-doing");
1738    }
1739  0 originalSource.updateHiddenColumns(); // sethasHiddenColumns(); =
1740    // viewport.getColumnSelection().getHiddenColumns()
1741    // != null;
1742   
1743  0 updateEditMenuBar();
1744  0 originalSource.notifyAlignment();
1745    }
1746   
 
1747  0 toggle AlignmentViewport getOriginatingSource(CommandI command)
1748    {
1749  0 AlignmentViewport originalSource = null;
1750    // For sequence removal and addition, we need to fire
1751    // the property change event FROM the viewport where the
1752    // original alignment was altered
1753  0 AlignmentI al = null;
1754  0 if (command instanceof EditCommand)
1755    {
1756  0 EditCommand editCommand = (EditCommand) command;
1757  0 al = editCommand.getAlignment();
1758  0 Vector comps = PaintRefresher.components
1759    .get(viewport.getSequenceSetId());
1760  0 for (int i = 0; i < comps.size(); i++)
1761    {
1762  0 if (comps.elementAt(i) instanceof AlignmentPanel)
1763    {
1764  0 if (al == ((AlignmentPanel) comps.elementAt(i)).av.getAlignment())
1765    {
1766  0 originalSource = ((AlignmentPanel) comps.elementAt(i)).av;
1767  0 break;
1768    }
1769    }
1770    }
1771    }
1772   
1773  0 if (originalSource == null)
1774    {
1775    // The original view is closed, we must validate
1776    // the current view against the closed view first
1777  0 if (al != null)
1778    {
1779  0 PaintRefresher.validateSequences(al, viewport.getAlignment());
1780    }
1781   
1782  0 originalSource = viewport;
1783    }
1784   
1785  0 return originalSource;
1786    }
1787   
1788    /**
1789    * Move the currently selected sequences up or down one position in the
1790    * alignment
1791    *
1792    * @param up
1793    */
 
1794  0 toggle public void moveSelectedSequences(boolean up)
1795    {
1796  0 SequenceGroup sg = viewport.getSelectionGroup();
1797  0 if (sg == null)
1798    {
1799  0 return;
1800    }
1801  0 viewport.getAlignment().moveSelectedSequencesByOne(sg,
1802  0 up ? null : viewport.getHiddenRepSequences(), up);
1803  0 alignPanel.paintAlignment(true, false);
1804   
1805    /*
1806    * Also move cDNA/protein complement sequences
1807    */
1808  0 AlignViewportI complement = viewport.getCodingComplement();
1809  0 if (complement != null)
1810    {
1811  0 SequenceGroup mappedSelection = MappingUtils.mapSequenceGroup(sg,
1812    viewport, complement);
1813  0 complement.getAlignment().moveSelectedSequencesByOne(mappedSelection,
1814  0 up ? null : complement.getHiddenRepSequences(), up);
1815  0 getSplitFrame().getComplement(this).alignPanel.paintAlignment(true,
1816    false);
1817    }
1818    }
1819   
 
1820  0 toggle synchronized void slideSequences(boolean right, int size)
1821    {
1822  0 List<SequenceI> sg = new Vector<>();
1823  0 if (viewport.cursorMode)
1824    {
1825  0 sg.add(viewport.getAlignment()
1826    .getSequenceAt(alignPanel.seqPanel.seqCanvas.cursorY));
1827    }
1828  0 else if (viewport.getSelectionGroup() != null
1829    && viewport.getSelectionGroup().getSize() != viewport
1830    .getAlignment().getHeight())
1831    {
1832  0 sg = viewport.getSelectionGroup()
1833    .getSequences(viewport.getHiddenRepSequences());
1834    }
1835   
1836  0 if (sg.size() < 1)
1837    {
1838  0 return;
1839    }
1840   
1841  0 Vector<SequenceI> invertGroup = new Vector();
1842   
1843  0 for (int i = 0; i < viewport.getAlignment().getHeight(); i++)
1844    {
1845  0 if (!sg.contains(viewport.getAlignment().getSequenceAt(i)))
1846    {
1847  0 invertGroup.addElement(viewport.getAlignment().getSequenceAt(i));
1848    }
1849    }
1850   
1851  0 SequenceI[] seqs1 = sg.toArray(new SequenceI[sg.size()]);
1852   
1853  0 SequenceI[] seqs2 = invertGroup
1854    .toArray(new SequenceI[invertGroup.size()]);
1855  0 for (int i = 0; i < invertGroup.size(); i++)
1856    {
1857  0 seqs2[i] = invertGroup.elementAt(i);
1858    }
1859   
1860  0 SlideSequencesCommand ssc;
1861  0 if (right)
1862    {
1863  0 ssc = new SlideSequencesCommand("Slide Sequences", seqs2, seqs1, size,
1864    viewport.getGapCharacter());
1865    }
1866    else
1867    {
1868  0 ssc = new SlideSequencesCommand("Slide Sequences", seqs1, seqs2, size,
1869    viewport.getGapCharacter());
1870    }
1871   
1872  0 int groupAdjustment = 0;
1873  0 if (ssc.getGapsInsertedBegin() && right)
1874    {
1875  0 if (viewport.cursorMode)
1876    {
1877  0 alignPanel.seqPanel.moveCursor(size, 0);
1878    }
1879    else
1880    {
1881  0 groupAdjustment = size;
1882    }
1883    }
1884  0 else if (!ssc.getGapsInsertedBegin() && !right)
1885    {
1886  0 if (viewport.cursorMode)
1887    {
1888  0 alignPanel.seqPanel.moveCursor(-size, 0);
1889    }
1890    else
1891    {
1892  0 groupAdjustment = -size;
1893    }
1894    }
1895   
1896  0 if (groupAdjustment != 0)
1897    {
1898  0 viewport.getSelectionGroup().setStartRes(
1899    viewport.getSelectionGroup().getStartRes() + groupAdjustment);
1900  0 viewport.getSelectionGroup().setEndRes(
1901    viewport.getSelectionGroup().getEndRes() + groupAdjustment);
1902    }
1903   
1904  0 boolean appendHistoryItem = false;
1905  0 Deque<CommandI> historyList = viewport.getHistoryList();
1906  0 if (historyList != null && historyList.size() > 0
1907    && historyList.peek() instanceof SlideSequencesCommand)
1908    {
1909  0 appendHistoryItem = ssc.appendSlideCommand(
1910    (SlideSequencesCommand) historyList.peek());
1911    }
1912   
1913  0 if (!appendHistoryItem)
1914    {
1915  0 addHistoryItem(ssc);
1916    }
1917   
1918  0 repaint();
1919    }
1920   
1921    static StringBuffer copiedSequences;
1922   
1923    static HiddenColumns copiedHiddenColumns;
1924   
 
1925  0 toggle protected void copy_actionPerformed()
1926    {
1927  0 if (viewport.getSelectionGroup() == null)
1928    {
1929  0 return;
1930    }
1931   
1932  0 SequenceGroup sg = viewport.getSelectionGroup();
1933  0 copiedSequences = new StringBuffer();
1934  0 Map<Integer, SequenceI> orderedSeqs = new HashMap<>();
1935  0 for (int i = 0; i < sg.getSize(); i++)
1936    {
1937  0 SequenceI seq = sg.getSequenceAt(i);
1938  0 int index = viewport.getAlignment().findIndex(seq);
1939  0 orderedSeqs.put(index, seq);
1940    }
1941   
1942  0 int index = 0, startRes, endRes;
1943  0 char ch;
1944   
1945  0 if (viewport.hasHiddenColumns() && viewport.getSelectionGroup() != null)
1946    {
1947  0 int hiddenOffset = viewport.getSelectionGroup().getStartRes();
1948  0 int hiddenCutoff = viewport.getSelectionGroup().getEndRes();
1949   
1950    // create new HiddenColumns object with copy of hidden regions
1951    // between startRes and endRes, offset by startRes
1952  0 copiedHiddenColumns = new HiddenColumns(
1953    viewport.getAlignment().getHiddenColumns(), hiddenOffset,
1954    hiddenCutoff, hiddenOffset);
1955    }
1956    else
1957    {
1958  0 copiedHiddenColumns = null;
1959    }
1960   
1961  0 for (int i = 0; i < sg.getSize(); i++)
1962    {
1963  0 SequenceI seq = null;
1964   
1965  0 while (seq == null)
1966    {
1967  0 if (orderedSeqs.containsKey(index))
1968    {
1969  0 seq = orderedSeqs.get(index);
1970  0 index++;
1971  0 break;
1972    }
1973    else
1974    {
1975  0 index++;
1976    }
1977    }
1978   
1979    // FIND START RES
1980    // Returns residue following index if gap
1981  0 startRes = seq.findPosition(sg.getStartRes());
1982   
1983    // FIND END RES
1984    // Need to find the residue preceeding index if gap
1985  0 endRes = 0;
1986   
1987  0 for (int j = 0; j < sg.getEndRes() + 1 && j < seq.getLength(); j++)
1988    {
1989  0 ch = seq.getCharAt(j);
1990  0 if (!jalview.util.Comparison.isGap((ch)))
1991    {
1992  0 endRes++;
1993    }
1994    }
1995   
1996  0 if (endRes > 0)
1997    {
1998  0 endRes += seq.getStart() - 1;
1999    }
2000   
2001  0 copiedSequences.append(seq.getName() + "\t" + startRes + "\t" + endRes
2002    + "\t" + seq.getSequenceAsString(sg.getStartRes(),
2003    sg.getEndRes() + 1)
2004    + "\n");
2005    }
2006   
2007    }
2008   
 
2009  0 toggle protected void pasteNew_actionPerformed()
2010    {
2011  0 paste(true);
2012    }
2013   
 
2014  0 toggle protected void pasteThis_actionPerformed()
2015    {
2016  0 paste(false);
2017    }
2018   
 
2019  0 toggle void paste(boolean newAlignment)
2020    {
2021  0 try
2022    {
2023  0 if (copiedSequences == null)
2024    {
2025  0 return;
2026    }
2027   
2028  0 StringTokenizer st = new StringTokenizer(copiedSequences.toString(),
2029    "\t");
2030  0 Vector seqs = new Vector();
2031  0 while (st.hasMoreElements())
2032    {
2033  0 String name = st.nextToken();
2034  0 int start = Integer.parseInt(st.nextToken());
2035  0 int end = Integer.parseInt(st.nextToken());
2036  0 seqs.addElement(new Sequence(name, st.nextToken(), start, end));
2037    }
2038  0 SequenceI[] newSeqs = new SequenceI[seqs.size()];
2039  0 for (int i = 0; i < seqs.size(); i++)
2040    {
2041  0 newSeqs[i] = (SequenceI) seqs.elementAt(i);
2042    }
2043   
2044  0 if (newAlignment)
2045    {
2046  0 String newtitle = MessageManager
2047    .getString("label.copied_sequences");
2048  0 if (getTitle().startsWith(
2049    MessageManager.getString("label.copied_sequences")))
2050    {
2051  0 newtitle = getTitle();
2052    }
2053    else
2054    {
2055  0 newtitle = newtitle.concat(MessageManager
2056    .formatMessage("label.from_msname", new String[]
2057    { getTitle() }));
2058    }
2059  0 AlignFrame af = new AlignFrame(new Alignment(newSeqs),
2060    viewport.applet, newtitle, false);
2061  0 af.viewport.setHiddenColumns(copiedHiddenColumns);
2062   
2063  0 jalview.bin.JalviewLite.addFrame(af, newtitle, frameWidth,
2064    frameHeight);
2065    }
2066    else
2067    {
2068  0 addSequences(newSeqs);
2069    }
2070   
2071    } catch (Exception ex)
2072    {
2073    } // could be anything being pasted in here
2074   
2075    }
2076   
 
2077  0 toggle void addSequences(SequenceI[] seqs)
2078    {
2079  0 for (int i = 0; i < seqs.length; i++)
2080    {
2081  0 viewport.getAlignment().addSequence(seqs[i]);
2082    }
2083   
2084    // !newAlignment
2085  0 addHistoryItem(new EditCommand(
2086    MessageManager.getString("label.add_sequences"), Action.PASTE,
2087    seqs, 0, viewport.getAlignment().getWidth(),
2088    viewport.getAlignment()));
2089   
2090  0 viewport.getRanges().setEndSeq(viewport.getAlignment().getHeight() - 1); // BH
2091    // 2019.04.18
2092  0 viewport.getAlignment().getWidth();
2093  0 viewport.notifyAlignment();
2094   
2095    }
2096   
 
2097  0 toggle protected void cut_actionPerformed()
2098    {
2099  0 copy_actionPerformed();
2100  0 delete_actionPerformed();
2101    }
2102   
 
2103  0 toggle protected void delete_actionPerformed()
2104    {
2105   
2106  0 SequenceGroup sg = viewport.getSelectionGroup();
2107  0 if (sg == null)
2108    {
2109  0 return;
2110    }
2111   
2112  0 Vector seqs = new Vector();
2113  0 SequenceI seq;
2114  0 for (int i = 0; i < sg.getSize(); i++)
2115    {
2116  0 seq = sg.getSequenceAt(i);
2117  0 seqs.addElement(seq);
2118    }
2119   
2120    /*
2121    * If the cut affects all sequences, warn, remove highlighted columns
2122    */
2123  0 if (sg.getSize() == viewport.getAlignment().getHeight())
2124    {
2125  0 boolean isEntireAlignWidth = (((sg.getEndRes() - sg.getStartRes())
2126    + 1) == viewport.getAlignment().getWidth()) ? true : false;
2127  0 if (isEntireAlignWidth)
2128    {
2129  0 String title = MessageManager.getString("label.delete_all");
2130  0 Panel infoPanel = new Panel();
2131  0 infoPanel.setLayout(new FlowLayout());
2132  0 infoPanel.add(
2133    new Label(MessageManager.getString("warn.delete_all")));
2134   
2135  0 final JVDialog dialog = new JVDialog(this, title, true, 400, 200);
2136  0 dialog.setMainPanel(infoPanel);
2137  0 dialog.ok.setLabel(MessageManager.getString("action.ok"));
2138  0 dialog.cancel.setLabel(MessageManager.getString("action.cancel"));
2139  0 dialog.setVisible(true);
2140   
2141  0 if (!dialog.accept)
2142    {
2143  0 return;
2144    }
2145    }
2146  0 viewport.getColumnSelection().removeElements(sg.getStartRes(),
2147    sg.getEndRes() + 1);
2148    }
2149   
2150  0 SequenceI[] cut = new SequenceI[seqs.size()];
2151  0 for (int i = 0; i < seqs.size(); i++)
2152    {
2153  0 cut[i] = (SequenceI) seqs.elementAt(i);
2154    }
2155   
2156    /*
2157    * //ADD HISTORY ITEM
2158    */
2159  0 addHistoryItem(new EditCommand(
2160    MessageManager.getString("label.cut_sequences"), Action.CUT,
2161    cut, sg.getStartRes(), sg.getEndRes() - sg.getStartRes() + 1,
2162    viewport.getAlignment()));
2163   
2164  0 viewport.setSelectionGroup(null);
2165  0 viewport.getAlignment().deleteGroup(sg);
2166   
2167  0 viewport.notifyAlignment();
2168   
2169  0 if (viewport.getAlignment().getHeight() < 1)
2170    {
2171  0 this.setVisible(false);
2172    }
2173  0 viewport.sendSelection();
2174    }
2175   
2176    /**
2177    * group consensus toggled
2178    *
2179    */
 
2180  0 toggle protected void showGroupConsensus_actionPerformed()
2181    {
2182  0 viewport.setShowGroupConsensus(showGroupConsensus.getState());
2183  0 alignPanel.updateAnnotation(applyAutoAnnotationSettings.getState());
2184   
2185    }
2186   
2187    /**
2188    * group conservation toggled.
2189    */
 
2190  0 toggle protected void showGroupConservation_actionPerformed()
2191    {
2192  0 viewport.setShowGroupConservation(showGroupConservation.getState());
2193  0 alignPanel.updateAnnotation(applyAutoAnnotationSettings.getState());
2194    }
2195   
2196    /*
2197    * (non-Javadoc)
2198    *
2199    * @see
2200    * jalview.jbgui.GAlignFrame#showConsensusHistogram_actionPerformed(java.awt
2201    * .event.ActionEvent)
2202    */
 
2203  0 toggle protected void showConsensusHistogram_actionPerformed()
2204    {
2205  0 viewport.setShowConsensusHistogram(showConsensusHistogram.getState());
2206  0 alignPanel.updateAnnotation(applyAutoAnnotationSettings.getState());
2207    }
2208   
2209    /*
2210    * (non-Javadoc)
2211    *
2212    * @see
2213    * jalview.jbgui.GAlignFrame#showConsensusProfile_actionPerformed(java.awt
2214    * .event.ActionEvent)
2215    */
 
2216  0 toggle protected void showSequenceLogo_actionPerformed()
2217    {
2218  0 viewport.setShowSequenceLogo(showSequenceLogo.getState());
2219  0 alignPanel.updateAnnotation(applyAutoAnnotationSettings.getState());
2220    }
2221   
 
2222  0 toggle protected void normSequenceLogo_actionPerformed()
2223    {
2224  0 showSequenceLogo.setState(true);
2225  0 viewport.setShowSequenceLogo(true);
2226  0 viewport.setNormaliseSequenceLogo(normSequenceLogo.getState());
2227  0 alignPanel.updateAnnotation(applyAutoAnnotationSettings.getState());
2228    }
2229   
 
2230  0 toggle protected void applyAutoAnnotationSettings_actionPerformed()
2231    {
2232  0 alignPanel.updateAnnotation(applyAutoAnnotationSettings.getState());
2233    }
2234   
 
2235  0 toggle protected void makeGrpsFromSelection_actionPerformed()
2236    {
2237  0 if (avc.makeGroupsFromSelection())
2238    {
2239  0 PaintRefresher.Refresh(this, viewport.getSequenceSetId());
2240  0 alignPanel.updateAnnotation();
2241  0 alignPanel.paintAlignment(true, true);
2242    }
2243    }
2244   
 
2245  0 toggle protected void createGroup_actionPerformed()
2246    {
2247  0 avc.createGroup();
2248    }
2249   
 
2250  0 toggle protected void unGroup_actionPerformed()
2251    {
2252  0 if (avc.unGroup())
2253    {
2254  0 alignPanel.alignmentChanged();
2255    }
2256    }
2257   
 
2258  0 toggle protected void deleteGroups_actionPerformed()
2259    {
2260  0 if (avc.deleteGroups())
2261    {
2262  0 alignPanel.alignmentChanged();
2263    }
2264    }
2265   
 
2266  0 toggle public void selectAllSequenceMenuItem_actionPerformed()
2267    {
2268  0 SequenceGroup sg = new SequenceGroup();
2269  0 for (int i = 0; i < viewport.getAlignment().getSequences().size(); i++)
2270    {
2271  0 sg.addSequence(viewport.getAlignment().getSequenceAt(i), false);
2272    }
2273  0 sg.setEndRes(viewport.getAlignment().getWidth() - 1);
2274  0 viewport.setSelectionGroup(sg);
2275    // JAL-2034 - should delegate to
2276    // alignPanel to decide if overview needs
2277    // updating.
2278  0 alignPanel.paintAlignment(false, false);
2279  0 PaintRefresher.Refresh(alignPanel, viewport.getSequenceSetId());
2280  0 viewport.sendSelection();
2281    }
2282   
 
2283  0 toggle public void deselectAllSequenceMenuItem_actionPerformed()
2284    {
2285  0 if (viewport.cursorMode)
2286    {
2287  0 alignPanel.seqPanel.keyboardNo1 = null;
2288  0 alignPanel.seqPanel.keyboardNo2 = null;
2289    }
2290  0 viewport.setSelectionGroup(null);
2291  0 viewport.getColumnSelection().clear();
2292  0 viewport.setSelectionGroup(null);
2293  0 alignPanel.idPanel.idCanvas.searchResults = null;
2294  0 alignPanel.seqPanel.seqCanvas.highlightSearchResults(null);
2295    // JAL-2034 - should delegate to
2296    // alignPanel to decide if overview needs
2297    // updating.
2298  0 alignPanel.paintAlignment(false, false);
2299  0 PaintRefresher.Refresh(alignPanel, viewport.getSequenceSetId());
2300  0 viewport.sendSelection();
2301    }
2302   
 
2303  0 toggle public void invertSequenceMenuItem_actionPerformed()
2304    {
2305  0 SequenceGroup sg = viewport.getSelectionGroup();
2306  0 for (int i = 0; i < viewport.getAlignment().getSequences().size(); i++)
2307    {
2308  0 sg.addOrRemove(viewport.getAlignment().getSequenceAt(i), false);
2309    }
2310   
2311  0 PaintRefresher.Refresh(alignPanel, viewport.getSequenceSetId());
2312  0 viewport.sendSelection();
2313    }
2314   
 
2315  0 toggle public void invertColSel_actionPerformed()
2316    {
2317  0 viewport.invertColumnSelection();
2318  0 alignPanel.paintAlignment(true, false);
2319  0 PaintRefresher.Refresh(alignPanel, viewport.getSequenceSetId());
2320  0 viewport.sendSelection();
2321    }
2322   
 
2323  0 toggle void trimAlignment(boolean trimLeft)
2324    {
2325  0 AlignmentI al = viewport.getAlignment();
2326  0 ViewportRanges ranges = viewport.getRanges();
2327  0 ColumnSelection colSel = viewport.getColumnSelection();
2328  0 int column;
2329   
2330  0 if (!colSel.isEmpty())
2331    {
2332  0 if (trimLeft)
2333    {
2334  0 column = colSel.getMin();
2335    }
2336    else
2337    {
2338  0 column = colSel.getMax();
2339    }
2340   
2341  0 SequenceI[] seqs;
2342  0 if (viewport.getSelectionGroup() != null)
2343    {
2344  0 seqs = viewport.getSelectionGroup()
2345    .getSequencesAsArray(viewport.getHiddenRepSequences());
2346    }
2347    else
2348    {
2349  0 seqs = al.getSequencesArray();
2350    }
2351   
2352  0 TrimRegionCommand trimRegion;
2353  0 if (trimLeft)
2354    {
2355  0 trimRegion = new TrimRegionCommand("Remove Left", true, seqs,
2356    column, al);
2357  0 ranges.setStartRes(0);
2358    }
2359    else
2360    {
2361  0 trimRegion = new TrimRegionCommand("Remove Right", false, seqs,
2362    column, al);
2363    }
2364   
2365  0 setStatus(MessageManager.formatMessage("label.removed_columns",
2366    new String[]
2367    { Integer.valueOf(trimRegion.getSize()).toString() }));
2368  0 addHistoryItem(trimRegion);
2369   
2370  0 for (SequenceGroup sg : al.getGroups())
2371    {
2372  0 if ((trimLeft && !sg.adjustForRemoveLeft(column))
2373    || (!trimLeft && !sg.adjustForRemoveRight(column)))
2374    {
2375  0 al.deleteGroup(sg);
2376    }
2377    }
2378   
2379  0 viewport.notifyAlignment();
2380    }
2381    }
2382   
 
2383  0 toggle public void removeGappedColumnMenuItem_actionPerformed()
2384    {
2385  0 AlignmentI al = viewport.getAlignment();
2386  0 ViewportRanges ranges = viewport.getRanges();
2387  0 int start = 0;
2388  0 int end = ranges.getAbsoluteAlignmentWidth() - 1;
2389   
2390  0 SequenceI[] seqs;
2391  0 if (viewport.getSelectionGroup() != null)
2392    {
2393  0 seqs = viewport.getSelectionGroup()
2394    .getSequencesAsArray(viewport.getHiddenRepSequences());
2395  0 start = viewport.getSelectionGroup().getStartRes();
2396  0 end = viewport.getSelectionGroup().getEndRes();
2397    }
2398    else
2399    {
2400  0 seqs = viewport.getAlignment().getSequencesArray();
2401    }
2402   
2403  0 RemoveGapColCommand removeGapCols = new RemoveGapColCommand(
2404    "Remove Gapped Columns", seqs, start, end,
2405    viewport.getAlignment());
2406   
2407  0 addHistoryItem(removeGapCols);
2408   
2409  0 setStatus(MessageManager.formatMessage("label.removed_empty_columns",
2410    new String[]
2411    { Integer.valueOf(removeGapCols.getSize()).toString() }));
2412   
2413    // This is to maintain viewport position on first residue
2414    // of first sequence
2415  0 SequenceI seq = al.getSequenceAt(0);
2416  0 int startRes = seq.findPosition(ranges.getStartRes());
2417    // ShiftList shifts;
2418    // viewport.getAlignment().removeGaps(shifts=new ShiftList());
2419    // edit.alColumnChanges=shifts.getInverse();
2420    // if (viewport.hasHiddenColumns)
2421    // viewport.getColumnSelection().compensateForEdits(shifts);
2422  0 ranges.setStartRes(seq.findIndex(startRes) - 1);
2423  0 viewport.notifyAlignment();
2424   
2425    }
2426   
 
2427  0 toggle public void removeAllGapsMenuItem_actionPerformed()
2428    {
2429  0 AlignmentI al = viewport.getAlignment();
2430  0 ViewportRanges ranges = viewport.getRanges();
2431  0 int start = 0;
2432  0 int end = ranges.getAbsoluteAlignmentWidth() - 1;
2433   
2434  0 SequenceI[] seqs;
2435  0 if (viewport.getSelectionGroup() != null)
2436    {
2437  0 seqs = viewport.getSelectionGroup()
2438    .getSequencesAsArray(viewport.getHiddenRepSequences());
2439  0 start = viewport.getSelectionGroup().getStartRes();
2440  0 end = viewport.getSelectionGroup().getEndRes();
2441    }
2442    else
2443    {
2444  0 seqs = viewport.getAlignment().getSequencesArray();
2445    }
2446   
2447    // This is to maintain viewport position on first residue
2448    // of first sequence
2449  0 SequenceI seq = al.getSequenceAt(0);
2450  0 int startRes = seq.findPosition(ranges.getStartRes());
2451   
2452  0 addHistoryItem(
2453    new RemoveGapsCommand("Remove Gaps", seqs, start, end, al));
2454   
2455  0 ranges.setStartRes(seq.findIndex(startRes) - 1);
2456   
2457  0 viewport.notifyAlignment();
2458   
2459    }
2460   
 
2461  0 toggle public void findMenuItem_actionPerformed()
2462    {
2463  0 new Finder(alignPanel);
2464    }
2465   
2466    /**
2467    * create a new view derived from the current view
2468    *
2469    * @param viewtitle
2470    * @return frame for the new view
2471    */
 
2472  0 toggle public AlignFrame newView(String viewtitle)
2473    {
2474  0 AlignmentI newal;
2475  0 if (viewport.hasHiddenRows())
2476    {
2477  0 newal = new Alignment(viewport.getAlignment().getHiddenSequences()
2478    .getFullAlignment().getSequencesArray());
2479    }
2480    else
2481    {
2482  0 newal = new Alignment(viewport.getAlignment().getSequencesArray());
2483    }
2484   
2485  0 if (viewport.getAlignment().getAlignmentAnnotation() != null)
2486    {
2487  0 for (int i = 0; i < viewport.getAlignment()
2488    .getAlignmentAnnotation().length; i++)
2489    {
2490  0 if (!viewport.getAlignment()
2491    .getAlignmentAnnotation()[i].autoCalculated)
2492    {
2493  0 newal.addAnnotation(
2494    viewport.getAlignment().getAlignmentAnnotation()[i]);
2495    }
2496    }
2497    }
2498   
2499  0 AlignFrame newaf = new AlignFrame(newal, viewport.applet, "", false);
2500   
2501  0 newaf.viewport.setSequenceSetId(alignPanel.av.getSequenceSetId());
2502  0 PaintRefresher.Register(alignPanel, alignPanel.av.getSequenceSetId());
2503  0 PaintRefresher.Register(newaf.alignPanel,
2504    newaf.alignPanel.av.getSequenceSetId());
2505   
2506  0 PaintRefresher.Register(newaf.alignPanel.idPanel.idCanvas,
2507    newaf.alignPanel.av.getSequenceSetId());
2508  0 PaintRefresher.Register(newaf.alignPanel.seqPanel.seqCanvas,
2509    newaf.alignPanel.av.getSequenceSetId());
2510   
2511  0 Vector comps = PaintRefresher.components
2512    .get(viewport.getSequenceSetId());
2513  0 int viewSize = -1;
2514  0 for (int i = 0; i < comps.size(); i++)
2515    {
2516  0 if (comps.elementAt(i) instanceof AlignmentPanel)
2517    {
2518  0 viewSize++;
2519    }
2520    }
2521   
2522  0 String title = new String(this.getTitle());
2523  0 if (viewtitle != null)
2524    {
2525  0 title = viewtitle + " ( " + title + ")";
2526    }
2527    else
2528    {
2529  0 if (title.indexOf("(View") > -1)
2530    {
2531  0 title = title.substring(0, title.indexOf("(View"));
2532    }
2533  0 title += "(View " + viewSize + ")";
2534    }
2535   
2536  0 newaf.setTitle(title.toString());
2537   
2538  0 newaf.viewport.setHistoryList(viewport.getHistoryList());
2539  0 newaf.viewport.setRedoList(viewport.getRedoList());
2540  0 return newaf;
2541    }
2542   
2543    /**
2544    *
2545    * @return list of feature groups on the view
2546    */
 
2547  0 toggle public String[] getFeatureGroups()
2548    {
2549  0 FeatureRenderer fr = null;
2550  0 if (alignPanel != null
2551    && (fr = alignPanel.getFeatureRenderer()) != null)
2552    {
2553  0 List<String> gps = fr.getFeatureGroups();
2554  0 String[] _gps = gps.toArray(new String[gps.size()]);
2555  0 return _gps;
2556    }
2557  0 return null;
2558    }
2559   
2560    /**
2561    * get sequence feature groups that are hidden or shown
2562    *
2563    * @param visible
2564    * true is visible
2565    * @return list
2566    */
 
2567  0 toggle public String[] getFeatureGroupsOfState(boolean visible)
2568    {
2569  0 FeatureRenderer fr = null;
2570  0 if (alignPanel != null
2571    && (fr = alignPanel.getFeatureRenderer()) != null)
2572    {
2573  0 List<String> gps = fr.getGroups(visible);
2574  0 String[] _gps = gps.toArray(new String[gps.size()]);
2575  0 return _gps;
2576    }
2577  0 return null;
2578    }
2579   
2580    /**
2581    * Change the display state for the given feature groups
2582    *
2583    * @param groups
2584    * list of group strings
2585    * @param state
2586    * visible or invisible
2587    */
 
2588  0 toggle public void setFeatureGroupState(String[] groups, boolean state)
2589    {
2590  0 FeatureRenderer fr = null;
2591  0 this.sequenceFeatures.setState(true);
2592  0 viewport.setShowSequenceFeatures(true);
2593  0 if (alignPanel != null
2594    && (fr = alignPanel.getFeatureRenderer()) != null)
2595    {
2596   
2597  0 fr.setGroupVisibility(Arrays.asList(groups), state);
2598  0 alignPanel.seqPanel.seqCanvas.repaint();
2599  0 if (alignPanel.overviewPanel != null)
2600    {
2601  0 alignPanel.overviewPanel.updateOverviewImage();
2602    }
2603    }
2604    }
2605   
 
2606  0 toggle public void seqLimits_itemStateChanged()
2607    {
2608  0 viewport.setShowJVSuffix(seqLimits.getState());
2609  0 alignPanel.fontChanged();
2610  0 alignPanel.paintAlignment(true, false);
2611    }
2612   
 
2613  0 toggle protected void colourTextMenuItem_actionPerformed()
2614    {
2615  0 viewport.setColourText(colourTextMenuItem.getState());
2616  0 alignPanel.paintAlignment(false, false);
2617    }
2618   
 
2619  0 toggle protected void displayNonconservedMenuItem_actionPerformed()
2620    {
2621  0 viewport.setShowUnconserved(displayNonconservedMenuItem.getState());
2622  0 alignPanel.paintAlignment(false, false);
2623    }
2624   
 
2625  0 toggle protected void wrapMenuItem_actionPerformed()
2626    {
2627  0 viewport.setWrapAlignment(wrapMenuItem.getState());
2628  0 alignPanel.setWrapAlignment(wrapMenuItem.getState());
2629  0 scaleAbove.setEnabled(wrapMenuItem.getState());
2630  0 scaleLeft.setEnabled(wrapMenuItem.getState());
2631  0 scaleRight.setEnabled(wrapMenuItem.getState());
2632  0 alignPanel.paintAlignment(true, false);
2633    }
2634   
 
2635  0 toggle public void overviewMenuItem_actionPerformed()
2636    {
2637  0 if (alignPanel.overviewPanel != null)
2638    {
2639  0 return;
2640    }
2641   
2642  0 Frame frame = new Frame();
2643  0 final OverviewPanel overview = new OverviewPanel(alignPanel);
2644  0 frame.add(overview);
2645    // +50 must allow for applet frame window
2646  0 jalview.bin.JalviewLite.addFrame(frame, MessageManager
2647    .formatMessage("label.overview_params", new String[]
2648    { this.getTitle() }), overview.getPreferredSize().width,
2649    overview.getPreferredSize().height + 50);
2650   
2651  0 frame.pack();
2652  0 final AlignmentPanel ap = alignPanel;
2653  0 frame.addWindowListener(new WindowAdapter()
2654    {
 
2655  0 toggle @Override
2656    public void windowClosing(WindowEvent e)
2657    {
2658  0 overview.dispose();
2659  0 if (ap != null)
2660    {
2661  0 ap.setOverviewPanel(null);
2662    }
2663    };
2664    });
2665   
2666  0 alignPanel.setOverviewPanel(overview);
2667   
2668    }
2669   
 
2670  0 toggle @Override
2671    public void changeColour(ColourSchemeI cs)
2672    {
2673  0 viewport.setGlobalColourScheme(cs);
2674   
2675  0 alignPanel.paintAlignment(true, true);
2676    }
2677   
 
2678  0 toggle protected void modifyPID_actionPerformed()
2679    {
2680  0 if (viewport.getAbovePIDThreshold()
2681    && viewport.getGlobalColourScheme() != null)
2682    {
2683  0 SliderPanel.setPIDSliderSource(alignPanel,
2684    viewport.getResidueShading(), alignPanel.getViewName());
2685  0 SliderPanel.showPIDSlider();
2686    }
2687    }
2688   
 
2689  0 toggle protected void modifyConservation_actionPerformed()
2690    {
2691  0 if (viewport.getConservationSelected()
2692    && viewport.getGlobalColourScheme() != null)
2693    {
2694  0 SliderPanel.setConservationSlider(alignPanel,
2695    viewport.getResidueShading(), alignPanel.getViewName());
2696  0 SliderPanel.showConservationSlider();
2697    }
2698    }
2699   
 
2700  0 toggle protected void conservationMenuItem_actionPerformed()
2701    {
2702  0 boolean selected = conservationMenuItem.getState();
2703  0 modifyConservation.setEnabled(selected);
2704  0 viewport.setConservationSelected(selected);
2705  0 viewport.getResidueShading().setConservationApplied(selected);
2706   
2707  0 changeColour(viewport.getGlobalColourScheme());
2708   
2709  0 if (selected)
2710    {
2711  0 modifyConservation_actionPerformed();
2712    }
2713    else
2714    {
2715  0 SliderPanel.hideConservationSlider();
2716    }
2717    }
2718   
 
2719  0 toggle public void abovePIDThreshold_actionPerformed()
2720    {
2721  0 boolean selected = abovePIDThreshold.getState();
2722  0 modifyPID.setEnabled(selected);
2723  0 viewport.setAbovePIDThreshold(selected);
2724  0 if (!selected)
2725    {
2726  0 viewport.getResidueShading().setThreshold(0,
2727    viewport.isIgnoreGapsConsensus());
2728    }
2729   
2730  0 changeColour(viewport.getGlobalColourScheme());
2731   
2732  0 if (selected)
2733    {
2734  0 modifyPID_actionPerformed();
2735    }
2736    else
2737    {
2738  0 SliderPanel.hidePIDSlider();
2739    }
2740    }
2741   
 
2742  0 toggle public void sortPairwiseMenuItem_actionPerformed()
2743    {
2744  0 SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
2745  0 AlignmentSorter.sortByPID(viewport.getAlignment(),
2746    viewport.getAlignment().getSequenceAt(0));
2747   
2748  0 addHistoryItem(new OrderCommand("Pairwise Sort", oldOrder,
2749    viewport.getAlignment()));
2750  0 alignPanel.paintAlignment(true, false);
2751    }
2752   
 
2753  0 toggle public void sortIDMenuItem_actionPerformed()
2754    {
2755  0 SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
2756  0 AlignmentSorter.sortByID(viewport.getAlignment());
2757  0 addHistoryItem(
2758    new OrderCommand("ID Sort", oldOrder, viewport.getAlignment()));
2759  0 alignPanel.paintAlignment(true, false);
2760    }
2761   
 
2762  0 toggle public void sortLengthMenuItem_actionPerformed()
2763    {
2764  0 SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
2765  0 AlignmentSorter.sortByLength(viewport.getAlignment());
2766  0 addHistoryItem(new OrderCommand("Length Sort", oldOrder,
2767    viewport.getAlignment()));
2768  0 alignPanel.paintAlignment(true, false);
2769    }
2770   
 
2771  0 toggle public void sortGroupMenuItem_actionPerformed()
2772    {
2773  0 SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
2774  0 AlignmentSorter.sortByGroup(viewport.getAlignment());
2775  0 addHistoryItem(new OrderCommand("Group Sort", oldOrder,
2776    viewport.getAlignment()));
2777  0 alignPanel.paintAlignment(true, false);
2778   
2779    }
2780   
 
2781  0 toggle public void sortEValueMenuItem_actionPerformed()
2782    {
2783  0 SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
2784  0 AlignmentSorter.sortByEValue(viewport.getAlignment());
2785  0 addHistoryItem(new OrderCommand("Group Sort", oldOrder,
2786    viewport.getAlignment()));
2787  0 alignPanel.paintAlignment(true, false);
2788   
2789    }
2790   
 
2791  0 toggle public void sortBitScoreMenuItem_actionPerformed()
2792    {
2793  0 SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
2794  0 AlignmentSorter.sortByBitScore(viewport.getAlignment());
2795  0 addHistoryItem(new OrderCommand("Group Sort", oldOrder,
2796    viewport.getAlignment()));
2797  0 alignPanel.paintAlignment(true, false);
2798   
2799    }
2800   
 
2801  0 toggle public void removeRedundancyMenuItem_actionPerformed()
2802    {
2803  0 new RedundancyPanel(alignPanel);
2804    }
2805   
 
2806  0 toggle public void pairwiseAlignmentMenuItem_actionPerformed()
2807    {
2808  0 if (viewport.getSelectionGroup() != null
2809    && viewport.getSelectionGroup().getSize() > 1)
2810    {
2811  0 Frame frame = new Frame();
2812  0 frame.add(new PairwiseAlignPanel(alignPanel));
2813  0 jalview.bin.JalviewLite.addFrame(frame,
2814    MessageManager.getString("action.pairwise_alignment"), 600,
2815    500);
2816    }
2817    }
2818   
 
2819  0 toggle public void PCAMenuItem_actionPerformed()
2820    {
2821    // are the sequences aligned?
2822  0 if (!viewport.getAlignment().isAligned(false))
2823    {
2824  0 SequenceI current;
2825  0 int Width = viewport.getAlignment().getWidth();
2826   
2827  0 for (int i = 0; i < viewport.getAlignment().getSequences()
2828    .size(); i++)
2829    {
2830  0 current = viewport.getAlignment().getSequenceAt(i);
2831   
2832  0 if (current.getLength() < Width)
2833    {
2834  0 current.insertCharAt(Width - 1, viewport.getGapCharacter());
2835    }
2836    }
2837  0 alignPanel.paintAlignment(false, false);
2838    }
2839   
2840  0 if ((viewport.getSelectionGroup() != null
2841    && viewport.getSelectionGroup().getSize() < 4
2842    && viewport.getSelectionGroup().getSize() > 0)
2843    || viewport.getAlignment().getHeight() < 4)
2844    {
2845  0 return;
2846    }
2847   
2848  0 try
2849    {
2850  0 new PCAPanel(viewport);
2851    } catch (java.lang.OutOfMemoryError ex)
2852    {
2853    }
2854   
2855    }
2856   
 
2857  0 toggle public void averageDistanceTreeMenuItem_actionPerformed()
2858    {
2859  0 newTreePanel(TreeBuilder.AVERAGE_DISTANCE, new PIDModel().getName(),
2860    "Average distance tree using PID");
2861    }
2862   
 
2863  0 toggle public void neighbourTreeMenuItem_actionPerformed()
2864    {
2865  0 newTreePanel(TreeBuilder.NEIGHBOUR_JOINING, new PIDModel().getName(),
2866    "Neighbour joining tree using PID");
2867    }
2868   
 
2869  0 toggle protected void njTreeBlosumMenuItem_actionPerformed()
2870    {
2871  0 newTreePanel(TreeBuilder.NEIGHBOUR_JOINING,
2872    ScoreModels.getInstance().getBlosum62().getName(),
2873    "Neighbour joining tree using BLOSUM62");
2874    }
2875   
 
2876  0 toggle protected void avTreeBlosumMenuItem_actionPerformed()
2877    {
2878  0 newTreePanel(TreeBuilder.AVERAGE_DISTANCE,
2879    ScoreModels.getInstance().getBlosum62().getName(),
2880    "Average distance tree using BLOSUM62");
2881    }
2882   
 
2883  0 toggle void newTreePanel(String type, String pwType, String title)
2884    {
2885    // are the sequences aligned?
2886  0 if (!viewport.getAlignment().isAligned(false))
2887    {
2888  0 SequenceI current;
2889  0 int Width = viewport.getAlignment().getWidth();
2890   
2891  0 for (int i = 0; i < viewport.getAlignment().getSequences()
2892    .size(); i++)
2893    {
2894  0 current = viewport.getAlignment().getSequenceAt(i);
2895   
2896  0 if (current.getLength() < Width)
2897    {
2898  0 current.insertCharAt(Width - 1, viewport.getGapCharacter());
2899    }
2900    }
2901  0 alignPanel.paintAlignment(false, false);
2902   
2903    }
2904   
2905  0 if ((viewport.getSelectionGroup() != null
2906    && viewport.getSelectionGroup().getSize() > 1)
2907    || (viewport.getAlignment().getHeight() > 1))
2908    {
2909  0 final TreePanel tp = new TreePanel(alignPanel, type, pwType);
2910   
2911  0 addTreeMenuItem(tp, title);
2912   
2913  0 jalview.bin.JalviewLite.addFrame(tp, title, 600, 500);
2914    }
2915    }
2916   
 
2917  0 toggle void loadTree_actionPerformed()
2918    {
2919  0 CutAndPasteTransfer cap = new CutAndPasteTransfer(true, this);
2920  0 cap.setText(MessageManager.getString("label.paste_newick_tree_file"));
2921  0 cap.setTreeImport();
2922  0 Frame frame = new Frame();
2923  0 frame.add(cap);
2924  0 jalview.bin.JalviewLite.addFrame(frame,
2925    MessageManager.getString("label.paste_newick_file"), 400, 300);
2926    }
2927   
 
2928  0 toggle public void loadTree(jalview.io.NewickFile tree, String treeFile)
2929    {
2930  0 TreePanel tp = new TreePanel(alignPanel, treeFile,
2931    MessageManager.getString("label.load_tree_from_file"), tree);
2932  0 jalview.bin.JalviewLite.addFrame(tp, treeFile, 600, 500);
2933  0 addTreeMenuItem(tp, treeFile);
2934    }
2935   
2936    /**
2937    * sort the alignment using the given treePanel
2938    *
2939    * @param treePanel
2940    * tree used to sort view
2941    * @param title
2942    * string used for undo event name
2943    */
 
2944  0 toggle public void sortByTree(TreePanel treePanel, String title)
2945    {
2946  0 SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
2947  0 AlignmentSorter.sortByTree(viewport.getAlignment(),
2948    treePanel.getTree());
2949    // addHistoryItem(new HistoryItem("Sort", viewport.alignment,
2950    // HistoryItem.SORT));
2951  0 addHistoryItem(new OrderCommand(MessageManager
2952    .formatMessage("label.order_by_params", new String[]
2953    { title }), oldOrder, viewport.getAlignment()));
2954  0 alignPanel.paintAlignment(true, false);
2955    }
2956   
2957    /**
2958    * Do any automatic reordering of the alignment and add the necessary bits to
2959    * the menu structure for the new tree
2960    *
2961    * @param treePanel
2962    * @param title
2963    */
 
2964  0 toggle protected void addTreeMenuItem(final TreePanel treePanel,
2965    final String title)
2966    {
2967  0 final MenuItem item = new MenuItem(title);
2968  0 sortByTreeMenu.add(item);
2969  0 item.addActionListener(new java.awt.event.ActionListener()
2970    {
 
2971  0 toggle @Override
2972    public void actionPerformed(ActionEvent evt)
2973    {
2974  0 sortByTree(treePanel, title); // treePanel.getTitle());
2975    }
2976    });
2977   
2978  0 treePanel.addWindowListener(new WindowAdapter()
2979    {
 
2980  0 toggle @Override
2981    public void windowOpened(WindowEvent e)
2982    {
2983  0 if (viewport.sortByTree)
2984    {
2985  0 sortByTree(treePanel, title);
2986    }
2987  0 super.windowOpened(e);
2988    }
2989   
 
2990  0 toggle @Override
2991    public void windowClosing(WindowEvent e)
2992    {
2993  0 sortByTreeMenu.remove(item);
2994    };
2995    });
2996    }
2997   
 
2998  0 toggle public boolean sortBy(AlignmentOrder alorder, String undoname)
2999    {
3000  0 SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray();
3001  0 if (viewport.applet.debug)
3002    {
3003  0 jalview.bin.Console.errPrintln("Sorting " + alorder.getOrder().size()
3004    + " in alignment '" + getTitle() + "'");
3005    }
3006  0 AlignmentSorter.sortBy(viewport.getAlignment(), alorder);
3007  0 if (undoname != null)
3008    {
3009  0 addHistoryItem(new OrderCommand(undoname, oldOrder,
3010    viewport.getAlignment()));
3011    }
3012  0 alignPanel.paintAlignment(true, false);
3013  0 return true;
3014    }
3015   
 
3016  0 toggle protected void documentation_actionPerformed()
3017    {
3018  0 alignPanel.av.applet.openJalviewHelpUrl();
3019    }
3020   
 
3021  0 toggle protected void about_actionPerformed()
3022    {
3023   
 
3024    class AboutPanel extends Canvas
3025    {
3026    String version;
3027   
3028    String builddate;
3029   
 
3030  0 toggle public AboutPanel(String version, String builddate)
3031    {
3032  0 this.version = version;
3033  0 this.builddate = builddate;
3034    }
3035   
 
3036  0 toggle @Override
3037    public void paint(Graphics g)
3038    {
3039  0 g.setColor(Color.white);
3040  0 g.fillRect(0, 0, getSize().width, getSize().height);
3041  0 g.setFont(new Font("Helvetica", Font.PLAIN, 12));
3042  0 FontMetrics fm = g.getFontMetrics();
3043  0 int fh = fm.getHeight();
3044  0 int y = 5, x = 7;
3045  0 g.setColor(Color.black);
3046    // TODO: update this text for each release or centrally store it for
3047    // lite and application
3048  0 g.setFont(new Font("Helvetica", Font.BOLD, 14));
3049  0 g.drawString(MessageManager
3050    .formatMessage("label.jalviewLite_release", new String[]
3051    { version }), x, y += fh);
3052  0 g.setFont(new Font("Helvetica", Font.BOLD, 12));
3053  0 g.drawString(MessageManager.formatMessage("label.jaview_build_date",
3054    new String[]
3055    { builddate }), x, y += fh);
3056  0 g.setFont(new Font("Helvetica", Font.PLAIN, 12));
3057  0 g.drawString(MessageManager.getString("label.jalview_authors_1"), x,
3058    y += fh * 1.5);
3059  0 g.drawString(MessageManager.getString("label.jalview_authors_2"),
3060    x + 50, y += fh + 8);
3061  0 g.drawString(MessageManager.getString("label.jalview_dev_managers"),
3062    x, y += fh);
3063  0 g.drawString(MessageManager
3064    .getString("label.jalview_distribution_lists"), x, y += fh);
3065  0 g.drawString(MessageManager.getString("label.jalview_please_cite"),
3066    x, y += fh + 8);
3067  0 g.drawString(
3068    MessageManager.getString("label.jalview_cite_1_authors"), x,
3069    y += fh);
3070  0 g.drawString(MessageManager.getString("label.jalview_cite_1_title"),
3071    x, y += fh);
3072  0 g.drawString(MessageManager.getString("label.jalview_cite_1_ref"),
3073    x, y += fh);
3074    }
3075    }
3076   
3077  0 Frame frame = new Frame();
3078  0 frame.add(new AboutPanel(JalviewLite.getVersion(),
3079    JalviewLite.getBuildDate()));
3080  0 jalview.bin.JalviewLite.addFrame(frame,
3081    MessageManager.getString("label.jalview"), 580, 220);
3082   
3083    }
3084   
 
3085  0 toggle public void showURL(String url, String target)
3086    {
3087  0 if (viewport.applet == null)
3088    {
3089  0 jalview.bin.Console
3090    .outPrintln("Not running as applet - no browser available.");
3091    }
3092    else
3093    {
3094  0 viewport.applet.showURL(url, target);
3095    }
3096    }
3097   
3098    // ////////////////////////////////////////////////////////////////////////////////
3099    // JBuilder Graphics here
3100   
3101    MenuBar alignFrameMenuBar = new MenuBar();
3102   
3103    Menu fileMenu = new Menu(MessageManager.getString("action.file"));
3104   
3105    MenuItem loadApplication = new MenuItem(
3106    MessageManager.getString("label.view_full_application"));
3107   
3108    MenuItem loadTree = new MenuItem(
3109    MessageManager.getString("label.load_associated_tree"));
3110   
3111    MenuItem loadAnnotations = new MenuItem(
3112    MessageManager.getString("label.load_features_annotations"));
3113   
3114    MenuItem outputFeatures = new MenuItem(
3115    MessageManager.getString("label.export_features"));
3116   
3117    MenuItem outputAnnotations = new MenuItem(
3118    MessageManager.getString("label.export_annotations"));
3119   
3120    MenuItem closeMenuItem = new MenuItem(
3121    MessageManager.getString("action.close"));
3122   
3123    MenuItem selectAllSequenceMenuItem = new MenuItem(
3124    MessageManager.getString("action.select_all"));
3125   
3126    MenuItem deselectAllSequenceMenuItem = new MenuItem(
3127    MessageManager.getString("action.deselect_all"));
3128   
3129    MenuItem invertSequenceMenuItem = new MenuItem(
3130    MessageManager.getString("action.invert_selection"));
3131   
3132    MenuItem remove2LeftMenuItem = new MenuItem();
3133   
3134    MenuItem remove2RightMenuItem = new MenuItem();
3135   
3136    MenuItem removeGappedColumnMenuItem = new MenuItem();
3137   
3138    MenuItem removeAllGapsMenuItem = new MenuItem();
3139   
3140    CheckboxMenuItem viewBoxesMenuItem = new CheckboxMenuItem();
3141   
3142    CheckboxMenuItem viewTextMenuItem = new CheckboxMenuItem();
3143   
3144    MenuItem sortPairwiseMenuItem = new MenuItem();
3145   
3146    MenuItem sortIDMenuItem = new MenuItem();
3147   
3148    MenuItem sortLengthMenuItem = new MenuItem();
3149   
3150    MenuItem sortGroupMenuItem = new MenuItem();
3151   
3152    MenuItem sortEValueMenuItem = new MenuItem();
3153   
3154    MenuItem sortBitScoreMenuItem = new MenuItem();
3155   
3156    MenuItem removeRedundancyMenuItem = new MenuItem();
3157   
3158    MenuItem pairwiseAlignmentMenuItem = new MenuItem();
3159   
3160    MenuItem PCAMenuItem = new MenuItem();
3161   
3162    MenuItem averageDistanceTreeMenuItem = new MenuItem();
3163   
3164    MenuItem neighbourTreeMenuItem = new MenuItem();
3165   
3166    BorderLayout borderLayout1 = new BorderLayout();
3167   
3168    public Label statusBar = new Label();
3169   
3170    MenuItem clustalColour = new MenuItem();
3171   
3172    MenuItem zappoColour = new MenuItem();
3173   
3174    MenuItem taylorColour = new MenuItem();
3175   
3176    MenuItem hydrophobicityColour = new MenuItem();
3177   
3178    MenuItem helixColour = new MenuItem();
3179   
3180    MenuItem strandColour = new MenuItem();
3181   
3182    MenuItem turnColour = new MenuItem();
3183   
3184    MenuItem buriedColour = new MenuItem();
3185   
3186    MenuItem purinePyrimidineColour = new MenuItem();
3187   
3188    // MenuItem RNAInteractionColour = new MenuItem();
3189   
3190    MenuItem RNAHelixColour = new MenuItem();
3191   
3192    MenuItem userDefinedColour = new MenuItem();
3193   
3194    MenuItem PIDColour = new MenuItem();
3195   
3196    MenuItem BLOSUM62Colour = new MenuItem();
3197   
3198    MenuItem tcoffeeColour = new MenuItem();
3199   
3200    MenuItem njTreeBlosumMenuItem = new MenuItem();
3201   
3202    MenuItem avDistanceTreeBlosumMenuItem = new MenuItem();
3203   
3204    CheckboxMenuItem annotationPanelMenuItem = new CheckboxMenuItem();
3205   
3206    CheckboxMenuItem colourTextMenuItem = new CheckboxMenuItem();
3207   
3208    CheckboxMenuItem displayNonconservedMenuItem = new CheckboxMenuItem();
3209   
3210    MenuItem alProperties = new MenuItem(
3211    MessageManager.getString("label.alignment_props"));
3212   
3213    MenuItem overviewMenuItem = new MenuItem();
3214   
3215    MenuItem undoMenuItem = new MenuItem();
3216   
3217    MenuItem redoMenuItem = new MenuItem();
3218   
3219    CheckboxMenuItem conservationMenuItem = new CheckboxMenuItem();
3220   
3221    MenuItem noColourmenuItem = new MenuItem();
3222   
3223    CheckboxMenuItem wrapMenuItem = new CheckboxMenuItem();
3224   
3225    CheckboxMenuItem renderGapsMenuItem = new CheckboxMenuItem();
3226   
3227    MenuItem findMenuItem = new MenuItem();
3228   
3229    CheckboxMenuItem abovePIDThreshold = new CheckboxMenuItem();
3230   
3231    MenuItem nucleotideColour = new MenuItem();
3232   
3233    MenuItem deleteGroups = new MenuItem();
3234   
3235    MenuItem grpsFromSelection = new MenuItem();
3236   
3237    MenuItem createGroup = new MenuItem();
3238   
3239    MenuItem unGroup = new MenuItem();
3240   
3241    MenuItem delete = new MenuItem();
3242   
3243    MenuItem copy = new MenuItem();
3244   
3245    MenuItem cut = new MenuItem();
3246   
3247    Menu pasteMenu = new Menu();
3248   
3249    MenuItem pasteNew = new MenuItem();
3250   
3251    MenuItem pasteThis = new MenuItem();
3252   
3253    CheckboxMenuItem applyToAllGroups = new CheckboxMenuItem();
3254   
3255    MenuItem font = new MenuItem();
3256   
3257    CheckboxMenuItem scaleAbove = new CheckboxMenuItem();
3258   
3259    CheckboxMenuItem scaleLeft = new CheckboxMenuItem();
3260   
3261    CheckboxMenuItem scaleRight = new CheckboxMenuItem();
3262   
3263    MenuItem modifyPID = new MenuItem();
3264   
3265    MenuItem modifyConservation = new MenuItem();
3266   
3267    CheckboxMenuItem autoCalculate = null;
3268   
3269    CheckboxMenuItem sortByTree = new CheckboxMenuItem(
3270    "Sort Alignment With New Tree", true);
3271   
3272    Menu sortByTreeMenu = new Menu();
3273   
3274    MenuItem inputText = new MenuItem();
3275   
3276    MenuItem documentation = new MenuItem();
3277   
3278    MenuItem about = new MenuItem();
3279   
3280    CheckboxMenuItem seqLimits = new CheckboxMenuItem();
3281   
3282    CheckboxMenuItem centreColumnLabelFlag = new CheckboxMenuItem();
3283   
3284    CheckboxMenuItem followMouseOverFlag = new CheckboxMenuItem();
3285   
3286    CheckboxMenuItem showSequenceLogo = new CheckboxMenuItem();
3287   
3288    CheckboxMenuItem applyAutoAnnotationSettings = new CheckboxMenuItem();
3289   
3290    CheckboxMenuItem showConsensusHistogram = new CheckboxMenuItem();
3291   
3292    CheckboxMenuItem showGroupConsensus = new CheckboxMenuItem();
3293   
3294    CheckboxMenuItem showGroupConservation = new CheckboxMenuItem();
3295   
3296    CheckboxMenuItem normSequenceLogo = new CheckboxMenuItem();
3297   
3298    /**
3299    * Initialise menus and other items
3300    *
3301    * @throws Exception
3302    */
 
3303  0 toggle private void jbInit() throws Exception
3304    {
3305  0 setMenuBar(alignFrameMenuBar);
3306   
3307    /*
3308    * Configure File menu items and actions
3309    */
3310  0 inputText
3311    .setLabel(MessageManager.getString("label.input_from_textbox"));
3312  0 inputText.addActionListener(this);
3313  0 Menu outputTextboxMenu = new Menu(
3314    MessageManager.getString("label.out_to_textbox"));
3315  0 for (String ff : FileFormats.getInstance().getWritableFormats(true))
3316    {
3317  0 MenuItem item = new MenuItem(ff);
3318   
3319  0 item.addActionListener(new java.awt.event.ActionListener()
3320    {
 
3321  0 toggle @Override
3322    public void actionPerformed(ActionEvent e)
3323    {
3324  0 outputText_actionPerformed(e);
3325    }
3326    });
3327   
3328  0 outputTextboxMenu.add(item);
3329    }
3330  0 closeMenuItem.addActionListener(this);
3331  0 loadApplication.addActionListener(this);
3332  0 loadTree.addActionListener(this);
3333  0 loadAnnotations.addActionListener(this);
3334  0 outputFeatures.addActionListener(this);
3335  0 outputAnnotations.addActionListener(this);
3336   
3337    /*
3338    * Configure Edit menu items and actions
3339    */
3340  0 undoMenuItem.setEnabled(false);
3341  0 undoMenuItem.setLabel(MessageManager.getString("action.undo"));
3342  0 undoMenuItem.addActionListener(this);
3343  0 redoMenuItem.setEnabled(false);
3344  0 redoMenuItem.setLabel(MessageManager.getString("action.redo"));
3345  0 redoMenuItem.addActionListener(this);
3346  0 copy.setLabel(MessageManager.getString("action.copy"));
3347  0 copy.addActionListener(this);
3348  0 cut.setLabel(MessageManager.getString("action.cut"));
3349  0 cut.addActionListener(this);
3350  0 delete.setLabel(MessageManager.getString("action.delete"));
3351  0 delete.addActionListener(this);
3352  0 pasteMenu.setLabel(MessageManager.getString("action.paste"));
3353  0 pasteNew.setLabel(MessageManager.getString("label.to_new_alignment"));
3354  0 pasteNew.addActionListener(this);
3355  0 pasteThis.setLabel(MessageManager.getString("label.to_this_alignment"));
3356  0 pasteThis.addActionListener(this);
3357  0 remove2LeftMenuItem
3358    .setLabel(MessageManager.getString("action.remove_left"));
3359  0 remove2LeftMenuItem.addActionListener(this);
3360  0 remove2RightMenuItem
3361    .setLabel(MessageManager.getString("action.remove_right"));
3362  0 remove2RightMenuItem.addActionListener(this);
3363  0 removeGappedColumnMenuItem.setLabel(
3364    MessageManager.getString("action.remove_empty_columns"));
3365  0 removeGappedColumnMenuItem.addActionListener(this);
3366  0 removeAllGapsMenuItem
3367    .setLabel(MessageManager.getString("action.remove_all_gaps"));
3368  0 removeAllGapsMenuItem.addActionListener(this);
3369  0 removeRedundancyMenuItem
3370    .setLabel(MessageManager.getString("action.remove_redundancy"));
3371  0 removeRedundancyMenuItem.addActionListener(this);
3372   
3373    /*
3374    * Configure Select menu items and actions
3375    */
3376  0 findMenuItem.setLabel(MessageManager.getString("action.find"));
3377  0 findMenuItem.addActionListener(this);
3378  0 selectAllSequenceMenuItem.addActionListener(this);
3379  0 deselectAllSequenceMenuItem.addActionListener(this);
3380  0 invertSequenceMenuItem.setLabel(
3381    MessageManager.getString("action.invert_sequence_selection"));
3382  0 invertSequenceMenuItem.addActionListener(this);
3383  0 invertColSel.setLabel(
3384    MessageManager.getString("action.invert_column_selection"));
3385  0 invertColSel.addActionListener(this);
3386  0 deleteGroups
3387    .setLabel(MessageManager.getString("action.undefine_groups"));
3388  0 deleteGroups.addActionListener(this);
3389  0 grpsFromSelection.setLabel(
3390    MessageManager.getString("action.make_groups_selection"));
3391  0 grpsFromSelection.addActionListener(this);
3392  0 createGroup.setLabel(MessageManager.getString("action.create_group"));
3393  0 createGroup.addActionListener(this);
3394  0 unGroup.setLabel(MessageManager.getString("action.remove_group"));
3395  0 unGroup.addActionListener(this);
3396   
3397  0 annotationColumnSelection.setLabel(
3398    MessageManager.getString("action.select_by_annotation"));
3399  0 annotationColumnSelection.addActionListener(this);
3400   
3401    /*
3402    * Configure View menu items and actions
3403    */
3404  0 newView.setLabel(MessageManager.getString("action.new_view"));
3405  0 newView.addActionListener(this);
3406  0 Menu showMenu = new Menu(MessageManager.getString("action.show"));
3407  0 showColumns.setLabel(MessageManager.getString("label.all_columns"));
3408  0 showSeqs.setLabel(MessageManager.getString("label.all_sequences"));
3409  0 Menu hideMenu = new Menu(MessageManager.getString("action.hide"));
3410  0 hideColumns
3411    .setLabel(MessageManager.getString("label.selected_columns"));
3412  0 hideSequences
3413    .setLabel(MessageManager.getString("label.selected_sequences"));
3414  0 hideAllButSelection.setLabel(
3415    MessageManager.getString("label.all_but_selected_region"));
3416  0 hideAllSelection
3417    .setLabel(MessageManager.getString("label.selected_region"));
3418  0 showAllHidden.setLabel(
3419    MessageManager.getString("label.all_sequences_columns"));
3420  0 showColumns.addActionListener(this);
3421  0 showSeqs.addActionListener(this);
3422  0 hideColumns.addActionListener(this);
3423  0 hideSequences.addActionListener(this);
3424  0 hideAllButSelection.addActionListener(this);
3425  0 hideAllSelection.addActionListener(this);
3426  0 showAllHidden.addActionListener(this);
3427  0 featureSettings
3428    .setLabel(MessageManager.getString("action.feature_settings"));
3429  0 featureSettings.addActionListener(this);
3430  0 sequenceFeatures.setLabel(
3431    MessageManager.getString("label.show_sequence_features"));
3432  0 sequenceFeatures.addItemListener(this);
3433  0 sequenceFeatures.setState(false);
3434  0 followMouseOverFlag.setLabel(
3435    MessageManager.getString("label.automatic_scrolling"));
3436  0 followMouseOverFlag.addItemListener(this);
3437  0 alProperties.addActionListener(this);
3438  0 overviewMenuItem
3439    .setLabel(MessageManager.getString("label.overview_window"));
3440  0 overviewMenuItem.addActionListener(this);
3441   
3442    /*
3443    * Configure Annotations menu items and actions
3444    */
3445  0 annotationPanelMenuItem
3446    .setLabel(MessageManager.getString("label.show_annotations"));
3447  0 annotationPanelMenuItem.addItemListener(this);
3448  0 showGroupConsensus
3449    .setLabel(MessageManager.getString("label.group_consensus"));
3450  0 showGroupConservation
3451    .setLabel(MessageManager.getString("label.group_conservation"));
3452  0 showConsensusHistogram.setLabel(
3453    MessageManager.getString("label.show_consensus_histogram"));
3454  0 showSequenceLogo.setLabel(
3455    MessageManager.getString("label.show_consensus_logo"));
3456  0 normSequenceLogo.setLabel(
3457    MessageManager.getString("label.norm_consensus_logo"));
3458  0 applyAutoAnnotationSettings
3459    .setLabel(MessageManager.getString("label.apply_all_groups"));
3460  0 applyAutoAnnotationSettings.setState(true);
3461  0 Menu autoAnnMenu = new Menu(
3462    MessageManager.getString("label.autocalculated_annotation"));
3463   
3464  0 Menu selectSS = new Menu(MessageManager
3465    .getString("label.select_secondary_structure_source"));
3466  0 showGroupConsensus.addItemListener(this);
3467  0 showGroupConservation.addItemListener(this);
3468  0 showConsensusHistogram.addItemListener(this);
3469  0 showSequenceLogo.addItemListener(this);
3470  0 normSequenceLogo.addItemListener(this);
3471  0 applyAutoAnnotationSettings.addItemListener(this);
3472  0 showAlignmentAnnotations = new CheckboxMenuItem(
3473    MessageManager.getString("label.show_all_al_annotations"));
3474  0 showSequenceAnnotations = new CheckboxMenuItem(
3475    MessageManager.getString("label.show_all_seq_annotations"));
3476  0 sortAnnBySequence = new CheckboxMenuItem(
3477    MessageManager.getString("label.sort_annotations_by_sequence"));
3478  0 sortAnnByLabel = new CheckboxMenuItem(
3479    MessageManager.getString("label.sort_annotations_by_label"));
3480  0 showAutoFirst = new CheckboxMenuItem(
3481    MessageManager.getString("label.show_first"));
3482  0 showAutoFirst.setState(false); // pending applet parameter
3483  0 setShowAutoCalculatedAbove(showAutoFirst.getState());
3484  0 showAutoLast = new CheckboxMenuItem(
3485    MessageManager.getString("label.show_last"));
3486  0 showAutoLast.setState(!showAutoFirst.getState());
3487  0 showAlignmentAnnotations.addItemListener(this);
3488  0 showSequenceAnnotations.addItemListener(this);
3489  0 sortAnnBySequence.addItemListener(this);
3490  0 sortAnnByLabel.addItemListener(this);
3491  0 showAutoFirst.addItemListener(this);
3492  0 showAutoLast.addItemListener(this);
3493   
3494    /*
3495    * Configure Format menu items and actions
3496    */
3497  0 font.setLabel(MessageManager.getString("action.font"));
3498  0 font.addActionListener(this);
3499  0 scaleAbove.setLabel(MessageManager.getString("action.scale_above"));
3500  0 scaleAbove.setState(true);
3501  0 scaleAbove.setEnabled(false);
3502  0 scaleAbove.addItemListener(this);
3503  0 scaleLeft.setEnabled(false);
3504  0 scaleLeft.setState(true);
3505  0 scaleLeft.setLabel(MessageManager.getString("action.scale_left"));
3506  0 scaleLeft.addItemListener(this);
3507  0 scaleRight.setEnabled(false);
3508  0 scaleRight.setState(true);
3509  0 scaleRight.setLabel(MessageManager.getString("action.scale_right"));
3510  0 scaleRight.addItemListener(this);
3511  0 viewBoxesMenuItem.setLabel(MessageManager.getString("action.boxes"));
3512  0 viewBoxesMenuItem.setState(true);
3513  0 viewBoxesMenuItem.addItemListener(this);
3514  0 viewTextMenuItem.setLabel(MessageManager.getString("action.text"));
3515  0 viewTextMenuItem.setState(true);
3516  0 viewTextMenuItem.addItemListener(this);
3517  0 colourTextMenuItem
3518    .setLabel(MessageManager.getString("label.colour_text"));
3519  0 colourTextMenuItem.addItemListener(this);
3520  0 displayNonconservedMenuItem
3521    .setLabel(MessageManager.getString("label.show_non_conserved"));
3522  0 displayNonconservedMenuItem.addItemListener(this);
3523  0 wrapMenuItem.setLabel(MessageManager.getString("action.wrap"));
3524  0 wrapMenuItem.addItemListener(this);
3525  0 renderGapsMenuItem
3526    .setLabel(MessageManager.getString("action.show_gaps"));
3527  0 renderGapsMenuItem.setState(true);
3528  0 renderGapsMenuItem.addItemListener(this);
3529  0 centreColumnLabelFlag.setLabel(
3530    MessageManager.getString("label.centre_column_labels"));
3531  0 centreColumnLabelFlag.addItemListener(this);
3532  0 seqLimits.setState(true);
3533  0 seqLimits.setLabel(
3534    MessageManager.getString("label.show_sequence_limits"));
3535  0 seqLimits.addItemListener(this);
3536   
3537    /*
3538    * Configure Colour menu items and actions
3539    */
3540  0 applyToAllGroups.setLabel(
3541    MessageManager.getString("label.apply_colour_to_all_groups"));
3542  0 applyToAllGroups.setState(true);
3543  0 applyToAllGroups.addItemListener(this);
3544  0 clustalColour.setLabel(
3545    MessageManager.getString("label.colourScheme_clustal"));
3546  0 clustalColour.addActionListener(this);
3547  0 zappoColour
3548    .setLabel(MessageManager.getString("label.colourScheme_zappo"));
3549  0 zappoColour.addActionListener(this);
3550  0 taylorColour.setLabel(
3551    MessageManager.getString("label.colourScheme_taylor"));
3552  0 taylorColour.addActionListener(this);
3553  0 hydrophobicityColour.setLabel(
3554    MessageManager.getString("label.colourScheme_hydrophobic"));
3555  0 hydrophobicityColour.addActionListener(this);
3556  0 helixColour.setLabel(
3557    MessageManager.getString("label.colourScheme_helixpropensity"));
3558  0 helixColour.addActionListener(this);
3559  0 strandColour.setLabel(MessageManager
3560    .getString("label.colourScheme_strandpropensity"));
3561  0 strandColour.addActionListener(this);
3562  0 turnColour.setLabel(
3563    MessageManager.getString("label.colourScheme_turnpropensity"));
3564  0 turnColour.addActionListener(this);
3565  0 buriedColour.setLabel(
3566    MessageManager.getString("label.colourScheme_buriedindex"));
3567  0 buriedColour.addActionListener(this);
3568  0 purinePyrimidineColour.setLabel(MessageManager
3569    .getString("label.colourScheme_purine/pyrimidine"));
3570  0 purinePyrimidineColour.addActionListener(this);
3571    // RNAInteractionColour.setLabel(MessageManager
3572    // .getString("label.rna_interaction"));
3573    // RNAInteractionColour.addActionListener(this);
3574  0 RNAHelixColour.setLabel(
3575    MessageManager.getString("label.colourScheme_rnahelices"));
3576  0 RNAHelixColour.addActionListener(this);
3577  0 userDefinedColour
3578    .setLabel(MessageManager.getString("action.user_defined"));
3579  0 userDefinedColour.addActionListener(this);
3580  0 PIDColour.setLabel(
3581    MessageManager.getString("label.colourScheme_%identity"));
3582  0 PIDColour.addActionListener(this);
3583  0 BLOSUM62Colour.setLabel(
3584    MessageManager.getString("label.colourScheme_blosum62"));
3585  0 BLOSUM62Colour.addActionListener(this);
3586  0 tcoffeeColour.setLabel(
3587    MessageManager.getString("label.colourScheme_t-coffeescores"));
3588    // it will be enabled only if a score file is provided
3589  0 tcoffeeColour.setEnabled(false);
3590  0 tcoffeeColour.addActionListener(this);
3591  0 conservationMenuItem
3592    .setLabel(MessageManager.getString("action.by_conservation"));
3593  0 conservationMenuItem.addItemListener(this);
3594  0 noColourmenuItem.setLabel(MessageManager.getString("label.none"));
3595  0 noColourmenuItem.addActionListener(this);
3596  0 abovePIDThreshold.setLabel(
3597    MessageManager.getString("label.above_identity_threshold"));
3598  0 abovePIDThreshold.addItemListener(this);
3599  0 nucleotideColour.setLabel(
3600    MessageManager.getString("label.colourScheme_nucleotide"));
3601  0 nucleotideColour.addActionListener(this);
3602  0 modifyPID.setLabel(
3603    MessageManager.getString("label.modify_identity_threshold"));
3604  0 modifyPID.setEnabled(abovePIDThreshold.getState());
3605  0 modifyPID.addActionListener(this);
3606  0 modifyConservation.setLabel(MessageManager
3607    .getString("label.modify_conservation_threshold"));
3608  0 modifyConservation.setEnabled(conservationMenuItem.getState());
3609  0 modifyConservation.addActionListener(this);
3610  0 annotationColour
3611    .setLabel(MessageManager.getString("action.by_annotation"));
3612  0 annotationColour.addActionListener(this);
3613   
3614    /*
3615    * Configure Calculate menu items and actions
3616    */
3617  0 sortPairwiseMenuItem
3618    .setLabel(MessageManager.getString("action.by_pairwise_id"));
3619  0 sortPairwiseMenuItem.addActionListener(this);
3620  0 sortIDMenuItem.setLabel(MessageManager.getString("action.by_id"));
3621  0 sortIDMenuItem.addActionListener(this);
3622  0 sortLengthMenuItem
3623    .setLabel(MessageManager.getString("action.by_length"));
3624  0 sortLengthMenuItem.addActionListener(this);
3625  0 sortGroupMenuItem.setLabel(MessageManager.getString("action.by_group"));
3626  0 sortGroupMenuItem.addActionListener(this);
3627  0 pairwiseAlignmentMenuItem.setLabel(
3628    MessageManager.getString("action.pairwise_alignment"));
3629  0 pairwiseAlignmentMenuItem.addActionListener(this);
3630  0 PCAMenuItem.setLabel(
3631    MessageManager.getString("label.principal_component_analysis"));
3632  0 PCAMenuItem.addActionListener(this);
3633  0 autoCalculate = new CheckboxMenuItem(
3634    MessageManager.getString("label.autocalculate_consensus"),
3635    true);
3636  0 averageDistanceTreeMenuItem.setLabel(
3637    MessageManager.getString("label.average_distance_identity"));
3638  0 averageDistanceTreeMenuItem.addActionListener(this);
3639  0 neighbourTreeMenuItem.setLabel(
3640    MessageManager.getString("label.neighbour_joining_identity"));
3641  0 neighbourTreeMenuItem.addActionListener(this);
3642  0 avDistanceTreeBlosumMenuItem.setLabel(
3643    MessageManager.getString("label.average_distance_blosum62"));
3644  0 avDistanceTreeBlosumMenuItem.addActionListener(this);
3645  0 njTreeBlosumMenuItem
3646    .setLabel(MessageManager.getString("label.neighbour_blosum62"));
3647  0 njTreeBlosumMenuItem.addActionListener(this);
3648  0 sortByTreeMenu
3649    .setLabel(MessageManager.getString("action.by_tree_order"));
3650  0 Menu sortMenu = new Menu(MessageManager.getString("action.sort"));
3651  0 Menu calculateTreeMenu = new Menu(
3652    MessageManager.getString("action.calculate_tree"));
3653  0 autoCalculate.addItemListener(this);
3654  0 sortByTree.addItemListener(this);
3655   
3656    /*
3657    * Configure Help menu items and actions
3658    */
3659  0 Menu helpMenu = new Menu(MessageManager.getString("action.help"));
3660  0 documentation.setLabel(MessageManager.getString("label.documentation"));
3661  0 documentation.addActionListener(this);
3662  0 about.setLabel(MessageManager.getString("label.about"));
3663  0 about.addActionListener(this);
3664   
3665    /*
3666    * Add top level menus to frame
3667    */
3668  0 alignFrameMenuBar.add(fileMenu);
3669  0 Menu editMenu = new Menu(MessageManager.getString("action.edit"));
3670  0 alignFrameMenuBar.add(editMenu);
3671  0 Menu selectMenu = new Menu(MessageManager.getString("action.select"));
3672  0 alignFrameMenuBar.add(selectMenu);
3673  0 Menu viewMenu = new Menu(MessageManager.getString("action.view"));
3674  0 alignFrameMenuBar.add(viewMenu);
3675  0 Menu annotationsMenu = new Menu(
3676    MessageManager.getString("action.annotations"));
3677  0 alignFrameMenuBar.add(annotationsMenu);
3678  0 Menu formatMenu = new Menu(MessageManager.getString("action.format"));
3679  0 alignFrameMenuBar.add(formatMenu);
3680  0 Menu colourMenu = new Menu(MessageManager.getString("action.colour"));
3681  0 alignFrameMenuBar.add(colourMenu);
3682  0 Menu calculateMenu = new Menu(
3683    MessageManager.getString("action.calculate"));
3684  0 alignFrameMenuBar.add(calculateMenu);
3685  0 alignFrameMenuBar.add(helpMenu);
3686   
3687    /*
3688    * File menu
3689    */
3690  0 fileMenu.add(inputText);
3691  0 fileMenu.add(loadTree);
3692  0 fileMenu.add(loadAnnotations);
3693  0 fileMenu.addSeparator();
3694  0 fileMenu.add(outputTextboxMenu);
3695  0 fileMenu.add(outputFeatures);
3696  0 fileMenu.add(outputAnnotations);
3697  0 if (jalviewServletURL != null)
3698    {
3699  0 fileMenu.add(loadApplication);
3700    }
3701  0 fileMenu.addSeparator();
3702  0 fileMenu.add(closeMenuItem);
3703   
3704    /*
3705    * Edit menu
3706    */
3707  0 editMenu.add(undoMenuItem);
3708  0 editMenu.add(redoMenuItem);
3709  0 editMenu.add(cut);
3710  0 editMenu.add(copy);
3711  0 pasteMenu.add(pasteNew);
3712  0 pasteMenu.add(pasteThis);
3713  0 editMenu.add(pasteMenu);
3714  0 editMenu.add(delete);
3715  0 editMenu.addSeparator();
3716  0 editMenu.add(remove2LeftMenuItem);
3717  0 editMenu.add(remove2RightMenuItem);
3718  0 editMenu.add(removeGappedColumnMenuItem);
3719  0 editMenu.add(removeAllGapsMenuItem);
3720  0 editMenu.add(removeRedundancyMenuItem);
3721   
3722    /*
3723    * Select menu
3724    */
3725  0 selectMenu.add(findMenuItem);
3726  0 selectMenu.addSeparator();
3727  0 selectMenu.add(selectAllSequenceMenuItem);
3728  0 selectMenu.add(deselectAllSequenceMenuItem);
3729  0 selectMenu.add(invertSequenceMenuItem);
3730  0 selectMenu.add(invertColSel);
3731  0 selectMenu.add(createGroup);
3732  0 selectMenu.add(unGroup);
3733  0 selectMenu.add(grpsFromSelection);
3734  0 selectMenu.add(deleteGroups);
3735  0 selectMenu.add(annotationColumnSelection);
3736   
3737    /*
3738    * View menu
3739    */
3740  0 viewMenu.add(newView);
3741  0 viewMenu.addSeparator();
3742  0 showMenu.add(showColumns);
3743  0 showMenu.add(showSeqs);
3744  0 showMenu.add(showAllHidden);
3745  0 viewMenu.add(showMenu);
3746  0 hideMenu.add(hideColumns);
3747  0 hideMenu.add(hideSequences);
3748  0 hideMenu.add(hideAllSelection);
3749  0 hideMenu.add(hideAllButSelection);
3750  0 viewMenu.add(hideMenu);
3751  0 viewMenu.addSeparator();
3752  0 viewMenu.add(followMouseOverFlag);
3753  0 viewMenu.addSeparator();
3754  0 viewMenu.add(sequenceFeatures);
3755  0 viewMenu.add(featureSettings);
3756  0 viewMenu.addSeparator();
3757  0 viewMenu.add(alProperties);
3758  0 viewMenu.addSeparator();
3759  0 viewMenu.add(overviewMenuItem);
3760   
3761    /*
3762    * Annotations menu
3763    */
3764  0 annotationsMenu.add(annotationPanelMenuItem);
3765  0 annotationsMenu.addSeparator();
3766  0 annotationsMenu.add(showAlignmentAnnotations);
3767  0 annotationsMenu.add(showSequenceAnnotations);
3768  0 annotationsMenu.add(sortAnnBySequence);
3769  0 annotationsMenu.add(sortAnnByLabel);
3770  0 annotationsMenu.addSeparator();
3771  0 autoAnnMenu.add(showAutoFirst);
3772  0 autoAnnMenu.add(showAutoLast);
3773  0 autoAnnMenu.addSeparator();
3774  0 autoAnnMenu.add(applyAutoAnnotationSettings);
3775  0 autoAnnMenu.add(showConsensusHistogram);
3776  0 autoAnnMenu.add(showSequenceLogo);
3777  0 autoAnnMenu.add(normSequenceLogo);
3778  0 autoAnnMenu.addSeparator();
3779  0 autoAnnMenu.add(showGroupConservation);
3780  0 autoAnnMenu.add(showGroupConsensus);
3781  0 annotationsMenu.add(autoAnnMenu);
3782   
3783    /*
3784    * Format menu
3785    */
3786  0 formatMenu.add(font);
3787  0 formatMenu.add(seqLimits);
3788  0 formatMenu.add(wrapMenuItem);
3789  0 formatMenu.add(scaleAbove);
3790  0 formatMenu.add(scaleLeft);
3791  0 formatMenu.add(scaleRight);
3792  0 formatMenu.add(viewBoxesMenuItem);
3793  0 formatMenu.add(viewTextMenuItem);
3794  0 formatMenu.add(colourTextMenuItem);
3795  0 formatMenu.add(displayNonconservedMenuItem);
3796  0 formatMenu.add(renderGapsMenuItem);
3797  0 formatMenu.add(centreColumnLabelFlag);
3798   
3799    /*
3800    * Colour menu
3801    */
3802  0 colourMenu.add(applyToAllGroups);
3803  0 colourMenu.addSeparator();
3804  0 colourMenu.add(noColourmenuItem);
3805  0 colourMenu.add(clustalColour);
3806  0 colourMenu.add(BLOSUM62Colour);
3807  0 colourMenu.add(PIDColour);
3808  0 colourMenu.add(zappoColour);
3809  0 colourMenu.add(taylorColour);
3810  0 colourMenu.add(hydrophobicityColour);
3811  0 colourMenu.add(helixColour);
3812  0 colourMenu.add(strandColour);
3813  0 colourMenu.add(turnColour);
3814  0 colourMenu.add(buriedColour);
3815  0 colourMenu.add(nucleotideColour);
3816  0 colourMenu.add(purinePyrimidineColour);
3817    // colourMenu.add(RNAInteractionColour);
3818  0 colourMenu.add(tcoffeeColour);
3819  0 colourMenu.add(userDefinedColour);
3820  0 colourMenu.addSeparator();
3821  0 colourMenu.add(conservationMenuItem);
3822  0 colourMenu.add(modifyConservation);
3823  0 colourMenu.add(abovePIDThreshold);
3824  0 colourMenu.add(modifyPID);
3825  0 colourMenu.add(annotationColour);
3826  0 colourMenu.add(RNAHelixColour);
3827   
3828    /*
3829    * Calculate menu
3830    */
3831  0 sortMenu.add(sortIDMenuItem);
3832  0 sortMenu.add(sortLengthMenuItem);
3833  0 sortMenu.add(sortByTreeMenu);
3834  0 sortMenu.add(sortGroupMenuItem);
3835  0 sortMenu.add(sortPairwiseMenuItem);
3836  0 calculateMenu.add(sortMenu);
3837  0 calculateTreeMenu.add(averageDistanceTreeMenuItem);
3838  0 calculateTreeMenu.add(neighbourTreeMenuItem);
3839  0 calculateTreeMenu.add(avDistanceTreeBlosumMenuItem);
3840  0 calculateTreeMenu.add(njTreeBlosumMenuItem);
3841  0 calculateMenu.add(calculateTreeMenu);
3842  0 calculateMenu.addSeparator();
3843  0 calculateMenu.add(pairwiseAlignmentMenuItem);
3844  0 calculateMenu.add(PCAMenuItem);
3845  0 calculateMenu.add(autoCalculate);
3846  0 calculateMenu.add(sortByTree);
3847   
3848    /*
3849    * Help menu
3850    */
3851  0 helpMenu.add(documentation);
3852  0 helpMenu.add(about);
3853   
3854    /*
3855    * Status bar
3856    */
3857  0 statusBar.setBackground(Color.white);
3858  0 statusBar.setFont(new java.awt.Font("Verdana", 0, 11));
3859  0 setStatus(MessageManager.getString("label.status_bar"));
3860  0 this.add(statusBar, BorderLayout.SOUTH);
3861    }
3862   
 
3863  0 toggle @Override
3864    public void setStatus(String string)
3865    {
3866  0 statusBar.setText(string);
3867    };
3868   
3869    MenuItem featureSettings = new MenuItem();
3870   
3871    CheckboxMenuItem sequenceFeatures = new CheckboxMenuItem();
3872   
3873    MenuItem annotationColour = new MenuItem();
3874   
3875    MenuItem annotationColumnSelection = new MenuItem();
3876   
3877    MenuItem invertColSel = new MenuItem();
3878   
3879    MenuItem showColumns = new MenuItem();
3880   
3881    MenuItem showSeqs = new MenuItem();
3882   
3883    MenuItem hideColumns = new MenuItem();
3884   
3885    MenuItem hideSequences = new MenuItem();
3886   
3887    MenuItem hideAllButSelection = new MenuItem();
3888   
3889    MenuItem hideAllSelection = new MenuItem();
3890   
3891    MenuItem showAllHidden = new MenuItem();
3892   
3893    MenuItem newView = new MenuItem();
3894   
3895    private CheckboxMenuItem showAlignmentAnnotations;
3896   
3897    private CheckboxMenuItem showSequenceAnnotations;
3898   
3899    private CheckboxMenuItem sortAnnBySequence;
3900   
3901    private CheckboxMenuItem sortAnnByLabel;
3902   
3903    private CheckboxMenuItem showAutoFirst;
3904   
3905    private CheckboxMenuItem showAutoLast;
3906   
3907    private SplitFrame splitFrame;
3908   
3909    /**
3910    * Attach the alignFrame panels after embedding menus, if necessary. This used
3911    * to be called setEmbedded, but is now creates the dropdown menus in a
3912    * platform independent manner to avoid OSX/Mac menu appendage daftness.
3913    *
3914    * @param reallyEmbedded
3915    * true to attach the view to the applet area on the page rather than
3916    * in a new window
3917    */
 
3918  0 toggle public void createAlignFrameWindow(boolean reallyEmbedded)
3919    {
3920  0 if (reallyEmbedded)
3921    {
3922  0 embedAlignFrameInApplet(viewport.applet);
3923    }
3924    else
3925    {
3926    // //////
3927    // test and embed menu bar if necessary.
3928    //
3929  0 if (embedMenuIfNeeded(alignPanel))
3930    {
3931    /*
3932    * adjust for status bar height too. ? pointless as overridden by layout
3933    * manager
3934    */
3935  0 alignPanel.setSize(getSize().width,
3936    getSize().height - statusBar.getHeight());
3937    }
3938  0 add(statusBar, BorderLayout.SOUTH);
3939  0 add(alignPanel, BorderLayout.CENTER);
3940    // and register with the applet so it can pass external API calls to us
3941  0 jalview.bin.JalviewLite.addFrame(this, this.getTitle(), frameWidth,
3942    frameHeight);
3943    }
3944    }
3945   
3946    /**
3947    * Add the components of this AlignFrame to the applet container.
3948    *
3949    * @param theApplet
3950    */
 
3951  0 toggle public void embedAlignFrameInApplet(final JalviewLite theApplet)
3952    {
3953    // ////
3954    // Explicitly build the embedded menu panel for the on-page applet
3955    //
3956    // view cannot be closed if its actually on the page
3957  0 fileMenu.remove(closeMenuItem);
3958  0 fileMenu.remove(3); // Remove Separator
3959    // construct embedded menu, using default font
3960  0 embeddedMenu = makeEmbeddedPopupMenu(alignFrameMenuBar, false, false);
3961    // and actually add the components to the applet area
3962  0 theApplet.setLayout(new BorderLayout());
3963  0 theApplet.add(embeddedMenu, BorderLayout.NORTH);
3964  0 theApplet.add(statusBar, BorderLayout.SOUTH);
3965    // TODO should size be left to the layout manager?
3966  0 alignPanel.setSize(theApplet.getSize().width, theApplet.getSize().height
3967    - embeddedMenu.getHeight() - statusBar.getHeight());
3968  0 theApplet.add(alignPanel, BorderLayout.CENTER);
3969  0 final AlignFrame me = this;
3970  0 theApplet.addFocusListener(new FocusListener()
3971    {
3972   
 
3973  0 toggle @Override
3974    public void focusLost(FocusEvent e)
3975    {
3976  0 if (theApplet.currentAlignFrame == me)
3977    {
3978  0 theApplet.currentAlignFrame = null;
3979    }
3980    }
3981   
 
3982  0 toggle @Override
3983    public void focusGained(FocusEvent e)
3984    {
3985  0 theApplet.currentAlignFrame = me;
3986    }
3987    });
3988  0 theApplet.validate();
3989    }
3990   
3991    /**
3992    * create a new binding between structures in an existing jmol viewer instance
3993    * and an alignpanel with sequences that have existing PDBFile entries. Note,
3994    * this does not open a new Jmol window, or modify the display of the
3995    * structures in the original jmol window. Note This method doesn't work
3996    * without an additional javascript library to exchange messages between the
3997    * distinct applets. See http://issues.jalview.org/browse/JAL-621
3998    *
3999    * @param jmolViewer
4000    * JmolViewer instance
4001    * @param sequenceIds
4002    * - sequence Ids to search for associations
4003    */
 
4004  0 toggle public SequenceStructureBinding addStructureViewInstance(
4005    Object jmolviewer, String[] sequenceIds)
4006    {
4007  0 Viewer viewer = null;
4008  0 try
4009    {
4010  0 viewer = (Viewer) jmolviewer;
4011    } catch (ClassCastException ex)
4012    {
4013  0 jalview.bin.Console.errPrintln(
4014    "Unsupported viewer object :" + jmolviewer.getClass());
4015    }
4016  0 if (viewer == null)
4017    {
4018  0 jalview.bin.Console
4019    .errPrintln("Can't use this object as a structure viewer:"
4020    + jmolviewer.getClass());
4021  0 return null;
4022    }
4023  0 SequenceI[] seqs = null;
4024  0 if (sequenceIds == null || sequenceIds.length == 0)
4025    {
4026  0 seqs = viewport.getAlignment().getSequencesArray();
4027    }
4028    else
4029    {
4030  0 Vector sqi = new Vector();
4031  0 AlignmentI al = viewport.getAlignment();
4032  0 for (int sid = 0; sid < sequenceIds.length; sid++)
4033    {
4034  0 SequenceI sq = al.findName(sequenceIds[sid]);
4035  0 if (sq != null)
4036    {
4037  0 sqi.addElement(sq);
4038    }
4039    }
4040  0 if (sqi.size() > 0)
4041    {
4042  0 seqs = new SequenceI[sqi.size()];
4043  0 for (int sid = 0, sSize = sqi.size(); sid < sSize; sid++)
4044    {
4045  0 seqs[sid] = (SequenceI) sqi.elementAt(sid);
4046    }
4047    }
4048    else
4049    {
4050  0 return null;
4051    }
4052    }
4053  0 AAStructureBindingModel jmv = null;
4054    // TODO: search for a jmv that involves viewer
4055  0 if (jmv == null)
4056    { // create a new viewer/jalview binding.
4057  0 jmv = new ExtJmol(viewer, alignPanel, new SequenceI[][] { seqs });
4058    }
4059  0 return jmv;
4060   
4061    }
4062   
4063    /**
4064    * bind a pdb file to a sequence in the current view
4065    *
4066    * @param sequenceId
4067    * - sequenceId within the dataset.
4068    * @param pdbEntryString
4069    * - the short name for the PDB file
4070    * @param pdbFile
4071    * - pdb file - either a URL or a valid PDB file.
4072    * @return true if binding was as success TODO: consider making an exception
4073    * structure for indicating when PDB parsing or sequenceId location
4074    * fails.
4075    */
 
4076  0 toggle public boolean addPdbFile(String sequenceId, String pdbEntryString,
4077    String pdbFile)
4078    {
4079  0 SequenceI toaddpdb = viewport.getAlignment().findName(sequenceId);
4080  0 boolean needtoadd = false;
4081  0 if (toaddpdb != null)
4082    {
4083  0 Vector pdbe = toaddpdb.getAllPDBEntries();
4084  0 PDBEntry pdbentry = null;
4085  0 if (pdbe != null && pdbe.size() > 0)
4086    {
4087  0 for (int pe = 0, peSize = pdbe.size(); pe < peSize; pe++)
4088    {
4089  0 pdbentry = (PDBEntry) pdbe.elementAt(pe);
4090  0 if (!pdbentry.getId().equals(pdbEntryString)
4091    && !pdbentry.getFile().equals(pdbFile))
4092    {
4093  0 pdbentry = null;
4094    }
4095    else
4096    {
4097  0 continue;
4098    }
4099    }
4100    }
4101  0 if (pdbentry == null)
4102    {
4103  0 pdbentry = new PDBEntry();
4104  0 pdbentry.setId(pdbEntryString);
4105  0 pdbentry.setFile(pdbFile);
4106  0 needtoadd = true; // add this new entry to sequence.
4107    }
4108    // resolve data source
4109    // TODO: this code should be a refactored to an io package
4110  0 DataSourceType protocol = AppletFormatAdapter.resolveProtocol(pdbFile,
4111    FileFormat.PDB);
4112  0 if (protocol == null)
4113    {
4114  0 return false;
4115    }
4116  0 if (needtoadd)
4117    {
4118  0 pdbentry.setProtocol(protocol);
4119  0 toaddpdb.addPDBId(pdbentry);
4120  0 alignPanel.getStructureSelectionManager()
4121    .registerPDBEntry(pdbentry);
4122    }
4123    }
4124  0 return true;
4125    }
4126   
 
4127  0 toggle private Object[] cleanSeqChainArrays(SequenceI[] seqs, String[] chains)
4128    {
4129  0 if (seqs != null)
4130    {
4131  0 Vector sequences = new Vector();
4132  0 for (int i = 0; i < seqs.length; i++)
4133    {
4134  0 if (seqs[i] != null)
4135    {
4136  0 sequences
4137    .addElement(new Object[]
4138  0 { seqs[i], (chains != null) ? chains[i] : null });
4139    }
4140    }
4141  0 seqs = new SequenceI[sequences.size()];
4142  0 chains = new String[sequences.size()];
4143  0 for (int i = 0, isize = sequences.size(); i < isize; i++)
4144    {
4145  0 Object[] oj = (Object[]) sequences.elementAt(i);
4146   
4147  0 seqs[i] = (SequenceI) oj[0];
4148  0 chains[i] = (String) oj[1];
4149    }
4150    }
4151  0 return new Object[] { seqs, chains };
4152   
4153    }
4154   
 
4155  0 toggle public void newStructureView(JalviewLite applet, PDBEntry pdb,
4156    SequenceI[] seqs, String[] chains, DataSourceType protocol)
4157    {
4158    // Scrub any null sequences from the array
4159  0 Object[] sqch = cleanSeqChainArrays(seqs, chains);
4160  0 seqs = (SequenceI[]) sqch[0];
4161  0 chains = (String[]) sqch[1];
4162  0 if (seqs == null || seqs.length == 0)
4163    {
4164  0 jalview.bin.Console.errPrintln(
4165    "JalviewLite.AlignFrame:newStructureView: No sequence to bind structure to.");
4166    }
4167  0 if (protocol == null)
4168    {
4169  0 String sourceType = (String) pdb.getProperty("protocol");
4170  0 try
4171    {
4172  0 protocol = DataSourceType.valueOf(sourceType);
4173    } catch (IllegalArgumentException e)
4174    {
4175    // ignore
4176    }
4177  0 if (protocol == null)
4178    {
4179  0 jalview.bin.Console
4180    .errPrintln("Couldn't work out protocol to open structure: "
4181    + pdb.getId());
4182  0 return;
4183    }
4184    }
4185  0 if (applet.useXtrnalSviewer)
4186    {
4187    // register the association(s) and quit, don't create any windows.
4188  0 if (StructureSelectionManager.getStructureSelectionManager(applet)
4189    .setMapping(seqs, chains, pdb.getFile(), protocol,
4190    null) == null)
4191    {
4192  0 jalview.bin.Console.errPrintln("Failed to map " + pdb.getFile()
4193    + " (" + protocol + ") to any sequences");
4194    }
4195  0 return;
4196    }
4197  0 if (applet.isAlignPdbStructures() && applet.jmolAvailable)
4198    {
4199    // can only do alignments with Jmol
4200    // find the last jmol window assigned to this alignment
4201  0 AppletJmol ajm = null, tajm;
4202  0 Vector jmols = applet.getAppletWindow(AppletJmol.class);
4203  0 for (int i = 0, iSize = jmols.size(); i < iSize; i++)
4204    {
4205  0 tajm = (AppletJmol) jmols.elementAt(i);
4206  0 if (tajm.ap.alignFrame == this)
4207    {
4208  0 ajm = tajm;
4209  0 break;
4210    }
4211    }
4212  0 if (ajm != null)
4213    {
4214  0 jalview.bin.Console.errPrintln(
4215    "Incremental adding and aligning structure to existing Jmol view not yet implemented.");
4216    // try and add the pdb structure
4217    // ajm.addS
4218  0 ajm = null;
4219    }
4220    }
4221    // otherwise, create a new window
4222  0 if (applet.jmolAvailable)
4223    {
4224  0 new AppletJmol(pdb, seqs, chains, alignPanel, protocol);
4225  0 applet.lastFrameX += 40;
4226  0 applet.lastFrameY += 40;
4227    }
4228    else
4229    {
4230  0 new mc_view.AppletPDBViewer(pdb, seqs, chains, alignPanel, protocol);
4231    }
4232   
4233    }
4234   
 
4235  0 toggle public void alignedStructureView(JalviewLite applet, PDBEntry[] pdb,
4236    SequenceI[][] seqs, String[][] chains, String[] protocols)
4237    {
4238    // TODO Auto-generated method stub
4239  0 jalview.bin.Console
4240    .errPrintln("Aligned Structure View: Not yet implemented.");
4241    }
4242   
4243    /**
4244    * modify the current selection, providing the user has not made a selection
4245    * already.
4246    *
4247    * @param sel
4248    * - sequences from this alignment
4249    * @param csel
4250    * - columns to be selected on the alignment
4251    */
 
4252  0 toggle public void select(SequenceGroup sel, ColumnSelection csel,
4253    HiddenColumns hidden)
4254    {
4255  0 alignPanel.seqPanel.selection(sel, csel, hidden, null);
4256    }
4257   
 
4258  0 toggle public void scrollTo(int row, int column)
4259    {
4260  0 alignPanel.seqPanel.scrollTo(row, column);
4261    }
4262   
 
4263  0 toggle public void scrollToRow(int row)
4264    {
4265  0 alignPanel.seqPanel.scrollToRow(row);
4266    }
4267   
 
4268  0 toggle public void scrollToColumn(int column)
4269    {
4270  0 alignPanel.seqPanel.scrollToColumn(column);
4271    }
4272   
4273    /**
4274    * @return the alignments unique ID.
4275    */
 
4276  0 toggle public String getSequenceSetId()
4277    {
4278  0 return viewport.getSequenceSetId();
4279    }
4280   
4281    /**
4282    * Load the (T-Coffee) score file from the specified url
4283    *
4284    * @param source
4285    * File/URL/T-COFFEE score file contents
4286    * @throws IOException
4287    * @return true if alignment was annotated with data from source
4288    */
 
4289  0 toggle public boolean loadScoreFile(String source) throws IOException
4290    {
4291   
4292  0 TCoffeeScoreFile file = new TCoffeeScoreFile(source,
4293    AppletFormatAdapter.checkProtocol(source));
4294  0 if (!file.isValid())
4295    {
4296    // TODO: raise dialog for gui
4297  0 jalview.bin.Console.errPrintln("Problems parsing T-Coffee scores: "
4298    + file.getWarningMessage());
4299  0 jalview.bin.Console.errPrintln("Origin was:\n" + source);
4300  0 return false;
4301    }
4302   
4303    /*
4304    * check that the score matrix matches the alignment dimensions
4305    */
4306  0 AlignmentI aln;
4307  0 if ((aln = viewport.getAlignment()) != null
4308    && (aln.getHeight() != file.getHeight()
4309    || aln.getWidth() != file.getWidth()))
4310    {
4311    // TODO: raise a dialog box here rather than bomb out.
4312  0 jalview.bin.Console.errPrintln(
4313    "The scores matrix does not match the alignment dimensions");
4314   
4315    }
4316   
4317    // TODO add parameter to indicate if matching should be done
4318  0 if (file.annotateAlignment(alignPanel.getAlignment(), false))
4319    {
4320  0 alignPanel.fontChanged();
4321  0 tcoffeeColour.setEnabled(true);
4322    // switch to this color
4323  0 changeColour(new TCoffeeColourScheme(alignPanel.getAlignment()));
4324  0 return true;
4325    }
4326    else
4327    {
4328  0 jalview.bin.Console.errPrintln("Problems resolving T-Coffee scores:");
4329  0 if (file.getWarningMessage() != null)
4330    {
4331  0 jalview.bin.Console.errPrintln(file.getWarningMessage());
4332    }
4333    }
4334  0 return false;
4335    }
4336   
 
4337  0 toggle public SplitFrame getSplitFrame()
4338    {
4339  0 return this.splitFrame;
4340    }
4341   
 
4342  0 toggle public void setSplitFrame(SplitFrame sf)
4343    {
4344  0 this.splitFrame = sf;
4345    }
4346   
4347    // may not need this
 
4348  0 toggle @Override
4349    public void setShowSeqFeatures(boolean b)
4350    {
4351    // showSeqFeatures.setSelected(b);
4352  0 viewport.setShowSequenceFeatures(b);
4353   
4354    }
4355   
 
4356  0 toggle @Override
4357    public void setMenusForViewport()
4358    {
4359    // setMenusFromViewport(viewport);
4360   
4361    }
4362   
 
4363  0 toggle @Override
4364    public void refreshFeatureUI(boolean enableIfNecessary)
4365    {
4366  0 if (enableIfNecessary)
4367    {
4368  0 sequenceFeatures.setState(true);
4369  0 alignPanel.av.setShowSequenceFeatures(true);
4370    }
4371    }
4372   
 
4373  0 toggle @Override
4374    public FeatureSettingsControllerI getFeatureSettingsUI()
4375    {
4376  0 return alignPanel.av.featureSettings;
4377    }
4378   
 
4379  0 toggle @Override
4380    public FeatureSettingsControllerI showFeatureSettingsUI()
4381    {
4382  0 return new FeatureSettings(alignPanel);
4383    }
4384   
4385    private Rectangle fs_bounds = null;
4386   
 
4387  0 toggle @Override
4388    public void setFeatureSettingsGeometry(Rectangle bounds)
4389    {
4390  0 fs_bounds = bounds;
4391    }
4392   
 
4393  0 toggle @Override
4394    public Rectangle getFeatureSettingsGeometry()
4395    {
4396  0 return fs_bounds;
4397    }
4398   
4399    }
  • Report generated by OpenClover v 4.4.1 on Thu Dec 4 2025 14:53:28 GMT using coverage data from Thu Dec 4 2025 14:53:14 GMT.
  • OpenClover is free and open-source software.