label.about = About...
label.show_sequence_limits = Show Sequence Limits
label.feature_settings = Feature Settings...
-label.sequence_features = Sequence Features
label.all_columns = All Columns
label.all_sequences = All Sequences
label.selected_columns = Selected Columns
label.description = Description
label.include_description= Include Description
label.start_jalview = Start Jalview
+label.biojs_html_export = BioJS
*/
package jalview.analysis;
-import jalview.datamodel.AlignedCodon;
-import jalview.datamodel.AlignedCodonFrame;
-import jalview.datamodel.AlignmentAnnotation;
-import jalview.datamodel.AlignmentI;
-import jalview.datamodel.Mapping;
-import jalview.datamodel.SearchResults;
-import jalview.datamodel.Sequence;
-import jalview.datamodel.SequenceI;
-import jalview.schemes.ResidueProperties;
-import jalview.util.MapList;
-
import java.util.ArrayList;
import java.util.Arrays;
+import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeMap;
+import jalview.datamodel.AlignedCodon;
+import jalview.datamodel.AlignedCodonFrame;
+import jalview.datamodel.AlignmentAnnotation;
+import jalview.datamodel.AlignmentI;
+import jalview.datamodel.Mapping;
+import jalview.datamodel.SearchResults;
+import jalview.datamodel.Sequence;
+import jalview.datamodel.SequenceGroup;
+import jalview.datamodel.SequenceI;
+import jalview.schemes.ResidueProperties;
+import jalview.util.MapList;
+
/**
* grab bag of useful alignment manipulation operations Expect these to be
* refactored elsewhere at some point.
*/
return mapProteinToCdna(proteinDs, dnaDs) != null;
}
+
+ /**
+ * Finds any reference annotations associated with the sequences in
+ * sequenceScope, that are not already added to the alignment, and adds them
+ * to the 'candidates' map. Also populates a lookup table of annotation
+ * labels, keyed by calcId, for use in constructing tooltips or the like.
+ *
+ * @param sequenceScope
+ * the sequences to scan for reference annotations
+ * @param labelForCalcId
+ * (optional) map to populate with label for calcId
+ * @param candidates
+ * map to populate with annotations for sequence
+ * @param al
+ * the alignment to check for presence of annotations
+ */
+ public static void findAddableReferenceAnnotations(
+ List<SequenceI> sequenceScope, Map<String, String> labelForCalcId,
+ final Map<SequenceI, List<AlignmentAnnotation>> candidates,
+ AlignmentI al)
+ {
+ if (sequenceScope == null)
+ {
+ return;
+ }
+
+ /*
+ * For each sequence in scope, make a list of any annotations on the
+ * underlying dataset sequence which are not already on the alignment.
+ *
+ * Add to a map of { alignmentSequence, <List of annotations to add> }
+ */
+ for (SequenceI seq : sequenceScope)
+ {
+ SequenceI dataset = seq.getDatasetSequence();
+ if (dataset == null)
+ {
+ continue;
+ }
+ AlignmentAnnotation[] datasetAnnotations = dataset.getAnnotation();
+ if (datasetAnnotations == null)
+ {
+ continue;
+ }
+ final List<AlignmentAnnotation> result = new ArrayList<AlignmentAnnotation>();
+ for (AlignmentAnnotation dsann : datasetAnnotations)
+ {
+ /*
+ * Find matching annotations on the alignment. If none is found, then
+ * add this annotation to the list of 'addable' annotations for this
+ * sequence.
+ */
+ final Iterable<AlignmentAnnotation> matchedAlignmentAnnotations = al
+ .findAnnotations(seq, dsann.getCalcId(),
+ dsann.label);
+ if (!matchedAlignmentAnnotations.iterator().hasNext())
+ {
+ result.add(dsann);
+ if (labelForCalcId != null)
+ {
+ labelForCalcId.put(dsann.getCalcId(), dsann.label);
+ }
+ }
+ }
+ /*
+ * Save any addable annotations for this sequence
+ */
+ if (!result.isEmpty())
+ {
+ candidates.put(seq, result);
+ }
+ }
+ }
+
+ /**
+ * Adds annotations to the top of the alignment annotations, in the same order
+ * as their related sequences.
+ *
+ * @param annotations
+ * the annotations to add
+ * @param alignment
+ * the alignment to add them to
+ * @param selectionGroup
+ * current selection group (or null if none)
+ */
+ public static void addReferenceAnnotations(
+ Map<SequenceI, List<AlignmentAnnotation>> annotations,
+ final AlignmentI alignment, final SequenceGroup selectionGroup)
+ {
+ for (SequenceI seq : annotations.keySet())
+ {
+ for (AlignmentAnnotation ann : annotations.get(seq))
+ {
+ AlignmentAnnotation copyAnn = new AlignmentAnnotation(ann);
+ int startRes = 0;
+ int endRes = ann.annotations.length;
+ if (selectionGroup != null)
+ {
+ startRes = selectionGroup.getStartRes();
+ endRes = selectionGroup.getEndRes();
+ }
+ copyAnn.restrict(startRes, endRes);
+
+ /*
+ * Add to the sequence (sets copyAnn.datasetSequence), unless the
+ * original annotation is already on the sequence.
+ */
+ if (!seq.hasAnnotation(ann))
+ {
+ seq.addAlignmentAnnotation(copyAnn);
+ }
+ // adjust for gaps
+ copyAnn.adjustForAlignment();
+ // add to the alignment and set visible
+ alignment.addAnnotation(copyAnn);
+ copyAnn.visible = true;
+ }
+ }
+ }
+
+ /**
+ * Set visibility of alignment annotations of specified types (labels), for
+ * specified sequences. This supports controls like
+ * "Show all secondary structure", "Hide all Temp factor", etc.
+ *
+ * @al the alignment to scan for annotations
+ * @param types
+ * the types (labels) of annotations to be updated
+ * @param forSequences
+ * if not null, only annotations linked to one of these sequences are
+ * in scope for update; if null, acts on all sequence annotations
+ * @param anyType
+ * if this flag is true, 'types' is ignored (label not checked)
+ * @param doShow
+ * if true, set visibility on, else set off
+ */
+ public static void showOrHideSequenceAnnotations(AlignmentI al,
+ Collection<String> types, List<SequenceI> forSequences,
+ boolean anyType, boolean doShow)
+ {
+ for (AlignmentAnnotation aa : al
+ .getAlignmentAnnotation())
+ {
+ if (anyType || types.contains(aa.label))
+ {
+ if ((aa.sequenceRef != null)
+ && (forSequences == null || forSequences
+ .contains(aa.sequenceRef)))
+ {
+ aa.visible = doShow;
+ }
+ }
+ }
+ }
}
*/
package jalview.appletgui;
+import java.awt.CheckboxMenuItem;
+import java.awt.Frame;
+import java.awt.Menu;
+import java.awt.MenuItem;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.ItemEvent;
+import java.awt.event.ItemListener;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+import java.util.Vector;
+
import jalview.analysis.AAFrequency;
+import jalview.analysis.AlignmentAnnotationUtils;
+import jalview.analysis.AlignmentUtils;
import jalview.analysis.Conservation;
import jalview.commands.ChangeCaseCommand;
import jalview.commands.EditCommand;
import jalview.commands.EditCommand.Action;
+import jalview.datamodel.AlignmentAnnotation;
+import jalview.datamodel.AlignmentI;
import jalview.datamodel.DBRefEntry;
import jalview.datamodel.PDBEntry;
-import jalview.datamodel.Sequence;
import jalview.datamodel.SequenceFeature;
import jalview.datamodel.SequenceGroup;
import jalview.datamodel.SequenceI;
import jalview.util.MessageManager;
import jalview.util.UrlLink;
-import java.awt.CheckboxMenuItem;
-import java.awt.Frame;
-import java.awt.Menu;
-import java.awt.MenuItem;
-import java.awt.event.ActionEvent;
-import java.awt.event.ActionListener;
-import java.awt.event.ItemEvent;
-import java.awt.event.ItemListener;
-import java.util.List;
-import java.util.Vector;
-
public class APopupMenu extends java.awt.PopupMenu implements
ActionListener, ItemListener
{
+ private static final String ALL_ANNOTATIONS = "All";
+
Menu groupMenu = new Menu();
MenuItem editGroupName = new MenuItem();
CheckboxMenuItem displayNonconserved = new CheckboxMenuItem();
+ Menu seqShowAnnotationsMenu = new Menu(
+ MessageManager.getString("label.show_annotations"));
+
+ Menu seqHideAnnotationsMenu = new Menu(
+ MessageManager.getString("label.hide_annotations"));
+
+ MenuItem seqAddReferenceAnnotations = new MenuItem(
+ MessageManager.getString("label.add_reference_annotations"));
+
+ Menu groupShowAnnotationsMenu = new Menu(
+ MessageManager.getString("label.show_annotations"));
+
+ Menu groupHideAnnotationsMenu = new Menu(
+ MessageManager.getString("label.hide_annotations"));
+
+ MenuItem groupAddReferenceAnnotations = new MenuItem(
+ MessageManager.getString("label.add_reference_annotations"));
+
Menu editMenu = new Menu(MessageManager.getString("action.edit"));
MenuItem copy = new MenuItem(MessageManager.getString("action.copy"));
MenuItem makeReferenceSeq = new MenuItem();
- Sequence seq;
+ SequenceI seq;
MenuItem revealAll = new MenuItem();
Menu menu1 = new Menu();
- public APopupMenu(AlignmentPanel apanel, final Sequence seq, Vector links)
+ public APopupMenu(AlignmentPanel apanel, final SequenceI seq,
+ Vector<String> links)
{
// /////////////////////////////////////////////////////////
// If this is activated from the sequence panel, the user may want to
outputmenu.add(item);
}
- SequenceGroup sg = ap.av.getSelectionGroup();
+ buildAnnotationSubmenus();
+ SequenceGroup sg = ap.av.getSelectionGroup();
if (sg != null && sg.getSize() > 0)
{
editGroupName.setLabel(MessageManager.formatMessage(
- "label.name_param", new String[]
+ "label.name_param", new Object[]
{ sg.getName() }));
showText.setState(sg.getDisplayText());
showColourText.setState(sg.getColourText());
if (links != null && links.size() > 0)
{
Menu linkMenu = new Menu(MessageManager.getString("action.link"));
- String link;
for (int i = 0; i < links.size(); i++)
{
- link = links.elementAt(i).toString();
+ String link = links.elementAt(i);
UrlLink urlLink = new UrlLink(link);
if (!urlLink.isValid())
{
.getString("action.set_as_reference")); // );
}
repGroup.setLabel(MessageManager.formatMessage(
- "label.represent_group_with", new String[]
+ "label.represent_group_with", new Object[]
{ seq.getName() }));
}
else
}
/**
+ * Build menus for annotation types that may be shown or hidden, and for
+ * 'reference annotations' that may be added to the alignment.
+ */
+ private void buildAnnotationSubmenus()
+ {
+ /*
+ * First for the currently selected sequence (if there is one):
+ */
+ final List<SequenceI> selectedSequence = (seq == null ? Collections
+ .<SequenceI> emptyList() : Arrays.asList(seq));
+ buildAnnotationTypesMenus(seqShowAnnotationsMenu,
+ seqHideAnnotationsMenu, selectedSequence);
+ configureReferenceAnnotationsMenu(seqAddReferenceAnnotations,
+ selectedSequence);
+
+ /*
+ * and repeat for the current selection group (if there is one):
+ */
+ final List<SequenceI> selectedGroup = (ap.av.getSelectionGroup() == null ? Collections
+ .<SequenceI> emptyList() : ap.av.getSelectionGroup()
+ .getSequences());
+ buildAnnotationTypesMenus(groupShowAnnotationsMenu,
+ groupHideAnnotationsMenu, selectedGroup);
+ configureReferenceAnnotationsMenu(groupAddReferenceAnnotations,
+ selectedGroup);
+ }
+
+ /**
+ * Determine whether or not to enable 'add reference annotations' menu item.
+ * It is enable if there are any annotations, on any of the selected
+ * sequences, which are not yet on the alignment (visible or not).
+ *
+ * @param menu
+ * @param forSequences
+ */
+ private void configureReferenceAnnotationsMenu(MenuItem menuItem,
+ List<SequenceI> forSequences)
+ {
+ menuItem.setEnabled(false);
+
+ /*
+ * Temporary store to hold distinct calcId / type pairs for the tooltip.
+ * Using TreeMap means calcIds are shown in alphabetical order.
+ */
+ Map<String, String> tipEntries = new TreeMap<String, String>();
+ final Map<SequenceI, List<AlignmentAnnotation>> candidates = new LinkedHashMap<SequenceI, List<AlignmentAnnotation>>();
+ AlignmentI al = this.ap.av.getAlignment();
+ AlignmentUtils.findAddableReferenceAnnotations(forSequences,
+ tipEntries, candidates, al);
+ if (!candidates.isEmpty())
+ {
+ StringBuilder tooltip = new StringBuilder(64);
+ tooltip.append(MessageManager.getString("label.add_annotations_for"));
+
+ /*
+ * Found annotations that could be added. Enable the menu item, and
+ * configure its action.
+ */
+ menuItem.setEnabled(true);
+
+ menuItem.addActionListener(new ActionListener()
+ {
+ @Override
+ public void actionPerformed(ActionEvent e)
+ {
+ addReferenceAnnotations_actionPerformed(candidates);
+ }
+ });
+ }
+ }
+
+ /**
+ * Add annotations to the sequences and to the alignment.
+ *
+ * @param candidates
+ * a map whose keys are sequences on the alignment, and values a list
+ * of annotations to add to each sequence
+ */
+ protected void addReferenceAnnotations_actionPerformed(
+ Map<SequenceI, List<AlignmentAnnotation>> candidates)
+ {
+ final SequenceGroup selectionGroup = this.ap.av.getSelectionGroup();
+ final AlignmentI alignment = this.ap.getAlignment();
+ AlignmentUtils.addReferenceAnnotations(candidates, alignment,
+ selectionGroup);
+ refresh();
+ }
+
+ /**
* add a show URL menu item to the given linkMenu
*
* @param linkMenu
{
if (seq == null)
{
- seq = (Sequence) sg.getSequenceAt(0);
+ seq = sg.getSequenceAt(0);
}
EditNameDialog dialog = new EditNameDialog(seq.getSequenceAsString(
Frame frame = new Frame();
frame.add(cap);
jalview.bin.JalviewLite.addFrame(frame, MessageManager.formatMessage(
- "label.selection_output_command", new String[]
+ "label.selection_output_command", new Object[]
{ e.getActionCommand() }), 600, 500);
// JBPNote: getSelectionAsNewSequence behaviour has changed - this method
// now returns a full copy of sequence data
for (SequenceI seq : sequences)
{
contents.append(MessageManager.formatMessage(
- "label.annotation_for_displayid", new String[]
+ "label.annotation_for_displayid", new Object[]
{ seq.getDisplayId(true) }));
new SequenceAnnotationReport(null)
.createSequenceAnnotationReport(
+ (sequences.length == 1 ? sequences[0].getDisplayId(true)
: "Selection"), 600, 500);
cap.setText(MessageManager.formatMessage("label.html_content",
- new String[]
+ new Object[]
{ contents.toString() }));
}
if (ap.av.applet.jmolAvailable)
{
- new jalview.appletgui.AppletJmol(entry, new Sequence[]
+ new jalview.appletgui.AppletJmol(entry, new SequenceI[]
{ seq }, null, ap, AppletFormatAdapter.URL);
}
else
{
- new MCview.AppletPDBViewer(entry, new Sequence[]
+ new MCview.AppletPDBViewer(entry, new SequenceI[]
{ seq }, null, ap, AppletFormatAdapter.URL);
}
Frame frame = new Frame();
frame.add(cap);
jalview.bin.JalviewLite.addFrame(frame, MessageManager.formatMessage(
- "label.paste_pdb_file_for_sequence", new String[]
+ "label.paste_pdb_file_for_sequence", new Object[]
{ seq.getName() }), 400, 300);
}
}
pdb.setLabel(MessageManager.getString("label.view_pdb_structure"));
hideSeqs.setLabel(MessageManager.getString("action.hide_sequences"));
repGroup.setLabel(MessageManager.formatMessage(
- "label.represent_group_with", new String[]
+ "label.represent_group_with", new Object[]
{ "" }));
revealAll.setLabel(MessageManager.getString("action.reveal_all"));
revealSeq.setLabel(MessageManager.getString("action.reveal_sequences"));
this.add(revealSeq);
this.add(revealAll);
// groupMenu.add(selSeqDetails);
+ groupMenu.add(groupShowAnnotationsMenu);
+ groupMenu.add(groupHideAnnotationsMenu);
+ groupMenu.add(groupAddReferenceAnnotations);
groupMenu.add(editMenu);
groupMenu.add(outputmenu);
groupMenu.add(sequenceFeature);
editMenu.add(toLower);
toLower.addActionListener(this);
editMenu.add(toggleCase);
+ seqMenu.add(seqShowAnnotationsMenu);
+ seqMenu.add(seqHideAnnotationsMenu);
+ seqMenu.add(seqAddReferenceAnnotations);
seqMenu.add(sequenceName);
seqMenu.add(makeReferenceSeq);
// seqMenu.add(sequenceDetails);
ap.av.sendSelection();
}
+ /**
+ * Add annotation types to 'Show annotations' and/or 'Hide annotations' menus.
+ * "All" is added first, followed by a separator. Then add any annotation
+ * types associated with the current selection. Separate menus are built for
+ * the selected sequence group (if any), and the selected sequence.
+ * <p>
+ * Some annotation rows are always rendered together - these can be identified
+ * by a common graphGroup property > -1. Only one of each group will be marked
+ * as visible (to avoid duplication of the display). For such groups we add a
+ * composite type name, e.g.
+ * <p>
+ * IUPredWS (Long), IUPredWS (Short)
+ *
+ * @param seq
+ */
+ protected void buildAnnotationTypesMenus(Menu showMenu, Menu hideMenu,
+ List<SequenceI> forSequences)
+ {
+ showMenu.removeAll();
+ hideMenu.removeAll();
+
+ final List<String> all = Arrays.asList(ALL_ANNOTATIONS);
+ addAnnotationTypeToShowHide(showMenu, forSequences, "", all, true, true);
+ addAnnotationTypeToShowHide(hideMenu, forSequences, "", all, true,
+ false);
+ showMenu.addSeparator();
+ hideMenu.addSeparator();
+
+ final AlignmentAnnotation[] annotations = ap.getAlignment()
+ .getAlignmentAnnotation();
+
+ /*
+ * Find shown/hidden annotations types, distinguished by source (calcId),
+ * and grouped by graphGroup. Using LinkedHashMap means we will retrieve in
+ * the insertion order, which is the order of the annotations on the
+ * alignment.
+ */
+ Map<String, List<List<String>>> shownTypes = new LinkedHashMap<String, List<List<String>>>();
+ Map<String, List<List<String>>> hiddenTypes = new LinkedHashMap<String, List<List<String>>>();
+ AlignmentAnnotationUtils.getShownHiddenTypes(shownTypes,
+ hiddenTypes,
+ AlignmentAnnotationUtils.asList(annotations),
+ forSequences);
+
+ for (String calcId : hiddenTypes.keySet())
+ {
+ for (List<String> type : hiddenTypes.get(calcId))
+ {
+ addAnnotationTypeToShowHide(showMenu, forSequences,
+ calcId, type, false, true);
+ }
+ }
+ // grey out 'show annotations' if none are hidden
+ showMenu.setEnabled(!hiddenTypes.isEmpty());
+
+ for (String calcId : shownTypes.keySet())
+ {
+ for (List<String> type : shownTypes.get(calcId))
+ {
+ addAnnotationTypeToShowHide(hideMenu, forSequences,
+ calcId, type, false, false);
+ }
+ }
+ // grey out 'hide annotations' if none are shown
+ hideMenu.setEnabled(!shownTypes.isEmpty());
+ }
+
+ /**
+ * Add one annotation type to the 'Show Annotations' or 'Hide Annotations'
+ * menus.
+ *
+ * @param showOrHideMenu
+ * the menu to add to
+ * @param forSequences
+ * the sequences whose annotations may be shown or hidden
+ * @param calcId
+ * @param types
+ * the label to add
+ * @param allTypes
+ * if true this is a special label meaning 'All'
+ * @param actionIsShow
+ * if true, the select menu item action is to show the annotation
+ * type, else hide
+ */
+ protected void addAnnotationTypeToShowHide(Menu showOrHideMenu,
+ final List<SequenceI> forSequences, String calcId,
+ final List<String> types, final boolean allTypes,
+ final boolean actionIsShow)
+ {
+ String label = types.toString(); // [a, b, c]
+ label = label.substring(1, label.length() - 1);
+ final MenuItem item = new MenuItem(label);
+ item.addActionListener(new java.awt.event.ActionListener()
+ {
+ @Override
+ public void actionPerformed(ActionEvent e)
+ {
+ AlignmentUtils.showOrHideSequenceAnnotations(ap.getAlignment(), types,
+ forSequences, allTypes, actionIsShow);
+ refresh();
+ }
+ });
+ showOrHideMenu.add(item);
+ }
+
}
*/
package jalview.appletgui;
+import java.awt.BorderLayout;
+import java.awt.Canvas;
+import java.awt.CheckboxMenuItem;
+import java.awt.Color;
+import java.awt.Font;
+import java.awt.FontMetrics;
+import java.awt.Frame;
+import java.awt.Graphics;
+import java.awt.Label;
+import java.awt.Menu;
+import java.awt.MenuBar;
+import java.awt.MenuItem;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.FocusEvent;
+import java.awt.event.FocusListener;
+import java.awt.event.ItemEvent;
+import java.awt.event.ItemListener;
+import java.awt.event.KeyEvent;
+import java.awt.event.KeyListener;
+import java.awt.event.WindowAdapter;
+import java.awt.event.WindowEvent;
+import java.io.IOException;
+import java.net.URL;
+import java.net.URLEncoder;
+import java.util.Arrays;
+import java.util.Deque;
+import java.util.HashMap;
+import java.util.Hashtable;
+import java.util.List;
+import java.util.Map;
+import java.util.StringTokenizer;
+import java.util.Vector;
+
import jalview.analysis.AlignmentSorter;
+import jalview.analysis.AnnotationSorter.SequenceAnnotationOrder;
import jalview.api.AlignViewControllerGuiI;
import jalview.api.AlignViewControllerI;
import jalview.api.AlignViewportI;
import jalview.commands.SlideSequencesCommand;
import jalview.commands.TrimRegionCommand;
import jalview.datamodel.Alignment;
+import jalview.datamodel.AlignmentAnnotation;
import jalview.datamodel.AlignmentI;
import jalview.datamodel.AlignmentOrder;
import jalview.datamodel.ColumnSelection;
import jalview.util.MappingUtils;
import jalview.util.MessageManager;
-import java.awt.BorderLayout;
-import java.awt.Canvas;
-import java.awt.CheckboxMenuItem;
-import java.awt.Color;
-import java.awt.Font;
-import java.awt.FontMetrics;
-import java.awt.Frame;
-import java.awt.Graphics;
-import java.awt.Label;
-import java.awt.Menu;
-import java.awt.MenuBar;
-import java.awt.MenuItem;
-import java.awt.event.ActionEvent;
-import java.awt.event.ActionListener;
-import java.awt.event.FocusEvent;
-import java.awt.event.FocusListener;
-import java.awt.event.ItemEvent;
-import java.awt.event.ItemListener;
-import java.awt.event.KeyEvent;
-import java.awt.event.KeyListener;
-import java.awt.event.WindowAdapter;
-import java.awt.event.WindowEvent;
-import java.io.IOException;
-import java.net.URL;
-import java.net.URLEncoder;
-import java.util.Arrays;
-import java.util.Deque;
-import java.util.Hashtable;
-import java.util.List;
-import java.util.Map;
-import java.util.StringTokenizer;
-import java.util.Vector;
-
public class AlignFrame extends EmbmenuFrame implements ActionListener,
ItemListener, KeyListener, AlignViewControllerGuiI
{
String jalviewServletURL;
+ /*
+ * Flag for showing autocalculated consensus above or below other consensus
+ * rows
+ */
+ private boolean showAutoCalculatedAbove;
+
+ private SequenceAnnotationOrder annotationSortOrder;
+
/**
* Constructor that creates the frame and adds it to the display.
*
viewport.updateConservation(alignPanel);
viewport.updateConsensus(alignPanel);
- annotationPanelMenuItem.setState(viewport.isShowAnnotation());
displayNonconservedMenuItem.setState(viewport.getShowUnconserved());
followMouseOverFlag.setState(viewport.getFollowHighlight());
showGroupConsensus.setState(viewport.isShowGroupConsensus());
showSequenceLogo.setState(viewport.isShowSequenceLogo());
normSequenceLogo.setState(viewport.isNormaliseSequenceLogo());
applyToAllGroups.setState(viewport.getColourAppliesToAllGroups());
+ showAlignmentAnnotations.setState(viewport.isShowAnnotation());
+ showSequenceAnnotations.setState(viewport.isShowAnnotation());
seqLimits.setState(viewport.getShowJVSuffix());
@Override
public void itemStateChanged(ItemEvent evt)
{
- if (evt.getSource() == displayNonconservedMenuItem)
+ final Object source = evt.getSource();
+ if (source == displayNonconservedMenuItem)
{
displayNonconservedMenuItem_actionPerformed();
}
- else if (evt.getSource() == colourTextMenuItem)
+ else if (source == colourTextMenuItem)
{
colourTextMenuItem_actionPerformed();
}
- else if (evt.getSource() == wrapMenuItem)
+ else if (source == wrapMenuItem)
{
wrapMenuItem_actionPerformed();
}
- else if (evt.getSource() == scaleAbove)
+ else if (source == scaleAbove)
{
viewport.setScaleAboveWrapped(scaleAbove.getState());
}
- else if (evt.getSource() == scaleLeft)
+ else if (source == scaleLeft)
{
viewport.setScaleLeftWrapped(scaleLeft.getState());
}
- else if (evt.getSource() == scaleRight)
+ else if (source == scaleRight)
{
viewport.setScaleRightWrapped(scaleRight.getState());
}
- else if (evt.getSource() == seqLimits)
+ else if (source == seqLimits)
{
seqLimits_itemStateChanged();
}
- else if (evt.getSource() == viewBoxesMenuItem)
+ else if (source == viewBoxesMenuItem)
{
viewport.setShowBoxes(viewBoxesMenuItem.getState());
}
- else if (evt.getSource() == viewTextMenuItem)
+ else if (source == viewTextMenuItem)
{
viewport.setShowText(viewTextMenuItem.getState());
}
- else if (evt.getSource() == renderGapsMenuItem)
+ else if (source == renderGapsMenuItem)
{
viewport.setRenderGaps(renderGapsMenuItem.getState());
}
- else if (evt.getSource() == annotationPanelMenuItem)
+ else if (source == annotationPanelMenuItem)
{
viewport.setShowAnnotation(annotationPanelMenuItem.getState());
alignPanel.setAnnotationVisible(annotationPanelMenuItem.getState());
}
- else if (evt.getSource() == sequenceFeatures)
+ else if (source == sequenceFeatures)
{
viewport.setShowSequenceFeatures(sequenceFeatures.getState());
alignPanel.seqPanel.seqCanvas.repaint();
}
- else if (evt.getSource() == conservationMenuItem)
+ else if (source == showAlignmentAnnotations)
+ {
+ setAnnotationsVisibility();
+ }
+ else if (source == showSequenceAnnotations)
+ {
+ setAnnotationsVisibility();
+ }
+ else if (source == sortAnnBySequence)
+ {
+ boolean newState = sortAnnBySequence.getState();
+ sortAnnByLabel.setState(false);
+ setAnnotationSortOrder(newState ? SequenceAnnotationOrder.SEQUENCE_AND_LABEL
+ : SequenceAnnotationOrder.NONE);
+ setViewportAnnotationOrder();
+ }
+ else if (source == sortAnnByLabel)
+ {
+ boolean newState = sortAnnByLabel.getState();
+ sortAnnBySequence.setState(false);
+ setAnnotationSortOrder(newState ? SequenceAnnotationOrder.LABEL_AND_SEQUENCE
+ : SequenceAnnotationOrder.NONE);
+ setViewportAnnotationOrder();
+ }
+ else if (source == showAutoFirst)
+ {
+ showAutoLast.setState(!showAutoFirst.getState());
+ setShowAutoCalculatedAbove(showAutoFirst.getState());
+ setViewportAnnotationOrder();
+ }
+ else if (source == showAutoLast)
+ {
+ showAutoFirst.setState(!showAutoLast.getState());
+ setShowAutoCalculatedAbove(showAutoFirst.getState());
+ setViewportAnnotationOrder();
+ }
+ else if (source == conservationMenuItem)
{
conservationMenuItem_actionPerformed();
}
- else if (evt.getSource() == abovePIDThreshold)
+ else if (source == abovePIDThreshold)
{
abovePIDThreshold_actionPerformed();
}
- else if (evt.getSource() == applyToAllGroups)
+ else if (source == applyToAllGroups)
{
viewport.setColourAppliesToAllGroups(applyToAllGroups.getState());
}
- else if (evt.getSource() == autoCalculate)
+ else if (source == autoCalculate)
{
viewport.autoCalculateConsensus = autoCalculate.getState();
}
- else if (evt.getSource() == sortByTree)
+ else if (source == sortByTree)
{
viewport.sortByTree = sortByTree.getState();
}
- else if (evt.getSource() == this.centreColumnLabelFlag)
+ else if (source == this.centreColumnLabelFlag)
{
centreColumnLabelFlag_stateChanged();
}
- else if (evt.getSource() == this.followMouseOverFlag)
+ else if (source == this.followMouseOverFlag)
{
mouseOverFlag_stateChanged();
}
- else if (evt.getSource() == showGroupConsensus)
+ else if (source == showGroupConsensus)
{
showGroupConsensus_actionPerformed();
}
- else if (evt.getSource() == showGroupConservation)
+ else if (source == showGroupConservation)
{
showGroupConservation_actionPerformed();
}
- else if (evt.getSource() == showSequenceLogo)
+ else if (source == showSequenceLogo)
{
showSequenceLogo_actionPerformed();
}
- else if (evt.getSource() == normSequenceLogo)
+ else if (source == normSequenceLogo)
{
normSequenceLogo_actionPerformed();
}
- else if (evt.getSource() == showConsensusHistogram)
+ else if (source == showConsensusHistogram)
{
showConsensusHistogram_actionPerformed();
}
- else if (evt.getSource() == applyAutoAnnotationSettings)
+ else if (source == applyAutoAnnotationSettings)
{
applyAutoAnnotationSettings_actionPerformed();
}
alignPanel.paintAlignment(true);
}
+ /**
+ * Set the visibility state of sequence-related and/or alignment-related
+ * annotations depending on checkbox selections. Repaint after calling.
+ *
+ * @param visible
+ */
+ private void setAnnotationsVisibility()
+ {
+ boolean showForAlignment = showAlignmentAnnotations.getState();
+ boolean showForSequences = showSequenceAnnotations.getState();
+ for (AlignmentAnnotation aa : alignPanel.getAlignment()
+ .getAlignmentAnnotation())
+ {
+ boolean visible = (aa.sequenceRef == null ? showForAlignment
+ : showForSequences);
+ aa.visible = visible;
+ }
+ alignPanel.validateAnnotationDimensions(false);
+ }
+
+ private void setAnnotationSortOrder(SequenceAnnotationOrder order)
+ {
+ this.annotationSortOrder = order;
+ }
+
+ /**
+ * Set flags on the viewport that control annotation ordering
+ */
+ private void setViewportAnnotationOrder()
+ {
+ this.alignPanel.av.setSortAnnotationsBy(this.annotationSortOrder);
+ this.alignPanel.av
+ .setShowAutocalculatedAbove(this.showAutoCalculatedAbove);
+ }
+
+ private void setShowAutoCalculatedAbove(boolean showAbove)
+ {
+ this.showAutoCalculatedAbove = showAbove;
+ }
+
private void mouseOverFlag_stateChanged()
{
viewport.followHighlight = followMouseOverFlag.getState();
SequenceGroup sg = viewport.getSelectionGroup();
copiedSequences = new StringBuffer();
- Hashtable orderedSeqs = new Hashtable();
+ Map<Integer, SequenceI> orderedSeqs = new HashMap<Integer, SequenceI>();
for (int i = 0; i < sg.getSize(); i++)
{
SequenceI seq = sg.getSequenceAt(i);
int index = viewport.getAlignment().findIndex(seq);
- orderedSeqs.put(index + "", seq);
+ orderedSeqs.put(index, seq);
}
int index = 0, startRes, endRes;
while (seq == null)
{
- if (orderedSeqs.containsKey(index + ""))
+ if (orderedSeqs.containsKey(index))
{
- seq = (SequenceI) orderedSeqs.get(index + "");
+ seq = orderedSeqs.get(index);
index++;
-
break;
}
else
if (alignPanel != null
&& (fr = alignPanel.getFeatureRenderer()) != null)
{
- List gps = fr.getFeatureGroups();
- int p=0;
- String[] _gps = new String[gps.size()];
- for (Object gp:gps)
- {
- _gps[p++] = gp.toString();
- }
+ List<String> gps = fr.getFeatureGroups();
+ String[] _gps = gps.toArray(new String[gps.size()]);
return _gps;
}
return null;
if (alignPanel != null
&& (fr = alignPanel.getFeatureRenderer()) != null)
{
- List gps = fr.getGroups(visible);
- int p=0;
- String[] _gps = new String[gps.size()];
- for (Object gp:gps)
- {
- _gps[p++] = gp.toString();
- }
+ List<String> gps = fr.getGroups(visible);
+ String[] _gps = gps.toArray(new String[gps.size()]);
return _gps;
}
return null;
MenuItem closeMenuItem = new MenuItem(
MessageManager.getString("action.close"));
- Menu editMenu = new Menu(MessageManager.getString("action.edit"));
-
- Menu viewMenu = new Menu(MessageManager.getString("action.view"));
-
- Menu colourMenu = new Menu(MessageManager.getString("action.colour"));
-
- Menu calculateMenu = new Menu(
- MessageManager.getString("action.calculate"));
-
MenuItem selectAllSequenceMenuItem = new MenuItem(
MessageManager.getString("action.select_all"));
public Label statusBar = new Label();
- Menu outputTextboxMenu = new Menu();
-
MenuItem clustalColour = new MenuItem();
MenuItem zappoColour = new MenuItem();
MenuItem modifyConservation = new MenuItem();
- CheckboxMenuItem autoCalculate = new CheckboxMenuItem(
- "Autocalculate Consensus", true);
+ CheckboxMenuItem autoCalculate = null;
CheckboxMenuItem sortByTree = new CheckboxMenuItem(
"Sort Alignment With New Tree", true);
Menu sortByTreeMenu = new Menu();
- Menu sort = new Menu();
-
- Menu calculate = new Menu();
-
MenuItem inputText = new MenuItem();
- Menu helpMenu = new Menu();
-
MenuItem documentation = new MenuItem();
MenuItem about = new MenuItem();
CheckboxMenuItem followMouseOverFlag = new CheckboxMenuItem();
- Menu autoAnnMenu = new Menu();
-
CheckboxMenuItem showSequenceLogo = new CheckboxMenuItem();
CheckboxMenuItem applyAutoAnnotationSettings = new CheckboxMenuItem();
CheckboxMenuItem normSequenceLogo = new CheckboxMenuItem();
+ /**
+ * Initialise menus and other items
+ *
+ * @throws Exception
+ */
private void jbInit() throws Exception
{
-
setMenuBar(alignFrameMenuBar);
- MenuItem item;
-
- // dynamically fill save as menu with available formats
+ /*
+ * Configure File menu items and actions
+ */
+ inputText
+ .setLabel(MessageManager.getString("label.input_from_textbox"));
+ inputText.addActionListener(this);
+ Menu outputTextboxMenu = new Menu(
+ MessageManager.getString("label.out_to_textbox"));
for (int i = 0; i < jalview.io.AppletFormatAdapter.WRITEABLE_FORMATS.length; i++)
{
- item = new MenuItem(
+ MenuItem item = new MenuItem(
jalview.io.AppletFormatAdapter.WRITEABLE_FORMATS[i]);
item.addActionListener(new java.awt.event.ActionListener()
}
closeMenuItem.addActionListener(this);
loadApplication.addActionListener(this);
-
loadTree.addActionListener(this);
loadAnnotations.addActionListener(this);
outputFeatures.addActionListener(this);
outputAnnotations.addActionListener(this);
- selectAllSequenceMenuItem.addActionListener(this);
- deselectAllSequenceMenuItem.addActionListener(this);
- invertSequenceMenuItem.addActionListener(this);
+
+ /*
+ * Configure Edit menu items and actions
+ */
+ undoMenuItem.setEnabled(false);
+ undoMenuItem.setLabel(MessageManager.getString("action.undo"));
+ undoMenuItem.addActionListener(this);
+ redoMenuItem.setEnabled(false);
+ redoMenuItem.setLabel(MessageManager.getString("action.redo"));
+ redoMenuItem.addActionListener(this);
+ copy.setLabel(MessageManager.getString("action.copy"));
+ copy.addActionListener(this);
+ cut.setLabel(MessageManager.getString("action.cut"));
+ cut.addActionListener(this);
+ delete.setLabel(MessageManager.getString("action.delete"));
+ delete.addActionListener(this);
+ pasteMenu.setLabel(MessageManager.getString("action.paste"));
+ pasteNew.setLabel(MessageManager.getString("label.to_new_alignment"));
+ pasteNew.addActionListener(this);
+ pasteThis.setLabel(MessageManager.getString("label.to_this_alignment"));
+ pasteThis.addActionListener(this);
remove2LeftMenuItem.setLabel(MessageManager
.getString("action.remove_left"));
remove2LeftMenuItem.addActionListener(this);
removeAllGapsMenuItem.setLabel(MessageManager
.getString("action.remove_all_gaps"));
removeAllGapsMenuItem.addActionListener(this);
- viewBoxesMenuItem.setLabel(MessageManager.getString("action.boxes"));
- viewBoxesMenuItem.setState(true);
- viewBoxesMenuItem.addItemListener(this);
- viewTextMenuItem.setLabel(MessageManager.getString("action.text"));
- viewTextMenuItem.setState(true);
- viewTextMenuItem.addItemListener(this);
- sortPairwiseMenuItem.setLabel(MessageManager
- .getString("action.by_pairwise_id"));
- sortPairwiseMenuItem.addActionListener(this);
- sortIDMenuItem.setLabel(MessageManager.getString("action.by_id"));
- sortIDMenuItem.addActionListener(this);
- sortLengthMenuItem.setLabel(MessageManager
- .getString("action.by_length"));
- sortLengthMenuItem.addActionListener(this);
- sortGroupMenuItem.setLabel(MessageManager.getString("action.by_group"));
- sortGroupMenuItem.addActionListener(this);
- removeRedundancyMenuItem.setLabel(MessageManager
- .getString("action.remove_redundancy").concat("..."));
+ removeRedundancyMenuItem.setLabel(MessageManager.getString(
+ "action.remove_redundancy").concat("..."));
removeRedundancyMenuItem.addActionListener(this);
- pairwiseAlignmentMenuItem.setLabel(MessageManager
- .getString("action.pairwise_alignment"));
- pairwiseAlignmentMenuItem.addActionListener(this);
- PCAMenuItem.setLabel(MessageManager
- .getString("label.principal_component_analysis"));
- PCAMenuItem.addActionListener(this);
- averageDistanceTreeMenuItem.setLabel(MessageManager
- .getString("label.average_distance_identity"));
- averageDistanceTreeMenuItem.addActionListener(this);
- neighbourTreeMenuItem.setLabel(MessageManager
- .getString("label.neighbour_joining_identity"));
- neighbourTreeMenuItem.addActionListener(this);
- statusBar.setBackground(Color.white);
- statusBar.setFont(new java.awt.Font("Verdana", 0, 11));
- statusBar.setText(MessageManager.getString("label.status_bar"));
- outputTextboxMenu.setLabel(MessageManager
- .getString("label.out_to_textbox"));
- clustalColour.setLabel(MessageManager.getString("label.clustalx"));
- clustalColour.addActionListener(this);
- zappoColour.setLabel(MessageManager.getString("label.zappo"));
- zappoColour.addActionListener(this);
- taylorColour.setLabel(MessageManager.getString("label.taylor"));
- taylorColour.addActionListener(this);
- hydrophobicityColour.setLabel(MessageManager
- .getString("label.hydrophobicity"));
- hydrophobicityColour.addActionListener(this);
- helixColour
- .setLabel(MessageManager.getString("label.helix_propensity"));
- helixColour.addActionListener(this);
- strandColour.setLabel(MessageManager
- .getString("label.strand_propensity"));
- strandColour.addActionListener(this);
- turnColour.setLabel(MessageManager.getString("label.turn_propensity"));
- turnColour.addActionListener(this);
- buriedColour.setLabel(MessageManager.getString("label.buried_index"));
- buriedColour.addActionListener(this);
- purinePyrimidineColour.setLabel(MessageManager
- .getString("label.purine_pyrimidine"));
- purinePyrimidineColour.addActionListener(this);
- RNAInteractionColour.setLabel(MessageManager
- .getString("label.rna_interaction"));
- RNAInteractionColour.addActionListener(this);
- RNAHelixColour.setLabel(MessageManager
- .getString("action.by_rna_helixes"));
- RNAHelixColour.addActionListener(this);
- userDefinedColour.setLabel(MessageManager
- .getString("action.user_defined"));
- userDefinedColour.addActionListener(this);
- PIDColour.setLabel(MessageManager
- .getString("label.percentage_identity"));
- PIDColour.addActionListener(this);
- BLOSUM62Colour.setLabel(MessageManager
- .getString("label.blosum62_score"));
- BLOSUM62Colour.addActionListener(this);
- tcoffeeColour
- .setLabel(MessageManager.getString("label.tcoffee_scores"));
- tcoffeeColour.setEnabled(false); // it will enabled only if a score file is
- // provided
- tcoffeeColour.addActionListener(this);
- avDistanceTreeBlosumMenuItem.setLabel(MessageManager
- .getString("label.average_distance_bloslum62"));
- avDistanceTreeBlosumMenuItem.addActionListener(this);
- njTreeBlosumMenuItem.setLabel(MessageManager
- .getString("label.neighbour_blosum62"));
- njTreeBlosumMenuItem.addActionListener(this);
- annotationPanelMenuItem.setLabel(MessageManager
- .getString("label.show_annotations"));
- annotationPanelMenuItem.addItemListener(this);
- colourTextMenuItem.setLabel(MessageManager
- .getString("label.colour_text"));
- colourTextMenuItem.addItemListener(this);
- displayNonconservedMenuItem.setLabel(MessageManager
- .getString("label.show_non_conversed"));
- displayNonconservedMenuItem.addItemListener(this);
- alProperties.addActionListener(this);
- overviewMenuItem.setLabel(MessageManager
- .getString("label.overview_window"));
- overviewMenuItem.addActionListener(this);
- undoMenuItem.setEnabled(false);
- undoMenuItem.setLabel(MessageManager.getString("action.undo"));
- undoMenuItem.addActionListener(this);
- redoMenuItem.setEnabled(false);
- redoMenuItem.setLabel(MessageManager.getString("action.redo"));
- redoMenuItem.addActionListener(this);
- conservationMenuItem.setLabel(MessageManager
- .getString("action.by_conservation"));
- conservationMenuItem.addItemListener(this);
- noColourmenuItem.setLabel(MessageManager.getString("label.none"));
- noColourmenuItem.addActionListener(this);
- wrapMenuItem.setLabel(MessageManager.getString("action.wrap"));
- wrapMenuItem.addItemListener(this);
- renderGapsMenuItem.setLabel(MessageManager
- .getString("action.show_gaps"));
- renderGapsMenuItem.setState(true);
- renderGapsMenuItem.addItemListener(this);
+ /*
+ * Configure Select menu items and actions
+ */
findMenuItem.setLabel(MessageManager.getString("action.find"));
findMenuItem.addActionListener(this);
- abovePIDThreshold.setLabel(MessageManager
- .getString("label.above_identity_threshold"));
- abovePIDThreshold.addItemListener(this);
- nucleotideColour.setLabel(MessageManager.getString("label.nucleotide"));
- nucleotideColour.addActionListener(this);
+ selectAllSequenceMenuItem.addActionListener(this);
+ deselectAllSequenceMenuItem.addActionListener(this);
+ invertSequenceMenuItem.setLabel(MessageManager
+ .getString("action.invert_sequence_selection"));
+ invertSequenceMenuItem.addActionListener(this);
+ invertColSel.setLabel(MessageManager
+ .getString("action.invert_column_selection"));
+ invertColSel.addActionListener(this);
deleteGroups.setLabel(MessageManager
.getString("action.undefine_groups"));
deleteGroups.addActionListener(this);
grpsFromSelection.addActionListener(this);
createGroup.setLabel(MessageManager.getString("action.create_group"));
unGroup.setLabel(MessageManager.getString("action.remove_group"));
- copy.setLabel(MessageManager.getString("action.copy"));
- copy.addActionListener(this);
- cut.setLabel(MessageManager.getString("action.cut"));
- cut.addActionListener(this);
- delete.setLabel(MessageManager.getString("action.delete"));
- delete.addActionListener(this);
- pasteMenu.setLabel(MessageManager.getString("action.paste"));
- pasteNew.setLabel(MessageManager.getString("label.to_new_alignment"));
- pasteNew.addActionListener(this);
- pasteThis.setLabel(MessageManager.getString("label.to_this_alignment"));
- pasteThis.addActionListener(this);
- applyToAllGroups.setLabel(MessageManager
- .getString("label.apply_colour_to_all_groups"));
- applyToAllGroups.setState(true);
- applyToAllGroups.addItemListener(this);
- font.setLabel(MessageManager.getString("action.font"));
- font.addActionListener(this);
- scaleAbove.setLabel(MessageManager.getString("action.scale_above"));
- scaleAbove.setState(true);
- scaleAbove.setEnabled(false);
- scaleAbove.addItemListener(this);
- scaleLeft.setEnabled(false);
- scaleLeft.setState(true);
- scaleLeft.setLabel(MessageManager.getString("action.scale_left"));
- scaleLeft.addItemListener(this);
- scaleRight.setEnabled(false);
- scaleRight.setState(true);
- scaleRight.setLabel(MessageManager.getString("action.scale_right"));
- scaleRight.addItemListener(this);
- modifyPID.setLabel(MessageManager
- .getString("label.modify_identity_thereshold"));
- modifyPID.addActionListener(this);
- modifyConservation.setLabel(MessageManager
- .getString("label.modify_conservation_thereshold"));
- modifyConservation.addActionListener(this);
- sortByTreeMenu.setLabel(MessageManager
- .getString("action.by_tree_order"));
- sort.setLabel(MessageManager.getString("action.sort"));
- calculate.setLabel(MessageManager.getString("action.calculate_tree"));
- autoCalculate.addItemListener(this);
- sortByTree.addItemListener(this);
- inputText
- .setLabel(MessageManager.getString("label.input_from_textbox"));
- inputText.addActionListener(this);
- centreColumnLabelFlag.setLabel(MessageManager
- .getString("label.centre_column_labels"));
- centreColumnLabelFlag.addItemListener(this);
- followMouseOverFlag.setLabel(MessageManager
- .getString("label.automatic_scrolling"));
- followMouseOverFlag.addItemListener(this);
- helpMenu.setLabel(MessageManager.getString("action.help"));
- documentation.setLabel(MessageManager.getString("label.documentation"));
- documentation.addActionListener(this);
-
- about.setLabel(MessageManager.getString("label.about"));
- about.addActionListener(this);
- seqLimits.setState(true);
- seqLimits.setLabel(MessageManager
- .getString("label.show_sequence_limits"));
- seqLimits.addItemListener(this);
- featureSettings.setLabel(MessageManager
- .getString("label.feature_settings"));
- featureSettings.addActionListener(this);
- sequenceFeatures.setLabel(MessageManager
- .getString("label.sequence_features"));
- sequenceFeatures.addItemListener(this);
- sequenceFeatures.setState(false);
- annotationColour.setLabel(MessageManager
- .getString("action.by_annotation"));
- annotationColour.addActionListener(this);
-
annotationColumnSelection.setLabel("Select by Annotation");
annotationColumnSelection.addActionListener(this);
- invertSequenceMenuItem.setLabel(MessageManager
- .getString("action.invert_sequence_selection"));
- invertColSel.setLabel(MessageManager
- .getString("action.invert_column_selection"));
- menu1.setLabel(MessageManager.getString("action.show"));
+ /*
+ * Configure View menu items and actions
+ */
+ newView.setLabel(MessageManager.getString("action.new_view"));
+ newView.addActionListener(this);
+ Menu showMenu = new Menu(MessageManager.getString("action.show"));
showColumns.setLabel(MessageManager.getString("label.all_columns"));
showSeqs.setLabel(MessageManager.getString("label.all_sequences"));
- menu2.setLabel(MessageManager.getString("action.hide"));
+ Menu hideMenu = new Menu(MessageManager.getString("action.hide"));
hideColumns
.setLabel(MessageManager.getString("label.selected_columns"));
hideSequences.setLabel(MessageManager
.getString("label.selected_region"));
showAllHidden.setLabel(MessageManager
.getString("label.all_sequences_columns"));
+ showColumns.addActionListener(this);
+ showSeqs.addActionListener(this);
+ hideColumns.addActionListener(this);
+ hideSequences.addActionListener(this);
+ hideAllButSelection.addActionListener(this);
+ hideAllSelection.addActionListener(this);
+ showAllHidden.addActionListener(this);
+ featureSettings.setLabel(MessageManager
+ .getString("label.feature_settings"));
+ featureSettings.addActionListener(this);
+ sequenceFeatures.setLabel(MessageManager
+ .getString("label.show_sequence_features"));
+ sequenceFeatures.addItemListener(this);
+ sequenceFeatures.setState(false);
+ followMouseOverFlag.setLabel(MessageManager
+ .getString("label.automatic_scrolling"));
+ followMouseOverFlag.addItemListener(this);
+ alProperties.addActionListener(this);
+ overviewMenuItem.setLabel(MessageManager
+ .getString("label.overview_window"));
+ overviewMenuItem.addActionListener(this);
+
+ /*
+ * Configure Annotations menu items and actions
+ */
+ annotationPanelMenuItem.setLabel(MessageManager
+ .getString("label.show_annotations"));
+ annotationPanelMenuItem.addItemListener(this);
showGroupConsensus.setLabel(MessageManager
.getString("label.group_consensus"));
showGroupConservation.setLabel(MessageManager
applyAutoAnnotationSettings.setLabel(MessageManager
.getString("label.apply_all_groups"));
applyAutoAnnotationSettings.setState(true);
- autoAnnMenu.setLabel(MessageManager
- .getString("label.autocalculated_annotation"));
-
- invertColSel.addActionListener(this);
- showColumns.addActionListener(this);
- showSeqs.addActionListener(this);
- hideColumns.addActionListener(this);
- hideSequences.addActionListener(this);
- hideAllButSelection.addActionListener(this);
- hideAllSelection.addActionListener(this);
- showAllHidden.addActionListener(this);
+ Menu autoAnnMenu = new Menu(
+ MessageManager.getString("label.autocalculated_annotation"));
showGroupConsensus.addItemListener(this);
showGroupConservation.addItemListener(this);
showConsensusHistogram.addItemListener(this);
showSequenceLogo.addItemListener(this);
normSequenceLogo.addItemListener(this);
-
applyAutoAnnotationSettings.addItemListener(this);
- formatMenu.setLabel(MessageManager.getString("action.format"));
- selectMenu.setLabel(MessageManager.getString("action.select"));
- newView.setLabel(MessageManager.getString("action.new_view"));
- newView.addActionListener(this);
+ showAlignmentAnnotations = new CheckboxMenuItem(
+ MessageManager.getString("label.show_all_al_annotations"));
+ showSequenceAnnotations = new CheckboxMenuItem(
+ MessageManager.getString("label.show_all_seq_annotations"));
+ sortAnnBySequence = new CheckboxMenuItem(
+ MessageManager.getString("label.sort_annotations_by_sequence"));
+ sortAnnByLabel = new CheckboxMenuItem(
+ MessageManager.getString("label.sort_annotations_by_label"));
+ showAutoFirst = new CheckboxMenuItem(
+ MessageManager.getString("label.show_first"));
+ showAutoLast = new CheckboxMenuItem(
+ MessageManager.getString("label.show_last"));
+ showAlignmentAnnotations.addItemListener(this);
+ showSequenceAnnotations.addItemListener(this);
+ sortAnnBySequence.addItemListener(this);
+ sortAnnByLabel.addItemListener(this);
+ showAutoFirst.addItemListener(this);
+ showAutoLast.addItemListener(this);
+
+ /*
+ * Configure Format menu items and actions
+ */
+ font.setLabel(MessageManager.getString("action.font"));
+ font.addActionListener(this);
+ scaleAbove.setLabel(MessageManager.getString("action.scale_above"));
+ scaleAbove.setState(true);
+ scaleAbove.setEnabled(false);
+ scaleAbove.addItemListener(this);
+ scaleLeft.setEnabled(false);
+ scaleLeft.setState(true);
+ scaleLeft.setLabel(MessageManager.getString("action.scale_left"));
+ scaleLeft.addItemListener(this);
+ scaleRight.setEnabled(false);
+ scaleRight.setState(true);
+ scaleRight.setLabel(MessageManager.getString("action.scale_right"));
+ scaleRight.addItemListener(this);
+ viewBoxesMenuItem.setLabel(MessageManager.getString("action.boxes"));
+ viewBoxesMenuItem.setState(true);
+ viewBoxesMenuItem.addItemListener(this);
+ viewTextMenuItem.setLabel(MessageManager.getString("action.text"));
+ viewTextMenuItem.setState(true);
+ viewTextMenuItem.addItemListener(this);
+ colourTextMenuItem.setLabel(MessageManager
+ .getString("label.colour_text"));
+ colourTextMenuItem.addItemListener(this);
+ displayNonconservedMenuItem.setLabel(MessageManager
+ .getString("label.show_non_conversed"));
+ displayNonconservedMenuItem.addItemListener(this);
+ wrapMenuItem.setLabel(MessageManager.getString("action.wrap"));
+ wrapMenuItem.addItemListener(this);
+ renderGapsMenuItem.setLabel(MessageManager
+ .getString("action.show_gaps"));
+ renderGapsMenuItem.setState(true);
+ renderGapsMenuItem.addItemListener(this);
+ centreColumnLabelFlag.setLabel(MessageManager
+ .getString("label.centre_column_labels"));
+ centreColumnLabelFlag.addItemListener(this);
+ seqLimits.setState(true);
+ seqLimits.setLabel(MessageManager
+ .getString("label.show_sequence_limits"));
+ seqLimits.addItemListener(this);
+
+ /*
+ * Configure Colour menu items and actions
+ */
+ applyToAllGroups.setLabel(MessageManager
+ .getString("label.apply_colour_to_all_groups"));
+ applyToAllGroups.setState(true);
+ applyToAllGroups.addItemListener(this);
+ clustalColour.setLabel(MessageManager.getString("label.clustalx"));
+ clustalColour.addActionListener(this);
+ zappoColour.setLabel(MessageManager.getString("label.zappo"));
+ zappoColour.addActionListener(this);
+ taylorColour.setLabel(MessageManager.getString("label.taylor"));
+ taylorColour.addActionListener(this);
+ hydrophobicityColour.setLabel(MessageManager
+ .getString("label.hydrophobicity"));
+ hydrophobicityColour.addActionListener(this);
+ helixColour
+ .setLabel(MessageManager.getString("label.helix_propensity"));
+ helixColour.addActionListener(this);
+ strandColour.setLabel(MessageManager
+ .getString("label.strand_propensity"));
+ strandColour.addActionListener(this);
+ turnColour.setLabel(MessageManager.getString("label.turn_propensity"));
+ turnColour.addActionListener(this);
+ buriedColour.setLabel(MessageManager.getString("label.buried_index"));
+ buriedColour.addActionListener(this);
+ purinePyrimidineColour.setLabel(MessageManager
+ .getString("label.purine_pyrimidine"));
+ purinePyrimidineColour.addActionListener(this);
+ RNAInteractionColour.setLabel(MessageManager
+ .getString("label.rna_interaction"));
+ RNAInteractionColour.addActionListener(this);
+ RNAHelixColour.setLabel(MessageManager
+ .getString("action.by_rna_helixes"));
+ RNAHelixColour.addActionListener(this);
+ userDefinedColour.setLabel(MessageManager
+ .getString("action.user_defined"));
+ userDefinedColour.addActionListener(this);
+ PIDColour.setLabel(MessageManager
+ .getString("label.percentage_identity"));
+ PIDColour.addActionListener(this);
+ BLOSUM62Colour.setLabel(MessageManager
+ .getString("label.blosum62_score"));
+ BLOSUM62Colour.addActionListener(this);
+ tcoffeeColour
+ .setLabel(MessageManager.getString("label.tcoffee_scores"));
+ // it will be enabled only if a score file is provided
+ tcoffeeColour.setEnabled(false);
+ tcoffeeColour.addActionListener(this);
+ conservationMenuItem.setLabel(MessageManager
+ .getString("action.by_conservation"));
+ conservationMenuItem.addItemListener(this);
+ noColourmenuItem.setLabel(MessageManager.getString("label.none"));
+ noColourmenuItem.addActionListener(this);
+ abovePIDThreshold.setLabel(MessageManager
+ .getString("label.above_identity_threshold"));
+ abovePIDThreshold.addItemListener(this);
+ nucleotideColour.setLabel(MessageManager.getString("label.nucleotide"));
+ nucleotideColour.addActionListener(this);
+ modifyPID.setLabel(MessageManager
+ .getString("label.modify_identity_thereshold"));
+ modifyPID.addActionListener(this);
+ modifyConservation.setLabel(MessageManager
+ .getString("label.modify_conservation_thereshold"));
+ modifyConservation.addActionListener(this);
+ annotationColour.setLabel(MessageManager
+ .getString("action.by_annotation"));
+ annotationColour.addActionListener(this);
+
+ /*
+ * Configure Calculate menu items and actions
+ */
+ sortPairwiseMenuItem.setLabel(MessageManager
+ .getString("action.by_pairwise_id"));
+ sortPairwiseMenuItem.addActionListener(this);
+ sortIDMenuItem.setLabel(MessageManager.getString("action.by_id"));
+ sortIDMenuItem.addActionListener(this);
+ sortLengthMenuItem.setLabel(MessageManager
+ .getString("action.by_length"));
+ sortLengthMenuItem.addActionListener(this);
+ sortGroupMenuItem.setLabel(MessageManager.getString("action.by_group"));
+ sortGroupMenuItem.addActionListener(this);
+ pairwiseAlignmentMenuItem.setLabel(MessageManager
+ .getString("action.pairwise_alignment"));
+ pairwiseAlignmentMenuItem.addActionListener(this);
+ PCAMenuItem.setLabel(MessageManager
+ .getString("label.principal_component_analysis"));
+ PCAMenuItem.addActionListener(this);
+ autoCalculate = new CheckboxMenuItem(
+ MessageManager.getString("label.autocalculate_consensus"), true);
+ averageDistanceTreeMenuItem.setLabel(MessageManager
+ .getString("label.average_distance_identity"));
+ averageDistanceTreeMenuItem.addActionListener(this);
+ neighbourTreeMenuItem.setLabel(MessageManager
+ .getString("label.neighbour_joining_identity"));
+ neighbourTreeMenuItem.addActionListener(this);
+ avDistanceTreeBlosumMenuItem.setLabel(MessageManager
+ .getString("label.average_distance_bloslum62"));
+ avDistanceTreeBlosumMenuItem.addActionListener(this);
+ njTreeBlosumMenuItem.setLabel(MessageManager
+ .getString("label.neighbour_blosum62"));
+ njTreeBlosumMenuItem.addActionListener(this);
+ sortByTreeMenu.setLabel(MessageManager
+ .getString("action.by_tree_order"));
+ Menu sortMenu = new Menu(MessageManager.getString("action.sort"));
+ Menu calculateTreeMenu = new Menu(
+ MessageManager.getString("action.calculate_tree"));
+ autoCalculate.addItemListener(this);
+ sortByTree.addItemListener(this);
+
+ /*
+ * Configure Help menu items and actions
+ */
+ Menu helpMenu = new Menu(MessageManager.getString("action.help"));
+ documentation.setLabel(MessageManager.getString("label.documentation"));
+ documentation.addActionListener(this);
+ about.setLabel(MessageManager.getString("label.about"));
+ about.addActionListener(this);
+
+ /*
+ * Add top level menus to frame
+ */
alignFrameMenuBar.add(fileMenu);
+ Menu editMenu = new Menu(MessageManager.getString("action.edit"));
alignFrameMenuBar.add(editMenu);
+ Menu selectMenu = new Menu(MessageManager.getString("action.select"));
alignFrameMenuBar.add(selectMenu);
+ Menu viewMenu = new Menu(MessageManager.getString("action.view"));
alignFrameMenuBar.add(viewMenu);
+ Menu annotationsMenu = new Menu(
+ MessageManager.getString("action.annotations"));
+ alignFrameMenuBar.add(annotationsMenu);
+ Menu formatMenu = new Menu(MessageManager.getString("action.format"));
alignFrameMenuBar.add(formatMenu);
+ Menu colourMenu = new Menu(MessageManager.getString("action.colour"));
alignFrameMenuBar.add(colourMenu);
+ Menu calculateMenu = new Menu(
+ MessageManager.getString("action.calculate"));
alignFrameMenuBar.add(calculateMenu);
alignFrameMenuBar.add(helpMenu);
+ /*
+ * File menu
+ */
fileMenu.add(inputText);
fileMenu.add(loadTree);
fileMenu.add(loadAnnotations);
-
fileMenu.addSeparator();
fileMenu.add(outputTextboxMenu);
fileMenu.add(outputFeatures);
fileMenu.add(outputAnnotations);
-
if (jalviewServletURL != null)
{
fileMenu.add(loadApplication);
}
-
fileMenu.addSeparator();
fileMenu.add(closeMenuItem);
+ /*
+ * Edit menu
+ */
editMenu.add(undoMenuItem);
editMenu.add(redoMenuItem);
editMenu.add(cut);
editMenu.add(copy);
+ pasteMenu.add(pasteNew);
+ pasteMenu.add(pasteThis);
editMenu.add(pasteMenu);
editMenu.add(delete);
editMenu.addSeparator();
editMenu.add(removeGappedColumnMenuItem);
editMenu.add(removeAllGapsMenuItem);
editMenu.add(removeRedundancyMenuItem);
+
+ /*
+ * Select menu
+ */
+ selectMenu.add(findMenuItem);
+ selectMenu.addSeparator();
+ selectMenu.add(selectAllSequenceMenuItem);
+ selectMenu.add(deselectAllSequenceMenuItem);
+ selectMenu.add(invertSequenceMenuItem);
+ selectMenu.add(invertColSel);
+ selectMenu.add(createGroup);
+ selectMenu.add(unGroup);
+ selectMenu.add(grpsFromSelection);
+ selectMenu.add(deleteGroups);
+ selectMenu.add(annotationColumnSelection);
+
+ /*
+ * View menu
+ */
viewMenu.add(newView);
viewMenu.addSeparator();
- viewMenu.add(menu1);
- viewMenu.add(menu2);
+ showMenu.add(showColumns);
+ showMenu.add(showSeqs);
+ showMenu.add(showAllHidden);
+ viewMenu.add(showMenu);
+ hideMenu.add(hideColumns);
+ hideMenu.add(hideSequences);
+ hideMenu.add(hideAllSelection);
+ hideMenu.add(hideAllButSelection);
+ viewMenu.add(hideMenu);
viewMenu.addSeparator();
viewMenu.add(followMouseOverFlag);
- viewMenu.add(annotationPanelMenuItem);
- autoAnnMenu.add(applyAutoAnnotationSettings);
- autoAnnMenu.add(showConsensusHistogram);
- autoAnnMenu.add(showSequenceLogo);
- autoAnnMenu.add(normSequenceLogo);
- autoAnnMenu.addSeparator();
- autoAnnMenu.add(showGroupConservation);
- autoAnnMenu.add(showGroupConsensus);
- viewMenu.add(autoAnnMenu);
viewMenu.addSeparator();
viewMenu.add(sequenceFeatures);
viewMenu.add(featureSettings);
viewMenu.add(alProperties);
viewMenu.addSeparator();
viewMenu.add(overviewMenuItem);
+
+ /*
+ * Annotations menu
+ */
+ // annotationsMenu.add(annotationPanelMenuItem);
+ // annotationsMenu.addSeparator();
+ annotationsMenu.add(showAlignmentAnnotations);
+ annotationsMenu.add(showSequenceAnnotations);
+ annotationsMenu.add(sortAnnBySequence);
+ annotationsMenu.add(sortAnnByLabel);
+ annotationsMenu.addSeparator();
+ autoAnnMenu.add(showAutoFirst);
+ autoAnnMenu.add(showAutoLast);
+ autoAnnMenu.addSeparator();
+ autoAnnMenu.add(applyAutoAnnotationSettings);
+ autoAnnMenu.add(showConsensusHistogram);
+ autoAnnMenu.add(showSequenceLogo);
+ autoAnnMenu.add(normSequenceLogo);
+ autoAnnMenu.addSeparator();
+ autoAnnMenu.add(showGroupConservation);
+ autoAnnMenu.add(showGroupConsensus);
+ annotationsMenu.add(autoAnnMenu);
+
+ /*
+ * Format menu
+ */
+ formatMenu.add(font);
+ formatMenu.add(seqLimits);
+ formatMenu.add(wrapMenuItem);
+ formatMenu.add(scaleAbove);
+ formatMenu.add(scaleLeft);
+ formatMenu.add(scaleRight);
+ formatMenu.add(viewBoxesMenuItem);
+ formatMenu.add(viewTextMenuItem);
+ formatMenu.add(colourTextMenuItem);
+ formatMenu.add(displayNonconservedMenuItem);
+ formatMenu.add(renderGapsMenuItem);
+ formatMenu.add(centreColumnLabelFlag);
+
+ /*
+ * Colour menu
+ */
colourMenu.add(applyToAllGroups);
colourMenu.addSeparator();
colourMenu.add(noColourmenuItem);
colourMenu.add(modifyPID);
colourMenu.add(annotationColour);
colourMenu.add(RNAHelixColour);
- calculateMenu.add(sort);
- calculateMenu.add(calculate);
+
+ /*
+ * Calculate menu
+ */
+ sortMenu.add(sortIDMenuItem);
+ sortMenu.add(sortLengthMenuItem);
+ sortMenu.add(sortByTreeMenu);
+ sortMenu.add(sortGroupMenuItem);
+ sortMenu.add(sortPairwiseMenuItem);
+ calculateMenu.add(sortMenu);
+ calculateTreeMenu.add(averageDistanceTreeMenuItem);
+ calculateTreeMenu.add(neighbourTreeMenuItem);
+ calculateTreeMenu.add(avDistanceTreeBlosumMenuItem);
+ calculateTreeMenu.add(njTreeBlosumMenuItem);
+ calculateMenu.add(calculateTreeMenu);
calculateMenu.addSeparator();
calculateMenu.add(pairwiseAlignmentMenuItem);
calculateMenu.add(PCAMenuItem);
calculateMenu.add(autoCalculate);
calculateMenu.add(sortByTree);
- this.add(statusBar, BorderLayout.SOUTH);
- pasteMenu.add(pasteNew);
- pasteMenu.add(pasteThis);
- sort.add(sortIDMenuItem);
- sort.add(sortLengthMenuItem);
- sort.add(sortByTreeMenu);
- sort.add(sortGroupMenuItem);
- sort.add(sortPairwiseMenuItem);
- calculate.add(averageDistanceTreeMenuItem);
- calculate.add(neighbourTreeMenuItem);
- calculate.add(avDistanceTreeBlosumMenuItem);
- calculate.add(njTreeBlosumMenuItem);
+
+ /*
+ * Help menu
+ */
helpMenu.add(documentation);
helpMenu.add(about);
- menu1.add(showColumns);
- menu1.add(showSeqs);
- menu1.add(showAllHidden);
- menu2.add(hideColumns);
- menu2.add(hideSequences);
- menu2.add(hideAllSelection);
- menu2.add(hideAllButSelection);
- formatMenu.add(font);
- formatMenu.add(seqLimits);
- formatMenu.add(wrapMenuItem);
- formatMenu.add(scaleAbove);
- formatMenu.add(scaleLeft);
- formatMenu.add(scaleRight);
- formatMenu.add(viewBoxesMenuItem);
- formatMenu.add(viewTextMenuItem);
- formatMenu.add(colourTextMenuItem);
- formatMenu.add(displayNonconservedMenuItem);
- formatMenu.add(renderGapsMenuItem);
- formatMenu.add(centreColumnLabelFlag);
- selectMenu.add(findMenuItem);
- selectMenu.addSeparator();
- selectMenu.add(selectAllSequenceMenuItem);
- selectMenu.add(deselectAllSequenceMenuItem);
- selectMenu.add(invertSequenceMenuItem);
- selectMenu.add(invertColSel);
- selectMenu.add(createGroup);
- selectMenu.add(unGroup);
- selectMenu.add(grpsFromSelection);
- selectMenu.add(deleteGroups);
- selectMenu.add(annotationColumnSelection);
+ /*
+ * Status bar
+ */
+ statusBar.setBackground(Color.white);
+ statusBar.setFont(new java.awt.Font("Verdana", 0, 11));
+ statusBar.setText(MessageManager.getString("label.status_bar"));
+ this.add(statusBar, BorderLayout.SOUTH);
}
public void setStatus(String string)
MenuItem invertColSel = new MenuItem();
- Menu menu1 = new Menu();
-
MenuItem showColumns = new MenuItem();
MenuItem showSeqs = new MenuItem();
- Menu menu2 = new Menu();
-
MenuItem hideColumns = new MenuItem();
MenuItem hideSequences = new MenuItem();
MenuItem showAllHidden = new MenuItem();
- Menu formatMenu = new Menu();
+ MenuItem newView = new MenuItem();
- Menu selectMenu = new Menu();
+ private CheckboxMenuItem showAlignmentAnnotations;
- MenuItem newView = new MenuItem();
+ private CheckboxMenuItem showSequenceAnnotations;
+
+ private CheckboxMenuItem sortAnnBySequence;
+
+ private CheckboxMenuItem sortAnnByLabel;
+
+ private CheckboxMenuItem showAutoFirst;
+
+ private CheckboxMenuItem showAutoLast;
/**
* Attach the alignFrame panels after embedding menus, if necessary. This used
*/
package jalview.appletgui;
-import jalview.api.AlignViewportI;
-import jalview.api.AlignmentViewPanel;
-import jalview.datamodel.AlignmentI;
-import jalview.datamodel.SearchResults;
-import jalview.datamodel.SequenceI;
-import jalview.structure.StructureSelectionManager;
-
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.event.ComponentAdapter;
import java.awt.event.ComponentEvent;
+import jalview.analysis.AnnotationSorter;
+import jalview.api.AlignViewportI;
+import jalview.api.AlignmentViewPanel;
+import jalview.datamodel.AlignmentI;
+import jalview.datamodel.SearchResults;
+import jalview.datamodel.SequenceI;
+import jalview.structure.StructureSelectionManager;
+
public class AlignmentPanel extends Panel implements AdjustmentListener,
AlignmentViewPanel
{
av.endSeq);
}
+ /**
+ * Repaint the alignment and annotations, and, optionally, any overview window
+ */
public void paintAlignment(boolean updateOverview)
{
+ final AnnotationSorter sorter = new AnnotationSorter(getAlignment(),
+ av.isShowAutocalculatedAbove());
+ sorter.sort(getAlignment().getAlignmentAnnotation(),
+ av.getSortAnnotationsBy());
repaint();
if (updateOverview)
*/
package jalview.appletgui;
-import jalview.datamodel.AlignmentAnnotation;
-import jalview.datamodel.Annotation;
-import jalview.datamodel.SequenceGroup;
-import jalview.datamodel.SequenceI;
-import jalview.util.MessageManager;
-import jalview.util.ParseHtmlBodyAndLinks;
-
import java.awt.Checkbox;
import java.awt.CheckboxMenuItem;
import java.awt.Color;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.util.Arrays;
+import java.util.Collections;
import java.util.Vector;
+import jalview.analysis.AlignmentUtils;
+import jalview.datamodel.AlignmentAnnotation;
+import jalview.datamodel.Annotation;
+import jalview.datamodel.SequenceGroup;
+import jalview.datamodel.SequenceI;
+import jalview.util.MessageManager;
+import jalview.util.ParseHtmlBodyAndLinks;
+
public class AnnotationLabels extends Panel implements ActionListener,
MouseListener, MouseMotionListener
{
}
}
+ refresh();
+ }
+
+ /**
+ * Adjust size and repaint
+ */
+ protected void refresh()
+ {
ap.annotationPanel.adjustPanelHeight();
setSize(getSize().width, ap.annotationPanel.getSize().height);
ap.validate();
item = new MenuItem(HIDE);
item.addActionListener(this);
popup.add(item);
+
+ /*
+ * Hide all <label>:
+ */
+ if (selectedRow < aa.length)
+ {
+ if (aa[selectedRow].sequenceRef != null)
+ {
+ final String label = aa[selectedRow].label;
+ MenuItem hideType = new MenuItem(
+ MessageManager.getString("label.hide_all") + " " + label);
+ hideType.addActionListener(new ActionListener()
+ {
+ @Override
+ public void actionPerformed(ActionEvent e)
+ {
+ AlignmentUtils.showOrHideSequenceAnnotations(
+ ap.av.getAlignment(), Collections.singleton(label),
+ null, false, false);
+ refresh();
+ }
+ });
+ popup.add(hideType);
+ }
+ }
+
if (hasHiddenRows)
{
item = new MenuItem(SHOWALL);
*/
package jalview.appletgui;
-import jalview.analysis.AlignmentUtils;
-import jalview.bin.JalviewLite;
-import jalview.datamodel.Alignment;
-import jalview.datamodel.AlignmentI;
-import jalview.datamodel.PDBEntry;
-import jalview.datamodel.Sequence;
-import jalview.io.AnnotationFile;
-import jalview.io.AppletFormatAdapter;
-import jalview.io.IdentifyFile;
-import jalview.io.NewickFile;
-import jalview.io.TCoffeeScoreFile;
-import jalview.schemes.TCoffeeColourScheme;
-import jalview.util.MessageManager;
-
import java.awt.BorderLayout;
import java.awt.Button;
import java.awt.Dialog;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
+import jalview.analysis.AlignmentUtils;
+import jalview.bin.JalviewLite;
+import jalview.datamodel.Alignment;
+import jalview.datamodel.AlignmentI;
+import jalview.datamodel.PDBEntry;
+import jalview.datamodel.SequenceI;
+import jalview.io.AnnotationFile;
+import jalview.io.AppletFormatAdapter;
+import jalview.io.IdentifyFile;
+import jalview.io.NewickFile;
+import jalview.io.TCoffeeScoreFile;
+import jalview.schemes.TCoffeeColourScheme;
+import jalview.util.MessageManager;
+
public class CutAndPasteTransfer extends Panel implements ActionListener,
MouseListener
{
boolean annotationImport = false;
- Sequence seq;
+ SequenceI seq;
AlignFrame alignFrame;
textarea.setText(text);
}
- public void setPDBImport(Sequence seq)
+ public void setPDBImport(SequenceI seq)
{
this.seq = seq;
accept.setLabel(MessageManager.getString("action.accept"));
if (alignFrame.alignPanel.av.applet.jmolAvailable)
{
- new jalview.appletgui.AppletJmol(pdb, new Sequence[]
+ new jalview.appletgui.AppletJmol(pdb, new SequenceI[]
{ seq }, null, alignFrame.alignPanel, AppletFormatAdapter.PASTE);
}
else
{
- new MCview.AppletPDBViewer(pdb, new Sequence[]
+ new MCview.AppletPDBViewer(pdb, new SequenceI[]
{ seq }, null, alignFrame.alignPanel, AppletFormatAdapter.PASTE);
}
}
*/
package jalview.appletgui;
+import java.awt.BorderLayout;
+import java.awt.Font;
+import java.awt.FontMetrics;
+import java.awt.Panel;
+import java.awt.Point;
+import java.awt.event.InputEvent;
+import java.awt.event.MouseEvent;
+import java.awt.event.MouseListener;
+import java.awt.event.MouseMotionListener;
+import java.util.List;
+import java.util.Vector;
+
import jalview.api.AlignViewportI;
import jalview.commands.EditCommand;
import jalview.commands.EditCommand.Action;
import jalview.util.MappingUtils;
import jalview.util.MessageManager;
-import java.awt.BorderLayout;
-import java.awt.Font;
-import java.awt.FontMetrics;
-import java.awt.Panel;
-import java.awt.Point;
-import java.awt.event.InputEvent;
-import java.awt.event.MouseEvent;
-import java.awt.event.MouseListener;
-import java.awt.event.MouseMotionListener;
-import java.util.List;
-import java.util.Vector;
-
public class SeqPanel extends Panel implements MouseMotionListener,
MouseListener, SequenceListener, SelectionListener
{
SequenceFeature[] allFeatures = findFeaturesAtRes(sequence,
sequence.findPosition(res));
- Vector links = null;
+ Vector<String> links = null;
if (allFeatures != null)
{
for (int i = 0; i < allFeatures.length; i++)
{
if (links == null)
{
- links = new Vector();
+ links = new Vector<String>();
}
for (int j = 0; j < allFeatures[i].links.size(); j++)
{
*/
package jalview.datamodel;
-import java.util.*;
+import java.util.Hashtable;
+import java.util.Vector;
/**
* DOCUMENT ME!
public Hashtable otherDetails;
- public java.util.Vector links;
+ public Vector<String> links;
// Feature group can be set from a features file
// as a group of features between STARTGROUP and ENDGROUP markers
}
if (cpy.links != null && cpy.links.size() > 0)
{
- links = new Vector();
+ links = new Vector<String>();
for (int i = 0, iSize = cpy.links.size(); i < iSize; i++)
{
links.addElement(cpy.links.elementAt(i));
{
if (links == null)
{
- links = new java.util.Vector();
+ links = new Vector<String>();
}
links.insertElementAt(labelLink, 0);
{
String stat = (String) otherDetails.get("status");
if (stat != null)
+ {
return new String(stat);
+ }
}
return null;
}
*/
package jalview.gui;
+import java.awt.BorderLayout;
+import java.awt.Component;
+import java.awt.GridLayout;
+import java.awt.Rectangle;
+import java.awt.Toolkit;
+import java.awt.datatransfer.Clipboard;
+import java.awt.datatransfer.DataFlavor;
+import java.awt.datatransfer.StringSelection;
+import java.awt.datatransfer.Transferable;
+import java.awt.dnd.DnDConstants;
+import java.awt.dnd.DropTargetDragEvent;
+import java.awt.dnd.DropTargetDropEvent;
+import java.awt.dnd.DropTargetEvent;
+import java.awt.dnd.DropTargetListener;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.ItemEvent;
+import java.awt.event.ItemListener;
+import java.awt.event.KeyAdapter;
+import java.awt.event.KeyEvent;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+import java.awt.print.PageFormat;
+import java.awt.print.PrinterJob;
+import java.beans.PropertyChangeEvent;
+import java.io.File;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Deque;
+import java.util.Enumeration;
+import java.util.Hashtable;
+import java.util.List;
+import java.util.Set;
+import java.util.Vector;
+
+import javax.swing.JButton;
+import javax.swing.JCheckBoxMenuItem;
+import javax.swing.JEditorPane;
+import javax.swing.JInternalFrame;
+import javax.swing.JLabel;
+import javax.swing.JLayeredPane;
+import javax.swing.JMenu;
+import javax.swing.JMenuItem;
+import javax.swing.JOptionPane;
+import javax.swing.JPanel;
+import javax.swing.JProgressBar;
+import javax.swing.JRadioButtonMenuItem;
+import javax.swing.JScrollPane;
+import javax.swing.SwingUtilities;
+
import jalview.analysis.AAFrequency;
import jalview.analysis.AlignmentSorter;
import jalview.analysis.AlignmentUtils;
import jalview.ws.jws2.jabaws2.Jws2Instance;
import jalview.ws.seqfetcher.DbSourceProxy;
-import java.awt.BorderLayout;
-import java.awt.Component;
-import java.awt.GridLayout;
-import java.awt.Rectangle;
-import java.awt.Toolkit;
-import java.awt.datatransfer.Clipboard;
-import java.awt.datatransfer.DataFlavor;
-import java.awt.datatransfer.StringSelection;
-import java.awt.datatransfer.Transferable;
-import java.awt.dnd.DnDConstants;
-import java.awt.dnd.DropTargetDragEvent;
-import java.awt.dnd.DropTargetDropEvent;
-import java.awt.dnd.DropTargetEvent;
-import java.awt.dnd.DropTargetListener;
-import java.awt.event.ActionEvent;
-import java.awt.event.ActionListener;
-import java.awt.event.ItemEvent;
-import java.awt.event.ItemListener;
-import java.awt.event.KeyAdapter;
-import java.awt.event.KeyEvent;
-import java.awt.event.MouseAdapter;
-import java.awt.event.MouseEvent;
-import java.awt.print.PageFormat;
-import java.awt.print.PrinterJob;
-import java.beans.PropertyChangeEvent;
-import java.io.File;
-import java.net.URL;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Deque;
-import java.util.Enumeration;
-import java.util.Hashtable;
-import java.util.List;
-import java.util.Set;
-import java.util.Vector;
-
-import javax.swing.JButton;
-import javax.swing.JCheckBoxMenuItem;
-import javax.swing.JEditorPane;
-import javax.swing.JInternalFrame;
-import javax.swing.JLabel;
-import javax.swing.JLayeredPane;
-import javax.swing.JMenu;
-import javax.swing.JMenuItem;
-import javax.swing.JOptionPane;
-import javax.swing.JPanel;
-import javax.swing.JProgressBar;
-import javax.swing.JRadioButtonMenuItem;
-import javax.swing.JScrollPane;
-import javax.swing.SwingUtilities;
-
/**
* DOCUMENT ME!
*
* DOCUMENT ME!
*/
@Override
- protected void LoadtreeMenuItem_actionPerformed(ActionEvent e)
+ protected void loadTreeMenuItem_actionPerformed(ActionEvent e)
{
// Pick the tree file
JalviewFileChooser chooser = new JalviewFileChooser(
*/
package jalview.gui;
+import java.awt.Container;
+import java.awt.Dimension;
+import java.awt.Font;
+import java.awt.Rectangle;
+import java.util.ArrayList;
+import java.util.Hashtable;
+import java.util.Set;
+import java.util.Vector;
+
+import javax.swing.JInternalFrame;
+import javax.swing.JOptionPane;
+
import jalview.analysis.AlignmentUtils;
import jalview.analysis.AnnotationSorter.SequenceAnnotationOrder;
import jalview.analysis.NJTree;
import jalview.viewmodel.AlignmentViewport;
import jalview.ws.params.AutoCalcSetting;
-import java.awt.Container;
-import java.awt.Dimension;
-import java.awt.Font;
-import java.awt.Rectangle;
-import java.util.ArrayList;
-import java.util.Hashtable;
-import java.util.Set;
-import java.util.Vector;
-
-import javax.swing.JInternalFrame;
-import javax.swing.JOptionPane;
-
/**
* DOCUMENT ME!
*
int endSeq;
-
- SequenceAnnotationOrder sortAnnotationsBy = null;
-
Font font;
NJTree currentTree = null;
private Hashtable<String, AutoCalcSetting> calcIdParams = new Hashtable<String, AutoCalcSetting>();
- private boolean showAutocalculatedAbove;
-
public AutoCalcSetting getCalcIdSettingsFor(String calcId)
{
return calcIdParams.get(calcId);
}
}
- protected SequenceAnnotationOrder getSortAnnotationsBy()
- {
- return sortAnnotationsBy;
- }
-
- protected void setSortAnnotationsBy(SequenceAnnotationOrder sortAnnotationsBy)
- {
- this.sortAnnotationsBy = sortAnnotationsBy;
- }
-
- protected boolean isShowAutocalculatedAbove()
- {
- return showAutocalculatedAbove;
- }
-
- protected void setShowAutocalculatedAbove(boolean showAutocalculatedAbove)
- {
- this.showAutocalculatedAbove = showAutocalculatedAbove;
- }
-
/**
* Method called when another alignment's edit (or possibly other) command is
* broadcast to here.
*/
package jalview.gui;
-import jalview.datamodel.Alignment;
-import jalview.datamodel.AlignmentAnnotation;
-import jalview.datamodel.Annotation;
-import jalview.datamodel.Sequence;
-import jalview.datamodel.SequenceGroup;
-import jalview.datamodel.SequenceI;
-import jalview.io.FormatAdapter;
-import jalview.util.MessageManager;
-
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.image.BufferedImage;
import java.util.ArrayList;
import java.util.Arrays;
+import java.util.Collections;
import java.util.regex.Pattern;
import javax.swing.JCheckBoxMenuItem;
import javax.swing.SwingUtilities;
import javax.swing.ToolTipManager;
+import jalview.analysis.AlignmentUtils;
+import jalview.datamodel.Alignment;
+import jalview.datamodel.AlignmentAnnotation;
+import jalview.datamodel.Annotation;
+import jalview.datamodel.Sequence;
+import jalview.datamodel.SequenceGroup;
+import jalview.datamodel.SequenceI;
+import jalview.io.FormatAdapter;
+import jalview.util.MessageManager;
+
/**
* DOCUMENT ME!
*
item.addActionListener(this);
pop.add(item);
// JAL-1264 hide all sequence-specific annotations of this type
- final String label = aa[selectedRow].label;
if (selectedRow < aa.length)
{
if (aa[selectedRow].sequenceRef != null)
{
+ final String label = aa[selectedRow].label;
JMenuItem hideType = new JMenuItem();
String text = MessageManager.getString("label.hide_all") + " " + label;
hideType.setText(text);
@Override
public void actionPerformed(ActionEvent e)
{
- for (AlignmentAnnotation ann : ap.av.getAlignment()
- .getAlignmentAnnotation())
- {
- if (ann.sequenceRef != null && ann.label != null
- && ann.label.equals(label))
- {
- ann.visible = false;
- }
- }
+ AlignmentUtils.showOrHideSequenceAnnotations(
+ ap.av.getAlignment(), Collections.singleton(label),
+ null, false, false);
+ // for (AlignmentAnnotation ann : ap.av.getAlignment()
+ // .getAlignmentAnnotation())
+ // {
+ // if (ann.sequenceRef != null && ann.label != null
+ // && ann.label.equals(label))
+ // {
+ // ann.visible = false;
+ // }
+ // }
refresh();
}
});
// property methods
if (selectedRow < aa.length)
{
+ final String label = aa[selectedRow].label;
if (!aa[selectedRow].autoCalculated)
{
if (aa[selectedRow].graph == AlignmentAnnotation.NO_GRAPH)
import java.awt.Color;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
-import java.util.ArrayList;
import java.util.Arrays;
-import java.util.Collection;
import java.util.Collections;
import java.util.Hashtable;
import java.util.LinkedHashMap;
import jalview.analysis.AAFrequency;
import jalview.analysis.AlignmentAnnotationUtils;
+import jalview.analysis.AlignmentUtils;
import jalview.analysis.Conservation;
import jalview.commands.ChangeCaseCommand;
import jalview.commands.EditCommand;
JMenu seqHideAnnotationsMenu = new JMenu();
- JMenuItem seqAddReferenceAnnotations = new JMenuItem();
+ JMenuItem seqAddReferenceAnnotations = new JMenuItem(
+ MessageManager.getString("label.add_reference_annotations"));
JMenu groupShowAnnotationsMenu = new JMenu();
JMenu groupHideAnnotationsMenu = new JMenu();
- JMenuItem groupAddReferenceAnnotations = new JMenuItem();
+ JMenuItem groupAddReferenceAnnotations = new JMenuItem(
+ MessageManager.getString("label.add_reference_annotations"));
JMenuItem sequenceFeature = new JMenuItem();
final boolean actionIsShow)
{
String label = types.toString(); // [a, b, c]
- label = label.substring(1, label.length() - 1);
+ label = label.substring(1, label.length() - 1); // a, b, c
final JMenuItem item = new JMenuItem(label);
item.setToolTipText(calcId);
item.addActionListener(new java.awt.event.ActionListener()
@Override
public void actionPerformed(ActionEvent e)
{
- showHideAnnotation_actionPerformed(types, forSequences, allTypes,
- actionIsShow);
+ AlignmentUtils.showOrHideSequenceAnnotations(ap.getAlignment(), types,
+ forSequences, allTypes, actionIsShow);
+ refresh();
}
});
showOrHideMenu.add(item);
}
- /**
- * Action on selecting a list of annotation type (or the 'all types' values)
- * to show or hide for the specified sequences.
- *
- * @param types
- * @param forSequences
- * @param anyType
- * @param doShow
- */
- protected void showHideAnnotation_actionPerformed(
- Collection<String> types, List<SequenceI> forSequences,
- boolean anyType, boolean doShow)
- {
- for (AlignmentAnnotation aa : ap.getAlignment()
- .getAlignmentAnnotation())
- {
- if (anyType || types.contains(aa.label))
- {
- if ((aa.sequenceRef != null)
- && forSequences.contains(aa.sequenceRef))
- {
- aa.visible = doShow;
- }
- }
- }
- refresh();
- }
-
private void buildGroupURLMenu(SequenceGroup sg, Vector groupLinks)
{
protected void configureReferenceAnnotationsMenu(
JMenuItem menuItem, List<SequenceI> forSequences)
{
- menuItem.setText(MessageManager
- .getString("label.add_reference_annotations"));
menuItem.setEnabled(false);
- if (forSequences == null)
- {
- return;
- }
/*
* Temporary store to hold distinct calcId / type pairs for the tooltip.
* Using TreeMap means calcIds are shown in alphabetical order.
*/
Map<String, String> tipEntries = new TreeMap<String, String>();
- StringBuilder tooltip = new StringBuilder(64);
- tooltip.append(MessageManager.getString("label.add_annotations_for"));
-
- /*
- * For each sequence selected in the alignment, make a list of any
- * annotations on the underlying dataset sequence which are not already on
- * the alignment.
- *
- * Build a map of { alignmentSequence, <List of annotations to add> }
- */
- AlignmentI al = this.ap.av.getAlignment();
final Map<SequenceI, List<AlignmentAnnotation>> candidates = new LinkedHashMap<SequenceI, List<AlignmentAnnotation>>();
- for (SequenceI seq : forSequences)
- {
- SequenceI dataset = seq.getDatasetSequence();
- if (dataset == null)
- {
- continue;
- }
- AlignmentAnnotation[] datasetAnnotations = dataset.getAnnotation();
- if (datasetAnnotations == null)
- {
- continue;
- }
- final List<AlignmentAnnotation> result = new ArrayList<AlignmentAnnotation>();
- for (AlignmentAnnotation dsann : datasetAnnotations)
- {
- /*
- * Find matching annotations on the alignment.
- */
- final Iterable<AlignmentAnnotation> matchedAlignmentAnnotations = al
- .findAnnotations(seq, dsann.getCalcId(),
- dsann.label);
- if (!matchedAlignmentAnnotations.iterator().hasNext())
- {
- result.add(dsann);
- tipEntries.put(dsann.getCalcId(), dsann.label);
- }
- }
- /*
- * Save any addable annotations for this sequence
- */
- if (!result.isEmpty())
- {
- candidates.put(seq, result);
- }
- }
+ AlignmentI al = this.ap.av.getAlignment();
+ AlignmentUtils.findAddableReferenceAnnotations(forSequences,
+ tipEntries, candidates, al);
if (!candidates.isEmpty())
{
+ StringBuilder tooltip = new StringBuilder(64);
+ tooltip.append(MessageManager.getString("label.add_annotations_for"));
+
/*
* Found annotations that could be added. Enable the menu item, and
* configure its tooltip and action.
protected void addReferenceAnnotations_actionPerformed(
Map<SequenceI, List<AlignmentAnnotation>> candidates)
{
- /*
- * Add annotations at the top of the annotation, in the same order as their
- * related sequences.
- */
- for (SequenceI seq : candidates.keySet())
- {
- for (AlignmentAnnotation ann : candidates.get(seq))
- {
- AlignmentAnnotation copyAnn = new AlignmentAnnotation(ann);
- int startRes = 0;
- int endRes = ann.annotations.length;
- final SequenceGroup selectionGroup = this.ap.av.getSelectionGroup();
- if (selectionGroup != null)
- {
- startRes = selectionGroup.getStartRes();
- endRes = selectionGroup.getEndRes();
- }
- copyAnn.restrict(startRes, endRes);
-
- /*
- * Add to the sequence (sets copyAnn.datasetSequence), unless the
- * original annotation is already on the sequence.
- */
- if (!seq.hasAnnotation(ann))
- {
- seq.addAlignmentAnnotation(copyAnn);
- }
- // adjust for gaps
- copyAnn.adjustForAlignment();
- // add to the alignment and set visible
- this.ap.getAlignment().addAnnotation(copyAnn);
- copyAnn.visible = true;
- }
- }
+ final SequenceGroup selectionGroup = this.ap.av.getSelectionGroup();
+ final AlignmentI alignment = this.ap.getAlignment();
+ AlignmentUtils.addReferenceAnnotations(candidates, alignment,
+ selectionGroup);
refresh();
}
*/
package jalview.jbgui;
-import jalview.analysis.AnnotationSorter.SequenceAnnotationOrder;
-import jalview.api.SplitContainerI;
-import jalview.bin.Cache;
-import jalview.gui.JvSwingUtils;
-import jalview.gui.Preferences;
-import jalview.schemes.ColourSchemeProperty;
-import jalview.util.MessageManager;
-
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.GridLayout;
import javax.swing.event.MenuEvent;
import javax.swing.event.MenuListener;
+import jalview.analysis.AnnotationSorter.SequenceAnnotationOrder;
+import jalview.api.SplitContainerI;
+import jalview.bin.Cache;
+import jalview.gui.JvSwingUtils;
+import jalview.gui.Preferences;
+import jalview.schemes.ColourSchemeProperty;
+import jalview.util.MessageManager;
+
public class GAlignFrame extends JInternalFrame
{
protected JMenuBar alignFrameMenuBar = new JMenuBar();
- protected JMenu fileMenu = new JMenu();
-
protected JMenuItem closeMenuItem = new JMenuItem();
- protected JMenu editMenu = new JMenu();
-
- protected JMenu viewMenu = new JMenu();
-
- protected JMenu annotationsMenu = new JMenu();
-
protected JMenu colourMenu = new JMenu();
- protected JMenu calculateMenu = new JMenu();
-
protected JMenu webService = new JMenu();
protected JMenuItem webServiceNoServices;
- protected JMenuItem selectAllSequenceMenuItem = new JMenuItem();
-
- protected JMenuItem deselectAllSequenceMenuItem = new JMenuItem();
-
- protected JMenuItem invertSequenceMenuItem = new JMenuItem();
-
- protected JMenuItem remove2LeftMenuItem = new JMenuItem();
-
- protected JMenuItem remove2RightMenuItem = new JMenuItem();
-
- protected JMenuItem removeGappedColumnMenuItem = new JMenuItem();
-
- protected JMenuItem removeAllGapsMenuItem = new JMenuItem();
-
public JCheckBoxMenuItem viewBoxesMenuItem = new JCheckBoxMenuItem();
public JCheckBoxMenuItem viewTextMenuItem = new JCheckBoxMenuItem();
- protected JMenuItem sortPairwiseMenuItem = new JMenuItem();
-
- protected JMenuItem sortIDMenuItem = new JMenuItem();
-
- protected JMenuItem sortLengthMenuItem = new JMenuItem();
-
- protected JMenuItem sortGroupMenuItem = new JMenuItem();
-
protected JMenu sortByAnnotScore = new JMenu();
- protected JMenuItem removeRedundancyMenuItem = new JMenuItem();
-
- protected JMenuItem pairwiseAlignmentMenuItem = new JMenuItem();
-
- protected JMenuItem PCAMenuItem = new JMenuItem();
-
- protected JMenuItem averageDistanceTreeMenuItem = new JMenuItem();
-
- protected JMenuItem neighbourTreeMenuItem = new JMenuItem();
-
- BorderLayout borderLayout1 = new BorderLayout();
-
public JLabel statusBar = new JLabel();
- protected JMenuItem saveAs = new JMenuItem();
-
protected JMenu outputTextboxMenu = new JMenu();
protected JRadioButtonMenuItem clustalColour = new JRadioButtonMenuItem();
protected JRadioButtonMenuItem tcoffeeColour = new JRadioButtonMenuItem();
- JMenuItem njTreeBlosumMenuItem = new JMenuItem();
-
- JMenuItem avDistanceTreeBlosumMenuItem = new JMenuItem();
-
public JCheckBoxMenuItem annotationPanelMenuItem = new JCheckBoxMenuItem();
public JCheckBoxMenuItem colourTextMenuItem = new JCheckBoxMenuItem();
public JCheckBoxMenuItem showNonconservedMenuItem = new JCheckBoxMenuItem();
- JMenuItem htmlMenuItem = new JMenuItem();
-
- JMenuItem overviewMenuItem = new JMenuItem();
-
protected JMenuItem undoMenuItem = new JMenuItem();
protected JMenuItem redoMenuItem = new JMenuItem();
public JCheckBoxMenuItem wrapMenuItem = new JCheckBoxMenuItem();
- JMenuItem printMenuItem = new JMenuItem();
-
public JCheckBoxMenuItem renderGapsMenuItem = new JCheckBoxMenuItem();
- JMenuItem findMenuItem = new JMenuItem();
-
public JCheckBoxMenuItem abovePIDThreshold = new JCheckBoxMenuItem();
public JCheckBoxMenuItem showSeqFeatures = new JCheckBoxMenuItem();
public JCheckBoxMenuItem showSeqFeaturesHeight = new JCheckBoxMenuItem();
- JMenuItem deleteGroups = new JMenuItem();
-
- JMenuItem createGroup = new JMenuItem();
-
- JMenuItem unGroup = new JMenuItem();
-
- JMenuItem delete = new JMenuItem();
-
JMenuItem copy = new JMenuItem();
JMenuItem cut = new JMenuItem();
JMenu pasteMenu = new JMenu();
- JMenuItem pasteNew = new JMenuItem();
-
- JMenuItem pasteThis = new JMenuItem();
-
public JCheckBoxMenuItem applyToAllGroups = new JCheckBoxMenuItem();
- JMenuItem createPNG = new JMenuItem();
-
- JMenuItem createBioJS = new JMenuItem();
-
- JMenuItem createSVG = new JMenuItem();
-
- protected JMenuItem font = new JMenuItem();
-
public JCheckBoxMenuItem seqLimits = new JCheckBoxMenuItem();
- JMenuItem epsFile = new JMenuItem();
-
- JMenuItem LoadtreeMenuItem = new JMenuItem();
-
public JCheckBoxMenuItem scaleAbove = new JCheckBoxMenuItem();
public JCheckBoxMenuItem scaleLeft = new JCheckBoxMenuItem();
public JCheckBoxMenuItem scaleRight = new JCheckBoxMenuItem();
- protected JMenuItem modifyPID = new JMenuItem();
-
protected JMenuItem modifyConservation = new JMenuItem();
protected JMenu sortByTreeMenu = new JMenu();
protected JMenu calculateTree = new JMenu();
- JMenu jMenu2 = new JMenu();
-
protected JCheckBoxMenuItem padGapsMenuitem = new JCheckBoxMenuItem();
protected JCheckBoxMenuItem showNpFeatsMenuitem = new JCheckBoxMenuItem();
protected ButtonGroup colours = new ButtonGroup();
- JMenuItem vamsasStore = new JMenuItem();
-
protected JMenuItem showTranslation = new JMenuItem();
- protected JMenuItem extractScores = new JMenuItem();
-
- protected JMenuItem expandAlignment = new JMenuItem();
-
protected JMenu showProducts = new JMenu();
- public JMenuItem openFeatureSettings = new JMenuItem();
-
- JMenuItem fetchSequence = new JMenuItem();
-
- JMenuItem annotationColour = new JMenuItem();
-
- JMenuItem annotationColumn = new JMenuItem();
-
protected JMenuItem rnahelicesColour = new JMenuItem();
- JMenuItem associatedData = new JMenuItem();
-
protected JCheckBoxMenuItem autoCalculate = new JCheckBoxMenuItem();
protected JCheckBoxMenuItem sortByTree = new JCheckBoxMenuItem();
protected JCheckBoxMenuItem listenToViewSelections = new JCheckBoxMenuItem();
- JMenu addSequenceMenu = new JMenu();
-
- JMenuItem addFromFile = new JMenuItem();
-
- JMenuItem addFromText = new JMenuItem();
-
- JMenuItem addFromURL = new JMenuItem();
-
- JMenuItem exportAnnotations = new JMenuItem();
-
- JMenuItem exportFeatures = new JMenuItem();
-
protected JPanel statusPanel = new JPanel();
- GridLayout gridLayout1 = new GridLayout();
-
- JMenu showMenu = new JMenu();
-
- JMenuItem showAllSeqs = new JMenuItem();
-
- JMenuItem showAllColumns = new JMenuItem();
-
- JMenu hideMenu = new JMenu();
-
- JMenuItem hideSelSequences = new JMenuItem();
-
- JMenuItem hideSelColumns = new JMenuItem();
-
- JMenuItem hideAllButSelection = new JMenuItem();
-
- JMenuItem hideAllSelection = new JMenuItem();
-
- JMenuItem showAllhidden = new JMenuItem();
-
protected JMenuItem showAllSeqAnnotations = new JMenuItem();
protected JMenuItem hideAllSeqAnnotations = new JMenuItem();
protected JCheckBoxMenuItem showComplementMenuItem = new JCheckBoxMenuItem();
- protected JCheckBoxMenuItem sortAnnBySequence = new JCheckBoxMenuItem();
-
- protected JCheckBoxMenuItem sortAnnByLabel = new JCheckBoxMenuItem();
-
protected JCheckBoxMenuItem hiddenMarkers = new JCheckBoxMenuItem();
- JMenuItem invertColSel = new JMenuItem();
-
protected JTabbedPane tabbedPane = new JTabbedPane();
- JMenuItem save = new JMenuItem();
-
protected JMenuItem reload = new JMenuItem();
- JMenuItem newView = new JMenuItem();
-
- JMenuItem textColour = new JMenuItem();
-
protected JMenu formatMenu = new JMenu();
- JMenu selectMenu = new JMenu();
-
protected JCheckBoxMenuItem idRightAlign = new JCheckBoxMenuItem();
protected JCheckBoxMenuItem centreColumnLabelsMenuItem = new JCheckBoxMenuItem();
protected JMenuItem expandViews = new JMenuItem();
- JMenuItem pageSetup = new JMenuItem();
-
- JMenuItem alignmentProperties = new JMenuItem();
-
- JMenu tooltipSettingsMenu = new JMenu();
-
- private JMenuItem justifyLeftMenuItem = new JMenuItem();
-
- private JMenuItem justifyRightMenuItem = new JMenuItem();
-
- JMenu autoAnnMenu = new JMenu();
-
protected JCheckBoxMenuItem showGroupConsensus = new JCheckBoxMenuItem();
protected JCheckBoxMenuItem showGroupConservation = new JCheckBoxMenuItem();
protected JCheckBoxMenuItem applyAutoAnnotationSettings = new JCheckBoxMenuItem();
- protected JRadioButtonMenuItem showAutoFirst = new JRadioButtonMenuItem();
-
- protected JRadioButtonMenuItem showAutoLast = new JRadioButtonMenuItem();
-
- private JMenuItem grpsFromSelection = new JMenuItem();
-
private SequenceAnnotationOrder annotationSortOrder;
private boolean showAutoCalculatedAbove = false;
private void jbInit() throws Exception
{
- fileMenu.setText(MessageManager.getString("action.file"));
-
- saveAs.setText(MessageManager.getString("action.save_as") + "...");
+ JMenuItem saveAs = new JMenuItem(
+ MessageManager.getString("action.save_as") + "...");
ActionListener al = new ActionListener()
{
@Override
};
addMenuActionAndAccelerator(keyStroke, closeMenuItem, al);
- editMenu.setText(MessageManager.getString("action.edit"));
- viewMenu.setText(MessageManager.getString("action.view"));
- annotationsMenu.setText(MessageManager.getString("action.annotations"));
+ JMenu editMenu = new JMenu(MessageManager.getString("action.edit"));
+ JMenu viewMenu = new JMenu(MessageManager.getString("action.view"));
+ JMenu annotationsMenu = new JMenu(
+ MessageManager.getString("action.annotations"));
+ JMenu showMenu = new JMenu(MessageManager.getString("action.show"));
colourMenu.setText(MessageManager.getString("action.colour"));
- calculateMenu.setText(MessageManager.getString("action.calculate"));
+ JMenu calculateMenu = new JMenu(
+ MessageManager.getString("action.calculate"));
webService.setText(MessageManager.getString("action.web_service"));
-
- selectAllSequenceMenuItem.setText(MessageManager
+ JMenuItem selectAllSequenceMenuItem = new JMenuItem(
+ MessageManager
.getString("action.select_all"));
keyStroke = KeyStroke.getKeyStroke(KeyEvent.VK_A, Toolkit
.getDefaultToolkit().getMenuShortcutKeyMask(), false);
};
addMenuActionAndAccelerator(keyStroke, selectAllSequenceMenuItem, al);
- deselectAllSequenceMenuItem.setText(MessageManager
- .getString("action.deselect_all"));
+ JMenuItem deselectAllSequenceMenuItem = new JMenuItem(
+ MessageManager.getString("action.deselect_all"));
keyStroke = KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE, 0, false);
al = new ActionListener()
{
};
addMenuActionAndAccelerator(keyStroke, deselectAllSequenceMenuItem, al);
- invertSequenceMenuItem.setText(MessageManager
- .getString("action.invert_sequence_selection"));
+ JMenuItem invertSequenceMenuItem = new JMenuItem(
+ MessageManager.getString("action.invert_sequence_selection"));
keyStroke = KeyStroke.getKeyStroke(KeyEvent.VK_I, Toolkit
.getDefaultToolkit().getMenuShortcutKeyMask(), false);
al = new ActionListener()
};
addMenuActionAndAccelerator(keyStroke, invertSequenceMenuItem, al);
- grpsFromSelection.setText(MessageManager
- .getString("action.make_groups_selection"));
+ JMenuItem grpsFromSelection = new JMenuItem(
+ MessageManager.getString("action.make_groups_selection"));
grpsFromSelection.addActionListener(new ActionListener()
{
@Override
makeGrpsFromSelection_actionPerformed(e);
}
});
- expandAlignment.setText(MessageManager
- .getString("action.view_flanking_regions"));
+ JMenuItem expandAlignment = new JMenuItem(
+ MessageManager.getString("action.view_flanking_regions"));
expandAlignment.setToolTipText(MessageManager
.getString("label.view_flanking_regions"));
expandAlignment.addActionListener(new ActionListener()
expand_newalign(e);
}
});
- remove2LeftMenuItem.setText(MessageManager
- .getString("action.remove_left"));
+ JMenuItem remove2LeftMenuItem = new JMenuItem(
+ MessageManager.getString("action.remove_left"));
keyStroke = KeyStroke.getKeyStroke(KeyEvent.VK_L, Toolkit
.getDefaultToolkit().getMenuShortcutKeyMask(), false);
al = new ActionListener()
};
addMenuActionAndAccelerator(keyStroke, remove2LeftMenuItem, al);
- remove2RightMenuItem.setText(MessageManager
- .getString("action.remove_right"));
+ JMenuItem remove2RightMenuItem = new JMenuItem(
+ MessageManager.getString("action.remove_right"));
keyStroke = KeyStroke.getKeyStroke(KeyEvent.VK_R, Toolkit
.getDefaultToolkit().getMenuShortcutKeyMask(), false);
al = new ActionListener()
};
addMenuActionAndAccelerator(keyStroke, remove2RightMenuItem, al);
- removeGappedColumnMenuItem.setText(MessageManager
- .getString("action.remove_empty_columns"));
+ JMenuItem removeGappedColumnMenuItem = new JMenuItem(
+ MessageManager.getString("action.remove_empty_columns"));
keyStroke = KeyStroke.getKeyStroke(KeyEvent.VK_E, Toolkit
.getDefaultToolkit().getMenuShortcutKeyMask(), false);
al = new ActionListener()
};
addMenuActionAndAccelerator(keyStroke, removeGappedColumnMenuItem, al);
- removeAllGapsMenuItem.setText(MessageManager
- .getString("action.remove_all_gaps"));
+ JMenuItem removeAllGapsMenuItem = new JMenuItem(
+ MessageManager.getString("action.remove_all_gaps"));
keyStroke = KeyStroke.getKeyStroke(KeyEvent.VK_E, Toolkit
.getDefaultToolkit().getMenuShortcutKeyMask()
| KeyEvent.SHIFT_MASK, false);
};
addMenuActionAndAccelerator(keyStroke, removeAllGapsMenuItem, al);
- justifyLeftMenuItem.setText(MessageManager
- .getString("action.left_justify_alignment"));
+ JMenuItem justifyLeftMenuItem = new JMenuItem(
+ MessageManager.getString("action.left_justify_alignment"));
justifyLeftMenuItem.addActionListener(new ActionListener()
{
@Override
justifyLeftMenuItem_actionPerformed(e);
}
});
- justifyRightMenuItem.setText(MessageManager
- .getString("action.right_justify_alignment"));
+ JMenuItem justifyRightMenuItem = new JMenuItem(
+ MessageManager.getString("action.right_justify_alignment"));
justifyRightMenuItem.addActionListener(new ActionListener()
{
@Override
showUnconservedMenuItem_actionPerformed(e);
}
});
- sortPairwiseMenuItem.setText(MessageManager
- .getString("action.by_pairwise_id"));
+ JMenuItem sortPairwiseMenuItem = new JMenuItem(
+ MessageManager.getString("action.by_pairwise_id"));
sortPairwiseMenuItem.addActionListener(new ActionListener()
{
@Override
sortPairwiseMenuItem_actionPerformed(e);
}
});
- sortIDMenuItem.setText(MessageManager.getString("action.by_id"));
+ JMenuItem sortIDMenuItem = new JMenuItem(
+ MessageManager.getString("action.by_id"));
sortIDMenuItem.addActionListener(new ActionListener()
{
@Override
sortIDMenuItem_actionPerformed(e);
}
});
- sortLengthMenuItem
- .setText(MessageManager.getString("action.by_length"));
+ JMenuItem sortLengthMenuItem = new JMenuItem(
+ MessageManager.getString("action.by_length"));
sortLengthMenuItem.addActionListener(new ActionListener()
{
@Override
sortLengthMenuItem_actionPerformed(e);
}
});
- sortGroupMenuItem.setText(MessageManager.getString("action.by_group"));
+ JMenuItem sortGroupMenuItem = new JMenuItem(
+ MessageManager.getString("action.by_group"));
sortGroupMenuItem.addActionListener(new ActionListener()
{
@Override
}
});
- removeRedundancyMenuItem.setText(MessageManager.getString(
- "action.remove_redundancy").concat("..."));
+ JMenuItem removeRedundancyMenuItem = new JMenuItem(MessageManager
+ .getString("action.remove_redundancy").concat("..."));
keyStroke = KeyStroke.getKeyStroke(KeyEvent.VK_D, Toolkit
.getDefaultToolkit().getMenuShortcutKeyMask(), false);
al = new ActionListener()
};
addMenuActionAndAccelerator(keyStroke, removeRedundancyMenuItem, al);
- pairwiseAlignmentMenuItem.setText(MessageManager
- .getString("action.pairwise_alignment"));
+ JMenuItem pairwiseAlignmentMenuItem = new JMenuItem(
+ MessageManager.getString("action.pairwise_alignment"));
pairwiseAlignmentMenuItem.addActionListener(new ActionListener()
{
@Override
pairwiseAlignmentMenuItem_actionPerformed(e);
}
});
- PCAMenuItem.setText(MessageManager
- .getString("label.principal_component_analysis"));
+ JMenuItem PCAMenuItem = new JMenuItem(
+ MessageManager.getString("label.principal_component_analysis"));
PCAMenuItem.addActionListener(new ActionListener()
{
@Override
PCAMenuItem_actionPerformed(e);
}
});
- averageDistanceTreeMenuItem.setText(MessageManager
- .getString("label.average_distance_identity"));
+ JMenuItem averageDistanceTreeMenuItem = new JMenuItem(
+ MessageManager.getString("label.average_distance_identity"));
averageDistanceTreeMenuItem.addActionListener(new ActionListener()
{
@Override
averageDistanceTreeMenuItem_actionPerformed(e);
}
});
- neighbourTreeMenuItem.setText(MessageManager
- .getString("label.neighbour_joining_identity"));
+ JMenuItem neighbourTreeMenuItem = new JMenuItem(
+ MessageManager.getString("label.neighbour_joining_identity"));
neighbourTreeMenuItem.addActionListener(new ActionListener()
{
@Override
neighbourTreeMenuItem_actionPerformed(e);
}
});
- this.getContentPane().setLayout(borderLayout1);
+
+ this.getContentPane().setLayout(new BorderLayout());
alignFrameMenuBar.setFont(new java.awt.Font("Verdana", 0, 11));
statusBar.setBackground(Color.white);
statusBar.setFont(new java.awt.Font("Verdana", 0, 11));
outputTextboxMenu.setText(MessageManager
.getString("label.out_to_textbox"));
clustalColour.setText(MessageManager.getString("label.clustalx"));
-
clustalColour.addActionListener(new ActionListener()
{
@Override
* });
*/
- avDistanceTreeBlosumMenuItem.setText(MessageManager
- .getString("label.average_distance_bloslum62"));
+ JMenuItem avDistanceTreeBlosumMenuItem = new JMenuItem(
+ MessageManager.getString("label.average_distance_bloslum62"));
avDistanceTreeBlosumMenuItem.addActionListener(new ActionListener()
{
@Override
avTreeBlosumMenuItem_actionPerformed(e);
}
});
- njTreeBlosumMenuItem.setText(MessageManager
- .getString("label.neighbour_blosum62"));
+ JMenuItem njTreeBlosumMenuItem = new JMenuItem(
+ MessageManager.getString("label.neighbour_blosum62"));
njTreeBlosumMenuItem.addActionListener(new ActionListener()
{
@Override
SequenceAnnotationOrder sortAnnotationsBy = SequenceAnnotationOrder
.valueOf(Cache.getDefault(Preferences.SORT_ANNOTATIONS,
SequenceAnnotationOrder.NONE.name()));
- sortAnnBySequence.setText(MessageManager
- .getString("label.sort_annotations_by_sequence"));
+ final JCheckBoxMenuItem sortAnnBySequence = new JCheckBoxMenuItem(
+ MessageManager.getString("label.sort_annotations_by_sequence"));
+ final JCheckBoxMenuItem sortAnnByLabel = new JCheckBoxMenuItem(
+ MessageManager.getString("label.sort_annotations_by_label"));
+
sortAnnBySequence
.setSelected(sortAnnotationsBy == SequenceAnnotationOrder.SEQUENCE_AND_LABEL);
sortAnnBySequence.addActionListener(new ActionListener()
sortAnnotations_actionPerformed();
}
});
- sortAnnByLabel.setText(MessageManager
- .getString("label.sort_annotations_by_label"));
sortAnnByLabel
.setSelected(sortAnnotationsBy == SequenceAnnotationOrder.LABEL_AND_SEQUENCE);
sortAnnByLabel.addActionListener(new ActionListener()
colourTextMenuItem_actionPerformed(e);
}
});
- htmlMenuItem.setText(MessageManager.getString("label.html"));
+
+ JMenuItem htmlMenuItem = new JMenuItem(
+ MessageManager.getString("label.html"));
htmlMenuItem.addActionListener(new ActionListener()
{
@Override
}
});
- // TODO uncomment when supported by MassageManager
- // createBioJS.setText(MessageManager.getString("label.biojs_html_export"));
- createBioJS.setText("BioJS");
+ JMenuItem createBioJS = new JMenuItem(
+ MessageManager.getString("label.biojs_html_export"));
createBioJS.addActionListener(new java.awt.event.ActionListener()
{
@Override
}
});
- overviewMenuItem.setText(MessageManager
- .getString("label.overview_window"));
+ JMenuItem overviewMenuItem = new JMenuItem(
+ MessageManager.getString("label.overview_window"));
overviewMenuItem.addActionListener(new ActionListener()
{
@Override
}
});
- printMenuItem.setText(MessageManager.getString("action.print") + "...");
+ JMenuItem printMenuItem = new JMenuItem(
+ MessageManager.getString("action.print") + "...");
keyStroke = KeyStroke.getKeyStroke(KeyEvent.VK_P, Toolkit
.getDefaultToolkit().getMenuShortcutKeyMask(), false);
al = new ActionListener()
}
});
- findMenuItem.setText(MessageManager.getString("action.find"));
+ JMenuItem findMenuItem = new JMenuItem(
+ MessageManager.getString("action.find"));
keyStroke = KeyStroke.getKeyStroke(KeyEvent.VK_F, Toolkit
.getDefaultToolkit().getMenuShortcutKeyMask(), false);
findMenuItem.setToolTipText(JvSwingUtils.wrapTooltip(true,
});
ButtonGroup buttonGroup = new ButtonGroup();
+ final JRadioButtonMenuItem showAutoFirst = new JRadioButtonMenuItem(
+ MessageManager.getString("label.show_first"));
+ final JRadioButtonMenuItem showAutoLast = new JRadioButtonMenuItem(
+ MessageManager.getString("label.show_last"));
buttonGroup.add(showAutoFirst);
buttonGroup.add(showAutoLast);
- showAutoFirst.setText(MessageManager.getString("label.show_first"));
showAutoFirst.setSelected(Cache.getDefault(
Preferences.SHOW_AUTOCALC_ABOVE, false));
showAutoFirst.addActionListener(new ActionListener()
sortAnnotations_actionPerformed();
}
});
- showAutoLast.setText(MessageManager.getString("label.show_last"));
showAutoLast.setSelected(!showAutoFirst.isSelected());
showAutoLast.addActionListener(new ActionListener()
{
}
});
- deleteGroups
- .setText(MessageManager.getString("action.undefine_groups"));
+ JMenuItem deleteGroups = new JMenuItem(
+ MessageManager.getString("action.undefine_groups"));
keyStroke = KeyStroke.getKeyStroke(KeyEvent.VK_U, Toolkit
.getDefaultToolkit().getMenuShortcutKeyMask(), false);
al = new ActionListener()
};
addMenuActionAndAccelerator(keyStroke, deleteGroups, al);
- createGroup.setText(MessageManager.getString("action.create_groups"));
+ JMenuItem createGroup = new JMenuItem(
+ MessageManager.getString("action.create_groups"));
keyStroke = KeyStroke.getKeyStroke(KeyEvent.VK_G, Toolkit
.getDefaultToolkit().getMenuShortcutKeyMask(), false);
al = new ActionListener()
};
addMenuActionAndAccelerator(keyStroke, createGroup, al);
- unGroup.setText(MessageManager.getString("action.remove_group"));
+ JMenuItem unGroup = new JMenuItem(
+ MessageManager.getString("action.remove_group"));
keyStroke = KeyStroke.getKeyStroke(KeyEvent.VK_G, Toolkit
.getDefaultToolkit().getMenuShortcutKeyMask()
| KeyEvent.SHIFT_MASK, false);
};
addMenuActionAndAccelerator(keyStroke, cut, al);
- delete.setText(MessageManager.getString("action.delete"));
+ JMenuItem delete = new JMenuItem(
+ MessageManager.getString("action.delete"));
delete.addActionListener(new ActionListener()
{
@Override
});
pasteMenu.setText(MessageManager.getString("action.paste"));
- pasteNew.setText(MessageManager.getString("label.to_new_alignment"));
+ JMenuItem pasteNew = new JMenuItem(
+ MessageManager.getString("label.to_new_alignment"));
keyStroke = KeyStroke.getKeyStroke(KeyEvent.VK_V, Toolkit
.getDefaultToolkit().getMenuShortcutKeyMask()
| KeyEvent.SHIFT_MASK, false);
};
addMenuActionAndAccelerator(keyStroke, pasteNew, al);
- pasteThis.setText(MessageManager.getString("label.to_this_alignment"));
+ JMenuItem pasteThis = new JMenuItem(
+ MessageManager.getString("label.to_this_alignment"));
keyStroke = KeyStroke.getKeyStroke(KeyEvent.VK_V, Toolkit
.getDefaultToolkit().getMenuShortcutKeyMask(), false);
al = new ActionListener()
applyToAllGroups_actionPerformed(e);
}
});
+ JMenuItem createPNG = new JMenuItem("PNG");
createPNG.addActionListener(new ActionListener()
{
@Override
});
createPNG.setActionCommand(MessageManager
.getString("label.save_png_image"));
- createPNG.setText("PNG");
- font.setText(MessageManager.getString("action.font"));
+ JMenuItem font = new JMenuItem(MessageManager.getString("action.font"));
font.addActionListener(new ActionListener()
{
@Override
seqLimit_actionPerformed(e);
}
});
- epsFile.setText("EPS");
+ JMenuItem epsFile = new JMenuItem("EPS");
epsFile.addActionListener(new ActionListener()
{
@Override
}
});
- createSVG.setText("SVG");
+ JMenuItem createSVG = new JMenuItem("SVG");
createSVG.addActionListener(new ActionListener()
{
@Override
}
});
- LoadtreeMenuItem.setActionCommand(MessageManager
+ JMenuItem loadTreeMenuItem = new JMenuItem(
+ MessageManager.getString("label.load_associated_tree"));
+ loadTreeMenuItem.setActionCommand(MessageManager
.getString("label.load_tree_for_sequence_set"));
- LoadtreeMenuItem.setText(MessageManager
- .getString("label.load_associated_tree"));
- LoadtreeMenuItem.addActionListener(new ActionListener()
+ loadTreeMenuItem.addActionListener(new ActionListener()
{
@Override
public void actionPerformed(ActionEvent e)
{
- LoadtreeMenuItem_actionPerformed(e);
+ loadTreeMenuItem_actionPerformed(e);
}
});
});
- modifyPID.setText(MessageManager
- .getString("label.modify_identity_thereshold"));
+ JMenuItem modifyPID = new JMenuItem(
+ MessageManager.getString("label.modify_identity_thereshold"));
modifyPID.addActionListener(new ActionListener()
{
@Override
calculateTree
.setText(MessageManager.getString("action.calculate_tree"));
- jMenu2.setText(MessageManager.getString("label.export_image"));
padGapsMenuitem.setText(MessageManager.getString("label.pad_gaps"));
padGapsMenuitem.setState(jalview.bin.Cache
.getDefault("PAD_GAPS", false));
padGapsMenuitem_actionPerformed(e);
}
});
+ JMenuItem vamsasStore = new JMenuItem(
+ MessageManager.getString("label.vamsas_store"));
vamsasStore.setVisible(false);
- vamsasStore.setText(MessageManager.getString("label.vamsas_store"));
vamsasStore.addActionListener(new ActionListener()
{
@Override
}
});
- extractScores.setText(MessageManager.getString("label.extract_scores")
- + "...");
+ JMenuItem extractScores = new JMenuItem(
+ MessageManager.getString("label.extract_scores") + "...");
extractScores.addActionListener(new ActionListener()
{
@Override
// for show products actions see AlignFrame.canShowProducts
showProducts.setText(MessageManager.getString("label.get_cross_refs"));
- openFeatureSettings.setText(MessageManager
- .getString("label.feature_settings"));
+
+ JMenuItem openFeatureSettings = new JMenuItem(
+ MessageManager.getString("label.feature_settings"));
openFeatureSettings.addActionListener(new ActionListener()
{
@Override
featureSettings_actionPerformed(e);
}
});
- fetchSequence
- .setText(MessageManager.getString("label.fetch_sequences"));
+ JMenuItem fetchSequence = new JMenuItem(
+ MessageManager.getString("label.fetch_sequences"));
fetchSequence.addActionListener(new ActionListener()
{
@Override
}
});
- annotationColour.setText(MessageManager
- .getString("action.by_annotation"));
+ JMenuItem annotationColour = new JMenuItem(
+ MessageManager.getString("action.by_annotation"));
annotationColour.addActionListener(new ActionListener()
{
@Override
}
});
- annotationColumn.setText(MessageManager
- .getString("action.select_by_annotation"));
+ JMenuItem annotationColumn = new JMenuItem(
+ MessageManager.getString("action.select_by_annotation"));
annotationColumn.addActionListener(new ActionListener()
{
@Override
}
});
- associatedData.setText(MessageManager
- .getString("label.load_features_annotations"));
+ JMenuItem associatedData = new JMenuItem(
+ MessageManager.getString("label.load_features_annotations"));
associatedData.addActionListener(new ActionListener()
{
@Override
}
});
- addSequenceMenu
- .setText(MessageManager.getString("label.add_sequences"));
- addFromFile.setText(MessageManager.getString("label.from_file"));
+ JMenu addSequenceMenu = new JMenu(
+ MessageManager.getString("label.add_sequences"));
+ JMenuItem addFromFile = new JMenuItem(
+ MessageManager.getString("label.from_file"));
addFromFile.addActionListener(new ActionListener()
{
@Override
addFromFile_actionPerformed(e);
}
});
- addFromText.setText(MessageManager.getString("label.from_textbox"));
+ JMenuItem addFromText = new JMenuItem(
+ MessageManager.getString("label.from_textbox"));
addFromText.addActionListener(new ActionListener()
{
@Override
addFromText_actionPerformed(e);
}
});
- addFromURL.setText(MessageManager.getString("label.from_url"));
+ JMenuItem addFromURL = new JMenuItem(
+ MessageManager.getString("label.from_url"));
addFromURL.addActionListener(new ActionListener()
{
@Override
addFromURL_actionPerformed(e);
}
});
- exportFeatures.setText(MessageManager
- .getString("label.export_features"));
+ JMenuItem exportFeatures = new JMenuItem(
+ MessageManager.getString("label.export_features"));
exportFeatures.addActionListener(new ActionListener()
{
@Override
exportFeatures_actionPerformed(e);
}
});
- exportAnnotations.setText(MessageManager
- .getString("label.export_annotations"));
+ JMenuItem exportAnnotations = new JMenuItem(
+ MessageManager.getString("label.export_annotations"));
exportAnnotations.addActionListener(new ActionListener()
{
@Override
exportAnnotations_actionPerformed(e);
}
});
- statusPanel.setLayout(gridLayout1);
- showMenu.setText(MessageManager.getString("action.show"));
- showAllSeqs.setText(MessageManager.getString("label.all_sequences"));
+ statusPanel.setLayout(new GridLayout());
+ JMenuItem showAllSeqs = new JMenuItem(
+ MessageManager.getString("label.all_sequences"));
showAllSeqs.setToolTipText(MessageManager
.getString("label.toggle_sequence_visibility"));
showAllSeqs.addActionListener(new ActionListener()
showAllSeqs_actionPerformed(e);
}
});
- showAllColumns.setText(MessageManager.getString("label.all_columns"));
+ JMenuItem showAllColumns = new JMenuItem(
+ MessageManager.getString("label.all_columns"));
showAllColumns.setToolTipText(MessageManager
.getString("label.toggle_columns_visibility"));
showAllColumns.addActionListener(new ActionListener()
showAllColumns_actionPerformed(e);
}
});
- hideMenu.setText(MessageManager.getString("action.hide"));
- hideSelSequences.setText(MessageManager
- .getString("label.selected_sequences"));
+ JMenu hideMenu = new JMenu(MessageManager.getString("action.hide"));
+ JMenuItem hideSelSequences = new JMenuItem(
+ MessageManager.getString("label.selected_sequences"));
hideSelSequences.setToolTipText(MessageManager
.getString("label.toggle_sequence_visibility"));
hideSelSequences.addActionListener(new ActionListener()
hideSelSequences_actionPerformed(e);
}
});
- hideSelColumns.setText(MessageManager
- .getString("label.selected_columns"));
+ JMenuItem hideSelColumns = new JMenuItem(
+ MessageManager.getString("label.selected_columns"));
hideSelColumns.setToolTipText(MessageManager
.getString("label.toggle_columns_visibility"));
hideSelColumns.addActionListener(new ActionListener()
hideSelColumns_actionPerformed(e);
}
});
- hideAllSelection.setText(MessageManager
- .getString("label.selected_region"));
+ JMenuItem hideAllSelection = new JMenuItem(
+ MessageManager.getString("label.selected_region"));
hideAllSelection.addActionListener(new ActionListener()
{
@Override
}
});
// TODO: should be hidden if no selection exists.
- hideAllButSelection.setText(MessageManager
- .getString("label.all_but_selected_region"));
+ JMenuItem hideAllButSelection = new JMenuItem(
+ MessageManager.getString("label.all_but_selected_region"));
hideAllButSelection.addActionListener(new ActionListener()
{
@Override
hideAllButSelection_actionPerformed(e);
}
});
- showAllhidden.setText(MessageManager
- .getString("label.all_sequences_columns"));
+ JMenuItem showAllhidden = new JMenuItem(
+ MessageManager.getString("label.all_sequences_columns"));
showAllhidden.setToolTipText(MessageManager
.getString("label.toggles_visibility_hidden_selected_regions"));
showAllhidden.addActionListener(new ActionListener()
}
});
- invertColSel.setText(MessageManager
- .getString("action.invert_column_selection"));
+ JMenuItem invertColSel = new JMenuItem(
+ MessageManager.getString("action.invert_column_selection"));
keyStroke = KeyStroke.getKeyStroke(KeyEvent.VK_I,
Toolkit.getDefaultToolkit().getMenuShortcutKeyMask()
| KeyEvent.ALT_MASK, false);
}
});
- save.setText(MessageManager.getString("action.save"));
+ JMenuItem save = new JMenuItem(MessageManager.getString("action.save"));
keyStroke = KeyStroke.getKeyStroke(KeyEvent.VK_S, Toolkit
.getDefaultToolkit().getMenuShortcutKeyMask(), false);
al = new ActionListener()
}
});
- newView.setText(MessageManager.getString("action.new_view"));
+ JMenuItem newView = new JMenuItem(
+ MessageManager.getString("action.new_view"));
keyStroke = KeyStroke.getKeyStroke(KeyEvent.VK_T, Toolkit
.getDefaultToolkit().getMenuShortcutKeyMask(), false);
al = new ActionListener()
tabbedPane.setToolTipText("<html><i>"
+ MessageManager.getString("label.rename_tab_eXpand_reGroup")
+ "</i></html>");
- textColour.setText(MessageManager.getString("label.colour_text")
- + "...");
+ JMenuItem textColour = new JMenuItem(
+ MessageManager.getString("label.colour_text") + "...");
textColour.addActionListener(new ActionListener()
{
@Override
}
});
formatMenu.setText(MessageManager.getString("action.format"));
- selectMenu.setText(MessageManager.getString("action.select"));
+ JMenu selectMenu = new JMenu(MessageManager.getString("action.select"));
idRightAlign.setText(MessageManager
.getString("label.right_align_sequence_id"));
idRightAlign.addActionListener(new ActionListener()
};
addMenuActionAndAccelerator(keyStroke, expandViews, al);
- pageSetup
- .setText(MessageManager.getString("action.page_setup") + "...");
+ JMenuItem pageSetup = new JMenuItem(
+ MessageManager.getString("action.page_setup") + "...");
pageSetup.addActionListener(new ActionListener()
{
@Override
pageSetup_actionPerformed(e);
}
});
- alignmentProperties.setText(MessageManager
- .getString("label.alignment_props") + "...");
+ JMenuItem alignmentProperties = new JMenuItem(
+ MessageManager.getString("label.alignment_props") + "...");
alignmentProperties.addActionListener(new ActionListener()
{
@Override
alignmentProperties();
}
});
- tooltipSettingsMenu.setText(MessageManager
- .getString("label.sequence_id_tooltip"));
- autoAnnMenu.setText(MessageManager
- .getString("label.autocalculated_annotation"));
+ JMenu tooltipSettingsMenu = new JMenu(
+ MessageManager.getString("label.sequence_id_tooltip"));
+ JMenu autoAnnMenu = new JMenu(
+ MessageManager.getString("label.autocalculated_annotation"));
+
+ JMenu exportImageMenu = new JMenu(
+ MessageManager.getString("label.export_image"));
+ JMenu fileMenu = new JMenu(MessageManager.getString("action.file"));
alignFrameMenuBar.add(fileMenu);
alignFrameMenuBar.add(editMenu);
alignFrameMenuBar.add(selectMenu);
fileMenu.add(pageSetup);
fileMenu.add(printMenuItem);
fileMenu.addSeparator();
- fileMenu.add(jMenu2);
+ fileMenu.add(exportImageMenu);
fileMenu.add(exportFeatures);
fileMenu.add(exportAnnotations);
- fileMenu.add(LoadtreeMenuItem);
+ fileMenu.add(loadTreeMenuItem);
fileMenu.add(associatedData);
fileMenu.addSeparator();
fileMenu.add(closeMenuItem);
// editMenu.add(justifyRightMenuItem);
// editMenu.addSeparator();
editMenu.add(padGapsMenuitem);
+
viewMenu.add(newView);
viewMenu.add(expandViews);
viewMenu.add(gatherViews);
viewMenu.add(showComplementMenuItem);
viewMenu.addSeparator();
viewMenu.add(followHighlightMenuItem);
+ viewMenu.addSeparator();
+ viewMenu.add(showSeqFeatures);
+ // viewMenu.add(showSeqFeaturesHeight);
+ viewMenu.add(openFeatureSettings);
+ tooltipSettingsMenu.add(showDbRefsMenuitem);
+ tooltipSettingsMenu.add(showNpFeatsMenuitem);
+ viewMenu.add(tooltipSettingsMenu);
+ viewMenu.addSeparator();
+ viewMenu.add(alignmentProperties);
+ viewMenu.addSeparator();
+ viewMenu.add(overviewMenuItem);
+
annotationsMenu.add(annotationPanelMenuItem);
annotationsMenu.addSeparator();
annotationsMenu.add(showAllAlAnnotations);
autoAnnMenu.add(showGroupConservation);
autoAnnMenu.add(showGroupConsensus);
annotationsMenu.add(autoAnnMenu);
- viewMenu.addSeparator();
- viewMenu.add(showSeqFeatures);
- // viewMenu.add(showSeqFeaturesHeight);
- viewMenu.add(openFeatureSettings);
- tooltipSettingsMenu.add(showDbRefsMenuitem);
- tooltipSettingsMenu.add(showNpFeatsMenuitem);
- viewMenu.add(tooltipSettingsMenu);
- viewMenu.addSeparator();
- viewMenu.add(alignmentProperties);
- viewMenu.addSeparator();
- viewMenu.add(overviewMenuItem);
colourMenu.add(applyToAllGroups);
colourMenu.add(textColour);
colourMenu.addSeparator();
sort.add(sortGroupMenuItem);
sort.add(sortPairwiseMenuItem);
sort.add(sortByTreeMenu);
- jMenu2.add(htmlMenuItem);
- jMenu2.add(epsFile);
- jMenu2.add(createPNG);
- jMenu2.add(createBioJS);
- jMenu2.add(createSVG);
+ exportImageMenu.add(htmlMenuItem);
+ exportImageMenu.add(epsFile);
+ exportImageMenu.add(createPNG);
+ exportImageMenu.add(createBioJS);
+ exportImageMenu.add(createSVG);
addSequenceMenu.add(addFromFile);
addSequenceMenu.add(addFromText);
addSequenceMenu.add(addFromURL);
{
}
- protected void LoadtreeMenuItem_actionPerformed(ActionEvent e)
+ protected void loadTreeMenuItem_actionPerformed(ActionEvent e)
{
}
*/
package jalview.viewmodel;
+import java.awt.Color;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.BitSet;
+import java.util.Deque;
+import java.util.HashMap;
+import java.util.Hashtable;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import jalview.analysis.AnnotationSorter.SequenceAnnotationOrder;
import jalview.analysis.Conservation;
import jalview.api.AlignCalcManagerI;
import jalview.api.AlignViewportI;
import jalview.workers.ConsensusThread;
import jalview.workers.StrucConsensusThread;
-import java.awt.Color;
-import java.util.ArrayDeque;
-import java.util.ArrayList;
-import java.util.BitSet;
-import java.util.Deque;
-import java.util.HashMap;
-import java.util.Hashtable;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
/**
* base class holding visualization and analysis attributes and common logic for
* an active alignment view displayed in the GUI
private Map<SequenceI, Color> sequenceColours = new HashMap<SequenceI, Color>();
+ protected SequenceAnnotationOrder sortAnnotationsBy = null;
+
+ protected boolean showAutocalculatedAbove;
+
/**
* Property change listener for changes in alignment
*
{
return this;
}
+
+ public SequenceAnnotationOrder getSortAnnotationsBy()
+ {
+ return sortAnnotationsBy;
+ }
+
+ public void setSortAnnotationsBy(SequenceAnnotationOrder sortAnnotationsBy)
+ {
+ this.sortAnnotationsBy = sortAnnotationsBy;
+ }
+
+ public boolean isShowAutocalculatedAbove()
+ {
+ return showAutocalculatedAbove;
+ }
+
+ public void setShowAutocalculatedAbove(boolean showAutocalculatedAbove)
+ {
+ this.showAutocalculatedAbove = showAutocalculatedAbove;
+ }
}
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+import org.junit.Test;
+
import jalview.datamodel.AlignedCodonFrame;
import jalview.datamodel.Alignment;
+import jalview.datamodel.AlignmentAnnotation;
import jalview.datamodel.AlignmentI;
+import jalview.datamodel.Annotation;
import jalview.datamodel.DBRefEntry;
import jalview.datamodel.Mapping;
import jalview.datamodel.Sequence;
import jalview.io.FormatAdapter;
import jalview.util.MapList;
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-import java.util.Map;
-
-import org.junit.Test;
-
public class AlignmentUtilsTests
{
// @formatter:off
assertEquals(cdna.getSequenceAt(0).getDatasetSequence(),
acf.getdnaSeqs()[0]);
}
+
+ /**
+ * Test the method that shows or hides sequence annotations by type(s) and
+ * selection group.
+ */
+ @Test
+ public void testShowOrHideSequenceAnnotations()
+ {
+ SequenceI seq1 = new Sequence("Seq1", "AAA");
+ SequenceI seq2 = new Sequence("Seq2", "BBB");
+ SequenceI seq3 = new Sequence("Seq3", "CCC");
+ Annotation[] anns = new Annotation[]
+ { new Annotation(2f) };
+ AlignmentAnnotation ann1 = new AlignmentAnnotation("Structure", "ann1",
+ anns);
+ ann1.setSequenceRef(seq1);
+ AlignmentAnnotation ann2 = new AlignmentAnnotation("Structure", "ann2",
+ anns);
+ ann2.setSequenceRef(seq2);
+ AlignmentAnnotation ann3 = new AlignmentAnnotation("Structure", "ann3",
+ anns);
+ AlignmentAnnotation ann4 = new AlignmentAnnotation("Temp", "ann4", anns);
+ ann4.setSequenceRef(seq1);
+ AlignmentAnnotation ann5 = new AlignmentAnnotation("Temp", "ann5", anns);
+ ann5.setSequenceRef(seq2);
+ AlignmentAnnotation ann6 = new AlignmentAnnotation("Temp", "ann6", anns);
+ AlignmentI al = new Alignment(new SequenceI[] {seq1, seq2, seq3});
+ al.addAnnotation(ann1); // Structure for Seq1
+ al.addAnnotation(ann2); // Structure for Seq2
+ al.addAnnotation(ann3); // Structure for no sequence
+ al.addAnnotation(ann4); // Temp for seq1
+ al.addAnnotation(ann5); // Temp for seq2
+ al.addAnnotation(ann6); // Temp for no sequence
+ List<String> types = new ArrayList<String>();
+ List<SequenceI> scope = new ArrayList<SequenceI>();
+
+ /*
+ * Set all sequence related Structure to hidden (ann1, ann2)
+ */
+ types.add("Structure");
+ AlignmentUtils.showOrHideSequenceAnnotations(al, types, null, false,
+ false);
+ assertFalse(ann1.visible);
+ assertFalse(ann2.visible);
+ assertTrue(ann3.visible); // not sequence-related, not affected
+ assertTrue(ann4.visible); // not Structure, not affected
+ assertTrue(ann5.visible); // "
+ assertTrue(ann6.visible); // not sequence-related, not affected
+
+ /*
+ * Set Temp in {seq1, seq3} to hidden
+ */
+ types.clear();
+ types.add("Temp");
+ scope.add(seq1);
+ scope.add(seq3);
+ AlignmentUtils.showOrHideSequenceAnnotations(al, types, scope, false,
+ false);
+ assertFalse(ann1.visible); // unchanged
+ assertFalse(ann2.visible); // unchanged
+ assertTrue(ann3.visible); // not sequence-related, not affected
+ assertFalse(ann4.visible); // Temp for seq1 hidden
+ assertTrue(ann5.visible); // not in scope, not affected
+ assertTrue(ann6.visible); // not sequence-related, not affected
+
+ /*
+ * Set Temp in all sequences to hidden
+ */
+ types.clear();
+ types.add("Temp");
+ scope.add(seq1);
+ scope.add(seq3);
+ AlignmentUtils.showOrHideSequenceAnnotations(al, types, null, false,
+ false);
+ assertFalse(ann1.visible); // unchanged
+ assertFalse(ann2.visible); // unchanged
+ assertTrue(ann3.visible); // not sequence-related, not affected
+ assertFalse(ann4.visible); // Temp for seq1 hidden
+ assertFalse(ann5.visible); // Temp for seq2 hidden
+ assertTrue(ann6.visible); // not sequence-related, not affected
+
+ /*
+ * Set all types in {seq1, seq3} to visible
+ */
+ types.clear();
+ scope.clear();
+ scope.add(seq1);
+ scope.add(seq3);
+ AlignmentUtils.showOrHideSequenceAnnotations(al, types, scope, true,
+ true);
+ assertTrue(ann1.visible); // Structure for seq1 set visible
+ assertFalse(ann2.visible); // not in scope, unchanged
+ assertTrue(ann3.visible); // not sequence-related, not affected
+ assertTrue(ann4.visible); // Temp for seq1 set visible
+ assertFalse(ann5.visible); // not in scope, unchanged
+ assertTrue(ann6.visible); // not sequence-related, not affected
+
+ /*
+ * Set all types in all scope to hidden
+ */
+ AlignmentUtils.showOrHideSequenceAnnotations(al, types, null, true,
+ false);
+ assertFalse(ann1.visible);
+ assertFalse(ann2.visible);
+ assertTrue(ann3.visible); // not sequence-related, not affected
+ assertFalse(ann4.visible);
+ assertFalse(ann5.visible);
+ assertTrue(ann6.visible); // not sequence-related, not affected
+ }
}
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
-import jalview.datamodel.AlignmentAnnotation;
-import jalview.datamodel.AlignmentI;
-import jalview.datamodel.SequenceI;
-import jalview.io.AppletFormatAdapter;
-import jalview.io.FormatAdapter;
-import jalview.util.MessageManager;
import java.awt.Component;
import java.io.IOException;
import org.junit.Before;
import org.junit.Test;
+import jalview.datamodel.AlignmentAnnotation;
+import jalview.datamodel.AlignmentI;
+import jalview.datamodel.SequenceI;
+import jalview.io.AppletFormatAdapter;
+import jalview.io.FormatAdapter;
+
public class PopupMenuTest
{
// 4 sequences x 13 positions
List<SequenceI> seqs = new ArrayList<SequenceI>();
testee.configureReferenceAnnotationsMenu(menu, seqs);
assertFalse(menu.isEnabled());
- assertEquals(
- MessageManager.getString("label.add_reference_annotations"),
- menu.getText());
// now try null list
menu.setEnabled(true);
- testee.configureReferenceAnnotationsMenu(menu, seqs);
+ testee.configureReferenceAnnotationsMenu(menu, null);
assertFalse(menu.isEnabled());
}
git://source.jalview.org / jalview.git / commitdiff