X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fcontroller%2FAlignViewController.java;h=aac78014d50cfec0617b87109e75dc6b8b07f482;hb=83be20f1d8274aa0044acc72c427abef766d8dd1;hp=74161c8d1fb3f33b3e8a2ccba37eb4a2c0de7f94;hpb=47168f025aefdaa044802bd5f8f510ffe43a4808;p=jalview.git diff --git a/src/jalview/controller/AlignViewController.java b/src/jalview/controller/AlignViewController.java index 74161c8..aac7801 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.8.2) - * Copyright (C) 2014 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,62 +20,82 @@ */ 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; import jalview.api.AlignViewportI; import jalview.api.AlignmentViewPanel; +import jalview.api.FeatureRenderer; +import jalview.commands.OrderCommand; import jalview.datamodel.AlignmentI; -import jalview.datamodel.AnnotatedCollectionI; 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.io.DataSourceType; +import jalview.io.FeaturesFile; +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; - AlignmentViewPanel alignPanel=null; + AlignViewportI viewport = null; + + AlignmentViewPanel alignPanel = null; + /** * the GUI container that is handling interactions with the user */ private AlignViewControllerGuiI avcg; - @Override - protected void finalize() throws Throwable { - viewport = null; - alignPanel = null; - avcg = null; - }; - - public AlignViewController(AlignViewControllerGuiI alignFrame, AlignViewportI viewport, - AlignmentViewPanel alignPanel) + + public AlignViewController(AlignViewControllerGuiI alignFrame, + 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 public boolean makeGroupsFromSelection() { - - if (viewport.getSelectionGroup() != null) + SequenceGroup sg = viewport.getSelectionGroup(); + ColumnSelection cs = viewport.getColumnSelection(); + SequenceGroup[] gps = null; + if (sg != null && (cs == null || cs.isEmpty())) { - SequenceGroup[] gps = jalview.analysis.Grouping.makeGroupsFrom( + gps = jalview.analysis.Grouping.makeGroupsFrom( viewport.getSequenceSelection(), - viewport.getAlignmentView(true).getSequenceStrings( - viewport.getGapCharacter()), viewport.getAlignment() - .getGroups()); + viewport.getAlignmentView(true) + .getSequenceStrings(viewport.getGapCharacter()), + viewport.getAlignment().getGroups()); + } + else + { + if (cs != null) + { + gps = jalview.analysis.Grouping.makeGroupsFromCols( + (sg == null) ? viewport.getAlignment().getSequencesArray() + : sg.getSequences().toArray(new SequenceI[0]), + cs, viewport.getAlignment().getGroups()); + } + } + if (gps != null) + { viewport.getAlignment().deleteAllGroups(); viewport.clearSequenceColours(); viewport.setSelectionGroup(null); @@ -89,189 +109,443 @@ public class AlignViewController implements AlignViewControllerI (int) (Math.random() * 255), (int) (Math.random() * 255)); col = col.brighter(); for (SequenceI sq : gps[g].getSequences(null)) + { viewport.setSequenceColour(sq, col); + } } return true; } return false; -} + } + @Override public boolean createGroup() { SequenceGroup sg = viewport.getSelectionGroup(); - if (sg!=null) + if (sg != null) { - viewport.getAlignment().addGroup(sg); - return true; - } + viewport.getAlignment().addGroup(sg); + return true; + } return false; } + @Override public boolean unGroup() { SequenceGroup sg = viewport.getSelectionGroup(); - if (sg!=null) + if (sg != null) { - viewport.getAlignment().deleteGroup(sg); - return true; + viewport.getAlignment().deleteGroup(sg); + return true; } return false; } + @Override public boolean deleteGroups() { - if (viewport.getAlignment().getGroups()!=null && viewport.getAlignment().getGroups().size()>0) + if (viewport.getAlignment().getGroups() != null + && viewport.getAlignment().getGroups().size() > 0) { - viewport.getAlignment().deleteAllGroups(); - viewport.clearSequenceColours(); - viewport.setSelectionGroup(null); - return true; + viewport.getAlignment().deleteAllGroups(); + viewport.clearSequenceColours(); + viewport.setSelectionGroup(null); + return true; } return false; } - + @Override - public boolean markColumnsContainingFeatures(boolean invert, boolean extendCurrent, boolean toggle, String featureType) + public boolean markColumnsContainingFeatures(boolean invert, + boolean extendCurrent, boolean toggle, String featureType) { // 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; + SequenceCollectionI sqcol = (viewport.getSelectionGroup() == null + || extendCurrent) ? viewport.getAlignment() + : viewport.getSelectionGroup(); + + 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 + { + avcg.setStatus(MessageManager + .formatMessage("label.no_feature_of_type_found", 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) { - SequenceI dsq = sq.getDatasetSequence(); - while (dsq.getDatasetSequence() != null) - { - dsq = dsq.getDatasetSequence(); - } - ; - SequenceFeature[] sf = dsq.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()))) + nseq++; + } + found = true; + + int sfStartCol = sq.findIndex(sf.getBegin()); + int sfEndCol = sq.findIndex(sf.getEnd()); + + if (sf.isContactFeature()) + { + /* + * 'contact' feature - check for 'start' or 'end' + * position within the selected region + */ + if (sfStartCol >= startColumn && sfStartCol <= endColumn) + { + bs.set(sfStartCol - 1); + } + if (sfEndCol >= startColumn && sfEndCol <= endColumn) { - 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 (jalw) - { - // 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); - } + bs.set(sfEndCol - 1); } + continue; } - } - if (tfeat > 0) - { - nseq++; + /* + * contiguous feature - select feature positions (if any) + * within the selected region + */ + if (sfStartCol < startColumn) + { + sfStartCol = startColumn; + } + // not sure what the point of this is + // if (sfStartCol < ist) + // { + // sfStartCol = ist; + // } + if (sfEndCol > endColumn) + { + sfEndCol = endColumn; + } + for (; sfStartCol <= sfEndCol; sfStartCol++) + { + bs.set(sfStartCol - 1); // convert to base 0 + } } } } - ColumnSelection cs = viewport.getColumnSelection(); - if (bs.cardinality() > 0 || invert) + return nseq; + } + + @Override + public void sortAlignmentByFeatureDensity(List typ) + { + sortBy(typ, "Sort by Density", AlignmentSorter.FEATURE_DENSITY); + } + + protected void sortBy(List typ, String methodText, + final String method) + { + FeatureRenderer fr = alignPanel.getFeatureRenderer(); + if (typ == null && fr != null) + { + typ = fr.getDisplayedFeatureTypes(); + } + List gps = null; + if (fr != null) + { + gps = fr.getDisplayedFeatureGroups(); + } + AlignmentI al = viewport.getAlignment(); + + int start, stop; + SequenceGroup sg = viewport.getSelectionGroup(); + if (sg != null) + { + start = sg.getStartRes(); + stop = sg.getEndRes(); + } + else + { + start = 0; + 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, false); + + } + + @Override + public void sortAlignmentByFeatureScore(List typ) + { + sortBy(typ, "Sort by Feature Score", AlignmentSorter.FEATURE_SCORE); + } + + @Override + public boolean parseFeaturesFile(String file, DataSourceType protocol, + boolean relaxedIdMatching) + { + boolean featuresAdded = false; + FeatureRenderer fr = alignPanel.getFeatureRenderer(); + try + { + featuresAdded = new FeaturesFile(false, file, protocol).parse( + viewport.getAlignment().getDataset(), fr.getFeatureColours(), + fr.getFeatureFilters(), false, relaxedIdMatching); + } catch (Exception ex) + { + ex.printStackTrace(); + } + + if (featuresAdded) { - if (cs == null) + avcg.refreshFeatureUI(true); + if (fr != null) { - cs = new ColumnSelection(); - } else { - if (!extendCurrent) + // update the min/max ranges where necessary + fr.findAllFeatures(true); + } + if (avcg.getFeatureSettingsUI() != null) + { + avcg.getFeatureSettingsUI().discoverAllFeatureData(); + } + alignPanel.paintAlignment(true, true); + } + + return featuresAdded; + + } + + /** + * + * Add highlighted sequences to selected rows. Exclude highlighted sequences + * from selected rows. toggle inclusion or exclusion of highlighted sequences. + * or add/exclude/toggle for sequences not highlighted. + * + * @param invert + * - when true, sequences that are not highlighted are added/removed + * from selection + * @param extendCurrent + * - normally true , the current selected group is modified. + * Otherwise a new selection is created + * @param toggle + * - toggle selection status for highlighted/not highlighted sequence + * @return + */ + public boolean selectHighlightedSequences(boolean invert, + boolean extendCurrent, boolean toggle) + { + List results = alignPanel.getAlignViewport() + .getHighlightedSeqs(); + + SequenceGroup sq = (extendCurrent + && viewport.getSelectionGroup() != null) + ? viewport.getSelectionGroup() + : new SequenceGroup(); + + SearchResultsI searchResults = viewport.getSearchResults(); + if (invert) + { + List nothighlighted = new ArrayList(); + for (SequenceI seq : alignPanel.getAlignViewport().getAlignment() + .getSequences()) + { + if (!results.contains(seq) && (searchResults == null + || !searchResults.involvesSequence(seq))) { - cs.clear(); + nothighlighted.add(seq); } } - if (invert) + results = nothighlighted; + } + else + { + // copy list and add in search results + results = new ArrayList(results); + if (searchResults != null) { - // invert only in the currently selected sequence region - for (int i = bs.nextClearBit(alStart), ibs = bs.nextSetBit(alStart); i >= alStart - && i < (alw);) + for (SequenceI seq : alignPanel.getAlignViewport().getAlignment() + .getSequences()) { - if (ibs < 0 || i < ibs) + if (searchResults.involvesSequence(seq)) { - if (toggle && cs.contains(i)) - { - cs.removeElement(i++); - } else - { - cs.addElement(i++); - } - } - else - { - i = bs.nextClearBit(ibs); - ibs = bs.nextSetBit(i); + results.add(seq); } } } + } + + if (results == null || results.size() == 0) + { + // do nothing if no selection exists + // unless toggle ?? + return false; + } + + boolean changed = false; + + for (SequenceI seq : results) + { + int size = sq.getSize(); + if (toggle) + { + sq.addOrRemove(seq, false); + } else { - for (int i = bs.nextSetBit(alStart); i >= alStart; i = bs.nextSetBit(i + 1)) - { - if (toggle && cs.contains(i)) - { - cs.removeElement(i); - } else - { - cs.addElement(i); - } - } + sq.addSequence(seq, false); } - viewport.setColumnSelection(cs); - alignPanel.paintAlignment(true); - avcg.setStatus((toggle ? "Toggled ": "Marked ") - + (invert ? (alw-alStart) - bs.cardinality() : bs.cardinality()) - + " columns "+(invert ? "not " : "") + "containing features of type " + featureType - + " across " + nseq + " sequence(s)"); - return true; + changed |= size != sq.getSize(); + } + + if (sq.getSize() == 0) + { + viewport.setSelectionGroup(null); } else { - avcg.setStatus("No features of type " + featureType + " found."); - if (!extendCurrent && cs!=null) + if (sq != viewport.getSelectionGroup()) + { + sq.setStartRes(0); + sq.setEndRes(viewport.getRanges().getAbsoluteAlignmentWidth()); + } + viewport.setSelectionGroup(sq); + } + + alignPanel.paintAlignment(false, false); + + return changed; + } + + @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 + .formatMessage("No highlighted regions marked")); + if (!extendCurrent) { cs.clear(); - alignPanel.paintAlignment(true); + alignPanel.paintAlignment(false, false); } - return false; } + return false; } + }