X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fcontroller%2FAlignViewController.java;h=443433134510475fc17e9ed5d4ee045d4f62f35b;hb=41fe43633ee3cc43a45a356176689731ff73ba67;hp=fce9da21f0d24795b13002214d84048d972f0bcd;hpb=c19d2a91ca05e052e3408bf5852d88eb5d0608f1;p=jalview.git diff --git a/src/jalview/controller/AlignViewController.java b/src/jalview/controller/AlignViewController.java index fce9da2..4434331 100644 --- a/src/jalview/controller/AlignViewController.java +++ b/src/jalview/controller/AlignViewController.java @@ -1,6 +1,6 @@ /* - * Jalview - A Sequence Alignment Editor and Viewer (Version 2.9.0b2) - * Copyright (C) 2015 The Jalview Authors + * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$) + * Copyright (C) $$Year-Rel$$ The Jalview Authors * * This file is part of Jalview. * @@ -20,6 +20,10 @@ */ package jalview.controller; +import java.awt.Color; +import java.util.BitSet; +import java.util.List; + import jalview.analysis.AlignmentSorter; import jalview.api.AlignViewControllerGuiI; import jalview.api.AlignViewControllerI; @@ -29,18 +33,17 @@ import jalview.api.FeatureRenderer; import jalview.commands.OrderCommand; import jalview.datamodel.AlignmentI; import jalview.datamodel.ColumnSelection; +import jalview.datamodel.SearchResultsI; import jalview.datamodel.SequenceCollectionI; import jalview.datamodel.SequenceFeature; import jalview.datamodel.SequenceGroup; import jalview.datamodel.SequenceI; +import jalview.gui.Desktop; +import jalview.io.DataSourceType; import jalview.io.FeaturesFile; +import jalview.schemes.ColourSchemeI; import jalview.util.MessageManager; -import java.awt.Color; -import java.util.ArrayList; -import java.util.BitSet; -import java.util.List; - public class AlignViewController implements AlignViewControllerI { AlignViewportI viewport = null; @@ -52,29 +55,20 @@ public class AlignViewController implements AlignViewControllerI */ private AlignViewControllerGuiI avcg; - @Override - protected void finalize() throws Throwable - { - viewport = null; - alignPanel = null; - avcg = null; - }; - public AlignViewController(AlignViewControllerGuiI alignFrame, - AlignViewportI viewport, AlignmentViewPanel alignPanel) + AlignViewportI vp, AlignmentViewPanel ap) { this.avcg = alignFrame; - this.viewport = viewport; - this.alignPanel = alignPanel; + this.viewport = vp; + this.alignPanel = ap; } @Override - public void setViewportAndAlignmentPanel(AlignViewportI viewport, - AlignmentViewPanel alignPanel) + public void setViewportAndAlignmentPanel(AlignViewportI vp, + AlignmentViewPanel ap) { - this.alignPanel = alignPanel; - this.viewport = viewport; - + this.alignPanel = ap; + this.viewport = vp; } @Override @@ -83,13 +77,13 @@ public class AlignViewController implements AlignViewControllerI SequenceGroup sg = viewport.getSelectionGroup(); ColumnSelection cs = viewport.getColumnSelection(); SequenceGroup[] gps = null; - if (sg != null - && (cs == null || cs.getSelected() == null || cs.size() == 0)) + if (sg != null && (cs == null || cs.isEmpty())) { - gps = jalview.analysis.Grouping.makeGroupsFrom(viewport - .getSequenceSelection(), viewport.getAlignmentView(true) - .getSequenceStrings(viewport.getGapCharacter()), viewport - .getAlignment().getGroups()); + gps = jalview.analysis.Grouping.makeGroupsFrom( + viewport.getSequenceSelection(), + viewport.getAlignmentView(true) + .getSequenceStrings(viewport.getGapCharacter()), + viewport.getAlignment().getGroups()); } else { @@ -97,8 +91,8 @@ public class AlignViewController implements AlignViewControllerI { gps = jalview.analysis.Grouping.makeGroupsFromCols( (sg == null) ? viewport.getAlignment().getSequencesArray() - : sg.getSequences().toArray(new SequenceI[0]), cs, - viewport.getAlignment().getGroups()); + : sg.getSequences().toArray(new SequenceI[0]), + cs, viewport.getAlignment().getGroups()); } } if (gps != null) @@ -106,19 +100,22 @@ public class AlignViewController implements AlignViewControllerI viewport.getAlignment().deleteAllGroups(); viewport.clearSequenceColours(); viewport.setSelectionGroup(null); + ColourSchemeI colours = viewport.getGlobalColourScheme(); // set view properties for each group for (int g = 0; g < gps.length; g++) { // gps[g].setShowunconserved(viewport.getShowUnconserved()); gps[g].setshowSequenceLogo(viewport.isShowSequenceLogo()); viewport.getAlignment().addGroup(gps[g]); - Color col = new Color((int) (Math.random() * 255), - (int) (Math.random() * 255), (int) (Math.random() * 255)); - col = col.brighter(); - for (SequenceI sq : gps[g].getSequences(null)) + if (colours != null) { - viewport.setSequenceColour(sq, col); + gps[g].setColourScheme(colours.getInstance(viewport, gps[g])); } + Color col = new Color((int) (Math.random() * 255), + (int) (Math.random() * 255), (int) (Math.random() * 255)); + gps[g].idColour = col; + viewport.setUpdateStructures(true); + viewport.addSequenceGroup(gps[g]); } return true; } @@ -171,193 +168,184 @@ public class AlignViewController implements AlignViewControllerI // JBPNote this routine could also mark rows, not just columns. // need a decent query structure to allow all types of feature searches BitSet bs = new BitSet(); - int alw, alStart; - SequenceCollectionI sqcol = (viewport.getSelectionGroup() == null ? viewport - .getAlignment() : viewport.getSelectionGroup()); - alStart = sqcol.getStartRes(); - alw = sqcol.getEndRes() + 1; + boolean searchSelection = viewport.getSelectionGroup() != null + && !extendCurrent; + SequenceCollectionI sqcol = searchSelection + ? viewport.getSelectionGroup() + : viewport.getAlignment(); + + int nseq = findColumnsWithFeature(featureType, sqcol, bs); + + ColumnSelection cs = viewport.getColumnSelection(); + if (cs == null) + { + cs = new ColumnSelection(); + } + + if (bs.cardinality() > 0 || invert) + { + boolean changed = cs.markColumns(bs, sqcol.getStartRes(), + sqcol.getEndRes(), invert, extendCurrent, toggle); + if (changed) + { + viewport.setColumnSelection(cs); + alignPanel.paintAlignment(false, false); + int columnCount = invert + ? (sqcol.getEndRes() - sqcol.getStartRes() + 1) + - bs.cardinality() + : bs.cardinality(); + avcg.setStatus(MessageManager.formatMessage( + "label.view_controller_toggled_marked", new String[] + { toggle ? MessageManager.getString("label.toggled") + : MessageManager.getString("label.marked"), + String.valueOf(columnCount), + invert ? MessageManager + .getString("label.not_containing") + : MessageManager.getString("label.containing"), + featureType, Integer.valueOf(nseq).toString() })); + return true; + } + } + else + { + String key = searchSelection ? "label.no_feature_found_selection" + : "label.no_feature_of_type_found"; + avcg.setStatus( + MessageManager.formatMessage(key, new String[] + { featureType })); + if (!extendCurrent) + { + cs.clear(); + alignPanel.paintAlignment(false, false); + } + } + return false; + } + + /** + * Sets a bit in the BitSet for each column (base 0) in the sequence + * collection which includes a visible feature of the specified feature type. + * Returns the number of sequences which have the feature visible in the + * selected range. + * + * @param featureType + * @param sqcol + * @param bs + * @return + */ + int findColumnsWithFeature(String featureType, SequenceCollectionI sqcol, + BitSet bs) + { + FeatureRenderer fr = alignPanel == null ? null + : alignPanel.getFeatureRenderer(); + + final int startColumn = sqcol.getStartRes() + 1; // converted to base 1 + final int endColumn = sqcol.getEndRes() + 1; List seqs = sqcol.getSequences(); int nseq = 0; for (SequenceI sq : seqs) { - int tfeat = 0; if (sq != null) { - SequenceFeature[] sf = sq.getSequenceFeatures(); - if (sf != null) + // int ist = sq.findPosition(sqcol.getStartRes()); + List sfs = sq.findFeatures(startColumn, endColumn, + featureType); + + boolean found = false; + for (SequenceFeature sf : sfs) { - int ist = sq.findIndex(sq.getStart()); - int iend = sq.findIndex(sq.getEnd()); - if (iend < alStart || ist > alw) + if (fr.getColour(sf) == null) { - // sequence not in region continue; } - for (SequenceFeature sfpos : sf) + if (!found) { - // future functionalty - featureType == null means mark columns - // containing all displayed features - if (sfpos != null && (featureType.equals(sfpos.getType()))) - { - tfeat++; - // optimisation - could consider 'spos,apos' like cursor argument - // - findIndex wastes time by starting from first character and - // counting - - int i = sq.findIndex(sfpos.getBegin()); - int j = sq.findIndex(sfpos.getEnd()); - if (j < alStart || i > alw) - { - // feature is outside selected region - continue; - } - if (i < alStart) - { - i = alStart; - } - if (i < ist) - { - i = ist; - } - if (j > alw) - { - j = alw; - } - for (; i <= j; i++) - { - bs.set(i - 1); - } - } + nseq++; } - } + found = true; - if (tfeat > 0) - { - nseq++; - } - } - } - ColumnSelection cs = viewport.getColumnSelection(); - if (bs.cardinality() > 0 || invert) - { - if (cs == null) - { - cs = new ColumnSelection(); - } - else - { - if (!extendCurrent) - { - cs.clear(); - } - } - if (invert) - { - // invert only in the currently selected sequence region - for (int i = bs.nextClearBit(alStart), ibs = bs.nextSetBit(alStart); i >= alStart - && i < (alw);) - { - if (ibs < 0 || i < ibs) + int sfStartCol = sq.findIndex(sf.getBegin()); + int sfEndCol = sq.findIndex(sf.getEnd()); + + if (sf.isContactFeature()) { - if (toggle && cs.contains(i)) + /* + * 'contact' feature - check for 'start' or 'end' + * position within the selected region + */ + if (sfStartCol >= startColumn && sfStartCol <= endColumn) { - cs.removeElement(i++); + bs.set(sfStartCol - 1); } - else + if (sfEndCol >= startColumn && sfEndCol <= endColumn) { - cs.addElement(i++); + bs.set(sfEndCol - 1); } + continue; } - else + + /* + * contiguous feature - select feature positions (if any) + * within the selected region + */ + if (sfStartCol < startColumn) { - i = bs.nextClearBit(ibs); - ibs = bs.nextSetBit(i); + sfStartCol = startColumn; } - } - } - else - { - for (int i = bs.nextSetBit(alStart); i >= alStart; i = bs - .nextSetBit(i + 1)) - { - if (toggle && cs.contains(i)) + // not sure what the point of this is + // if (sfStartCol < ist) + // { + // sfStartCol = ist; + // } + if (sfEndCol > endColumn) { - cs.removeElement(i); + sfEndCol = endColumn; } - else + for (; sfStartCol <= sfEndCol; sfStartCol++) { - cs.addElement(i); + bs.set(sfStartCol - 1); // convert to base 0 } } } - viewport.setColumnSelection(cs); - alignPanel.paintAlignment(true); - avcg.setStatus(MessageManager.formatMessage( - "label.view_controller_toggled_marked", - new String[] { - (toggle ? MessageManager.getString("label.toggled") - : MessageManager.getString("label.marked")), - (invert ? (Integer.valueOf((alw - alStart) - - bs.cardinality()).toString()) : (Integer - .valueOf(bs.cardinality()).toString())), - featureType, Integer.valueOf(nseq).toString() })); - return true; - } - else - { - avcg.setStatus(MessageManager.formatMessage( - "label.no_feature_of_type_found", - new String[] { featureType })); - if (!extendCurrent && cs != null) - { - cs.clear(); - alignPanel.paintAlignment(true); - } - return false; } + return nseq; } @Override - public void sortAlignmentByFeatureDensity(String[] typ) + public void sortAlignmentByFeatureDensity(List typ) { - sortBy(typ, "Sort by Density", AlignmentSorter.FEATURE_DENSITY); + String methodText = MessageManager.getString("label.sort_by_density"); + sortByFeatures(typ, methodText, AlignmentSorter.FEATURE_DENSITY); } - protected void sortBy(String[] typ, String methodText, final String method) + /** + * Sorts the alignment (or current selection) by either average score or + * density of the specified feature types, and adds to the command history. If + * {@code types} is null, all visible feature types are used for the sort. If + * no feature types apply, does nothing. + * + * @param types + * @param methodText + * - text shown in Undo/Redo command + * @param method + * - passed to jalview.analysis.AlignmentSorter.sortByFeatures() + */ + protected void sortByFeatures(List types, String methodText, + final String method) { FeatureRenderer fr = alignPanel.getFeatureRenderer(); - if (typ == null) + if (types == null && fr != null) { - typ = fr == null ? null : fr.getDisplayedFeatureTypes(); + types = fr.getDisplayedFeatureTypes(); } - String gps[] = null; - gps = fr == null ? null : fr.getDisplayedFeatureGroups(); - if (typ != null) + if (types.isEmpty()) { - ArrayList types = new ArrayList(); - for (int i = 0; i < typ.length; i++) - { - if (typ[i] != null) - { - types.add(typ[i]); - } - typ = new String[types.size()]; - types.toArray(typ); - } + return; // nothing to do } - if (gps != null) + List gps = null; + if (fr != null) { - ArrayList grps = new ArrayList(); - - for (int i = 0; i < gps.length; i++) - { - if (gps[i] != null) - { - grps.add(gps[i]); - } - } - gps = new String[grps.size()]; - grps.toArray(gps); + gps = fr.getDisplayedFeatureGroups(); } AlignmentI al = viewport.getAlignment(); @@ -374,50 +362,142 @@ public class AlignViewController implements AlignViewControllerI stop = al.getWidth(); } SequenceI[] oldOrder = al.getSequencesArray(); - AlignmentSorter.sortByFeature(typ, gps, start, stop, al, method); - avcg.addHistoryItem(new OrderCommand(methodText, oldOrder, viewport - .getAlignment())); - alignPanel.paintAlignment(true); + AlignmentSorter.sortByFeature(types, gps, start, stop, al, method); + avcg.addHistoryItem(new OrderCommand(methodText, oldOrder, + viewport.getAlignment())); + alignPanel.paintAlignment(true, false); } @Override - public void sortAlignmentByFeatureScore(String[] typ) + public void sortAlignmentByFeatureScore(List typ) { - sortBy(typ, "Sort by Feature Score", AlignmentSorter.FEATURE_SCORE); + String methodText = MessageManager.getString("label.sort_by_score"); + sortByFeatures(typ, methodText, AlignmentSorter.FEATURE_SCORE); } @Override - public boolean parseFeaturesFile(String file, String protocol, + public boolean parseFeaturesFile(Object file, DataSourceType protocol, boolean relaxedIdMatching) { - boolean featuresFile = false; + boolean featuresAdded = false; + FeatureRenderer fr = alignPanel.getFeatureRenderer(); try { - featuresFile = new FeaturesFile(file, protocol).parse(viewport - .getAlignment().getDataset(), alignPanel.getFeatureRenderer() - .getFeatureColours(), false, relaxedIdMatching); + featuresAdded = new FeaturesFile(false, file, protocol).parse( + viewport.getAlignment().getDataset(), fr.getFeatureColours(), + fr.getFeatureFilters(), false, relaxedIdMatching); } catch (Exception ex) { ex.printStackTrace(); } - if (featuresFile) + if (featuresAdded) { avcg.refreshFeatureUI(true); - if (alignPanel.getFeatureRenderer() != null) + if (fr != null) { // update the min/max ranges where necessary - alignPanel.getFeatureRenderer().findAllFeatures(true); + fr.findAllFeatures(true); } if (avcg.getFeatureSettingsUI() != null) { avcg.getFeatureSettingsUI().discoverAllFeatureData(); } - alignPanel.paintAlignment(true); + alignPanel.paintAlignment(true, true); } - return featuresFile; + return featuresAdded; } + + @Override + public boolean markHighlightedColumns(boolean invert, + boolean extendCurrent, boolean toggle) + { + if (!viewport.hasSearchResults()) + { + // do nothing if no selection exists + return false; + } + // JBPNote this routine could also mark rows, not just columns. + BitSet bs = new BitSet(); + SequenceCollectionI sqcol = (viewport.getSelectionGroup() == null + || extendCurrent) ? viewport.getAlignment() + : viewport.getSelectionGroup(); + + // this could be a lambda... - the remains of the method is boilerplate, + // except for the different messages for reporting selection. + int nseq = viewport.getSearchResults().markColumns(sqcol, bs); + + ColumnSelection cs = viewport.getColumnSelection(); + if (cs == null) + { + cs = new ColumnSelection(); + } + + if (bs.cardinality() > 0 || invert) + { + boolean changed = cs.markColumns(bs, sqcol.getStartRes(), + sqcol.getEndRes(), invert, extendCurrent, toggle); + if (changed) + { + viewport.setColumnSelection(cs); + alignPanel.paintAlignment(false, false); + int columnCount = invert + ? (sqcol.getEndRes() - sqcol.getStartRes() + 1) + - bs.cardinality() + : bs.cardinality(); + avcg.setStatus(MessageManager.formatMessage( + "label.view_controller_toggled_marked", new String[] + { toggle ? MessageManager.getString("label.toggled") + : MessageManager.getString("label.marked"), + String.valueOf(columnCount), + invert ? MessageManager + .getString("label.not_containing") + : MessageManager.getString("label.containing"), + "Highlight", Integer.valueOf(nseq).toString() })); + return true; + } + } + else + { + avcg.setStatus(MessageManager + .getString("label.no_highlighted_regions_marked")); + if (!extendCurrent) + { + cs.clear(); + alignPanel.paintAlignment(false, false); + } + } + return false; + } + + @Override + public boolean copyHighlightedRegionsToClipboard() + { + if (!viewport.hasSearchResults()) + { + // do nothing if no selection exists + return false; + } + + SearchResultsI searchResults = viewport.getSearchResults(); + if (searchResults.isEmpty()) + { + return false; // shouldn't happen + } + List seqs = searchResults.getMatchingSubSequences(); + + // TODO: pass in hiddenColumns according to intersection of searchResults + // and visible columns. Currently this isn't done, since each contig becomes + // a single subsequence + Desktop.jalviewClipboard = new Object[] { + seqs.toArray(new SequenceI[0]), + alignPanel.getAlignment().getDataset(), null }; + avcg.setStatus(MessageManager.formatMessage( + "label.copied_sequences_to_clipboard", seqs.size())); + // Technically we should return false, since view has not changed + return false; + } }