+
+ @Override
+ 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;
+ List<SequenceI> 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.findIndex(sq.getStart());
+ int iend = sq.findIndex(sq.getEnd());
+ if (iend < alStart || ist > alw)
+ {
+ // sequence not in region
+ continue;
+ }
+ for (SequenceFeature sfpos : sf)
+ {
+ // 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);
+ }
+ }
+ }
+ }
+
+ 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)
+ {
+ if (toggle && cs.contains(i))
+ {
+ cs.removeElement(i++);
+ }
+ else
+ {
+ cs.addElement(i++);
+ }
+ }
+ else
+ {
+ i = bs.nextClearBit(ibs);
+ ibs = bs.nextSetBit(i);
+ }
+ }
+ }
+ 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);
+ }
+ }
+ }
+ 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;
+ }
+ }
+
+ @Override
+ public void sortAlignmentByFeatureDensity(String[] typ)
+ {
+ sortBy(typ, "Sort by Density", AlignmentSorter.FEATURE_DENSITY);
+ }
+
+ protected void sortBy(String[] typ, String methodText, final String method)
+ {
+ FeatureRenderer fr = alignPanel.getFeatureRenderer();
+ if (typ == null)
+ {
+ typ = fr == null ? null : fr.getDisplayedFeatureTypes();
+ }
+ String gps[] = null;
+ gps = fr == null ? null : fr.getDisplayedFeatureGroups();
+ if (typ != null)
+ {
+ 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);
+ }
+ }
+ if (gps != 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);
+ }
+ 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);
+
+ }
+
+ @Override
+ public void sortAlignmentByFeatureScore(String[] typ)
+ {
+ sortBy(typ, "Sort by Feature Score", AlignmentSorter.FEATURE_SCORE);
+ }
+
+ @Override
+ public boolean parseFeaturesFile(String file, String protocol,
+ boolean relaxedIdMatching)
+ {
+ boolean featuresFile = false;
+ try
+ {
+ featuresFile = new FeaturesFile(file, protocol).parse(viewport
+ .getAlignment().getDataset(), alignPanel.getFeatureRenderer()
+ .getFeatureColours(), false, relaxedIdMatching);
+ } catch (Exception ex)
+ {
+ ex.printStackTrace();
+ }
+
+ if (featuresFile)
+ {
+ avcg.refreshFeatureUI(true);
+ if (alignPanel.getFeatureRenderer() != null)
+ {
+ // update the min/max ranges where necessary
+ alignPanel.getFeatureRenderer().findAllFeatures(true);
+ }
+ if (avcg.getFeatureSettingsUI() != null)
+ {
+ avcg.getFeatureSettingsUI().discoverAllFeatureData();
+ }
+ alignPanel.paintAlignment(true);
+ }
+
+ return featuresFile;
+