--- /dev/null
+Clazz.declarePackage ("jalview.datamodel");
+Clazz.load (["java.util.Vector"], "jalview.datamodel.ColumnSelection", ["jalview.util.ShiftList", "jalview.viewmodel.annotationfilter.AnnotationFilterParameter", "java.lang.StringBuffer", "java.util.ArrayList", "$.Collections"], function () {
+c$ = Clazz.decorateAsClass (function () {
+this.selected = null;
+this.hiddenColumns = null;
+Clazz.instantialize (this, arguments);
+}, jalview.datamodel, "ColumnSelection");
+Clazz.prepareFields (c$, function () {
+this.selected = new java.util.Vector ();
+});
+Clazz.defineMethod (c$, "addElement",
+function (col) {
+var column = new Integer (col);
+if (!this.selected.contains (column)) {
+this.selected.addElement (column);
+}}, "~N");
+Clazz.defineMethod (c$, "clear",
+function () {
+this.selected.removeAllElements ();
+});
+Clazz.defineMethod (c$, "removeElement",
+function (col) {
+var colInt = new Integer (col);
+if (this.selected.contains (colInt)) {
+this.selected.removeElement (colInt);
+}}, "~N");
+Clazz.defineMethod (c$, "removeElements",
+function (start, end) {
+var colInt;
+for (var i = start; i < end; i++) {
+colInt = new Integer (i);
+if (this.selected.contains (colInt)) {
+this.selected.removeElement (colInt);
+}}
+}, "~N,~N");
+Clazz.defineMethod (c$, "getSelected",
+function () {
+return this.selected;
+});
+Clazz.defineMethod (c$, "contains",
+function (col) {
+return this.selected.contains ( new Integer (col));
+}, "~N");
+Clazz.defineMethod (c$, "columnAt",
+function (i) {
+return this.selected.elementAt (i).intValue ();
+}, "~N");
+Clazz.defineMethod (c$, "size",
+function () {
+return this.selected.size ();
+});
+Clazz.defineMethod (c$, "getMax",
+function () {
+var max = -1;
+for (var i = 0; i < this.selected.size (); i++) {
+if (this.columnAt (i) > max) {
+max = this.columnAt (i);
+}}
+return max;
+});
+Clazz.defineMethod (c$, "getMin",
+function () {
+var min = 1000000000;
+for (var i = 0; i < this.selected.size (); i++) {
+if (this.columnAt (i) < min) {
+min = this.columnAt (i);
+}}
+return min;
+});
+Clazz.defineMethod (c$, "compensateForEdit",
+function (start, change) {
+var deletedHiddenColumns = null;
+for (var i = 0; i < this.size (); i++) {
+var temp = this.columnAt (i);
+if (temp >= start) {
+this.selected.setElementAt ( new Integer (temp - change), i);
+}}
+if (this.hiddenColumns != null) {
+deletedHiddenColumns = new java.util.ArrayList ();
+var hSize = this.hiddenColumns.size ();
+for (var i = 0; i < hSize; i++) {
+var region = this.hiddenColumns.elementAt (i);
+if (region[0] > start && start + change > region[1]) {
+deletedHiddenColumns.add (region);
+this.hiddenColumns.removeElementAt (i);
+i--;
+hSize--;
+continue;
+}if (region[0] > start) {
+region[0] -= change;
+region[1] -= change;
+}if (region[0] < 0) {
+region[0] = 0;
+}}
+this.revealHiddenColumns (0);
+}return deletedHiddenColumns;
+}, "~N,~N");
+Clazz.defineMethod (c$, "compensateForDelEdits",
+ function (start, change) {
+for (var i = 0; i < this.size (); i++) {
+var temp = this.columnAt (i);
+if (temp >= start) {
+this.selected.setElementAt ( new Integer (temp - change), i);
+}}
+if (this.hiddenColumns != null) {
+for (var i = 0; i < this.hiddenColumns.size (); i++) {
+var region = this.hiddenColumns.elementAt (i);
+if (region[0] >= start) {
+region[0] -= change;
+}if (region[1] >= start) {
+region[1] -= change;
+}if (region[1] < region[0]) {
+this.hiddenColumns.removeElementAt (i--);
+}if (region[0] < 0) {
+region[0] = 0;
+}if (region[1] < 0) {
+region[1] = 0;
+}}
+}}, "~N,~N");
+Clazz.defineMethod (c$, "compensateForEdits",
+function (shiftrecord) {
+if (shiftrecord != null) {
+var shifts = shiftrecord.getShifts ();
+if (shifts != null && shifts.size () > 0) {
+var shifted = 0;
+for (var i = 0, j = shifts.size (); i < j; i++) {
+var sh = shifts.get (i);
+this.compensateForDelEdits (shifted + sh[0], sh[1]);
+shifted -= sh[1];
+}
+}return shiftrecord.getInverse ();
+}return null;
+}, "jalview.util.ShiftList");
+Clazz.defineMethod (c$, "pruneIntervalVector",
+ function (shifts, intervals) {
+var pruned = false;
+var i = 0;
+var j = intervals.size () - 1;
+var s = 0;
+var t = shifts.size () - 1;
+var hr = intervals.elementAt (i);
+var sr = shifts.get (s);
+while (i <= j && s <= t) {
+var trailinghn = hr[1] >= sr[0];
+if (!trailinghn) {
+if (i < j) {
+hr = intervals.elementAt (++i);
+} else {
+i++;
+}continue;
+}var endshift = sr[0] + sr[1];
+if (endshift < hr[0] || endshift < sr[0]) {
+if (s < t) {
+sr = shifts.get (++s);
+} else {
+s++;
+}continue;
+}var leadinghn = hr[0] >= sr[0];
+var leadinghc = hr[0] < endshift;
+var trailinghc = hr[1] < endshift;
+if (leadinghn) {
+if (trailinghc) {
+intervals.removeElementAt (i);
+pruned = true;
+j--;
+if (i <= j) {
+hr = intervals.elementAt (i);
+}continue;
+}if (leadinghc) {
+hr[0] = endshift;
+leadinghn = !leadinghn;
+pruned = true;
+}}if (!leadinghn) {
+if (trailinghc) {
+if (trailinghn) {
+hr[1] = sr[0] - 1;
+pruned = true;
+}} else {
+if (s < t) {
+sr = shifts.get (++s);
+} else {
+s++;
+}continue;
+}}}
+return pruned;
+}, "java.util.List,java.util.Vector");
+Clazz.defineMethod (c$, "pruneColumnList",
+ function (shifts, list) {
+var s = 0;
+var t = shifts.size ();
+var sr = shifts.get (s++);
+var pruned = false;
+var i = 0;
+var j = list.size ();
+while (i < j && s <= t) {
+var c = list.elementAt (i++).intValue ();
+if (sr[0] <= c) {
+if (sr[1] + sr[0] >= c) {
+list.removeElementAt (--i);
+j--;
+} else {
+if (s < t) {
+sr = shifts.get (s);
+}s++;
+}}}
+return pruned;
+}, "java.util.List,java.util.Vector");
+Clazz.defineMethod (c$, "pruneDeletions",
+function (deletions) {
+if (deletions != null) {
+var shifts = deletions.getShifts ();
+if (shifts != null && shifts.size () > 0) {
+if (this.hiddenColumns != null) {
+this.pruneIntervalVector (shifts, this.hiddenColumns);
+if (this.hiddenColumns != null && this.hiddenColumns.size () == 0) {
+this.hiddenColumns = null;
+}}if (this.selected != null && this.selected.size () > 0) {
+this.pruneColumnList (shifts, this.selected);
+if (this.selected != null && this.selected.size () == 0) {
+this.selected = null;
+}}this.compensateForEdits (deletions);
+}}}, "jalview.util.ShiftList");
+Clazz.defineMethod (c$, "getHiddenColumns",
+function () {
+return this.hiddenColumns == null ? java.util.Collections.emptyList () : this.hiddenColumns;
+});
+Clazz.defineMethod (c$, "adjustForHiddenColumns",
+function (column) {
+var result = column;
+if (this.hiddenColumns != null) {
+for (var i = 0; i < this.hiddenColumns.size (); i++) {
+var region = this.hiddenColumns.elementAt (i);
+if (result >= region[0]) {
+result += region[1] - region[0] + 1;
+}}
+}return result;
+}, "~N");
+Clazz.defineMethod (c$, "findColumnPosition",
+function (hiddenColumn) {
+var result = hiddenColumn;
+if (this.hiddenColumns != null) {
+var index = 0;
+var region;
+do {
+region = this.hiddenColumns.elementAt (index++);
+if (hiddenColumn > region[1]) {
+result -= region[1] + 1 - region[0];
+}} while ((hiddenColumn > region[1]) && (index < this.hiddenColumns.size ()));
+if (hiddenColumn > region[0] && hiddenColumn < region[1]) {
+return region[0] + hiddenColumn - result;
+}}return result;
+}, "~N");
+Clazz.defineMethod (c$, "findHiddenRegionPosition",
+function (hiddenRegion) {
+var result = 0;
+if (this.hiddenColumns != null) {
+var index = 0;
+var gaps = 0;
+do {
+var region = this.hiddenColumns.elementAt (index);
+if (hiddenRegion == 0) {
+return region[0];
+}gaps += region[1] + 1 - region[0];
+result = region[1] + 1;
+index++;
+} while (index < hiddenRegion + 1);
+result -= gaps;
+}return result;
+}, "~N");
+Clazz.defineMethod (c$, "getHiddenBoundaryRight",
+function (alPos) {
+if (this.hiddenColumns != null) {
+var index = 0;
+do {
+var region = this.hiddenColumns.elementAt (index);
+if (alPos < region[0]) {
+return region[0];
+}index++;
+} while (index < this.hiddenColumns.size ());
+}return alPos;
+}, "~N");
+Clazz.defineMethod (c$, "getHiddenBoundaryLeft",
+function (alPos) {
+if (this.hiddenColumns != null) {
+var index = this.hiddenColumns.size () - 1;
+do {
+var region = this.hiddenColumns.elementAt (index);
+if (alPos > region[1]) {
+return region[1];
+}index--;
+} while (index > -1);
+}return alPos;
+}, "~N");
+Clazz.defineMethod (c$, "hideSelectedColumns",
+function () {
+while (this.size () > 0) {
+var column = this.getSelected ().firstElement ().intValue ();
+this.hideColumns (column);
+}
+});
+Clazz.defineMethod (c$, "hideColumns",
+function (start, end) {
+if (this.hiddenColumns == null) {
+this.hiddenColumns = new java.util.Vector ();
+}var added = false;
+var overlap = false;
+for (var i = 0; i < this.hiddenColumns.size (); i++) {
+var region = this.hiddenColumns.elementAt (i);
+if (start <= region[1] && end >= region[0]) {
+this.hiddenColumns.removeElementAt (i);
+overlap = true;
+break;
+} else if (end < region[0] && start < region[0]) {
+this.hiddenColumns.insertElementAt ( Clazz.newIntArray (-1, [start, end]), i);
+added = true;
+break;
+}}
+if (overlap) {
+this.hideColumns (start, end);
+} else if (!added) {
+this.hiddenColumns.addElement ( Clazz.newIntArray (-1, [start, end]));
+}}, "~N,~N");
+Clazz.defineMethod (c$, "hideColumns",
+function (col) {
+var min = col;
+var max = col + 1;
+while (this.contains (min)) {
+this.removeElement (min);
+min--;
+}
+while (this.contains (max)) {
+this.removeElement (max);
+max++;
+}
+min++;
+max--;
+if (min > max) {
+min = max;
+}this.hideColumns (min, max);
+}, "~N");
+Clazz.defineMethod (c$, "revealAllHiddenColumns",
+function () {
+if (this.hiddenColumns != null) {
+for (var i = 0; i < this.hiddenColumns.size (); i++) {
+var region = this.hiddenColumns.elementAt (i);
+for (var j = region[0]; j < region[1] + 1; j++) {
+this.addElement (j);
+}
+}
+}this.hiddenColumns = null;
+});
+Clazz.defineMethod (c$, "revealHiddenColumns",
+function (res) {
+for (var i = 0; i < this.hiddenColumns.size (); i++) {
+var region = this.hiddenColumns.elementAt (i);
+if (res == region[0]) {
+for (var j = region[0]; j < region[1] + 1; j++) {
+this.addElement (j);
+}
+this.hiddenColumns.removeElement (region);
+break;
+}}
+if (this.hiddenColumns.size () == 0) {
+this.hiddenColumns = null;
+}}, "~N");
+Clazz.defineMethod (c$, "isVisible",
+function (column) {
+if (this.hiddenColumns != null) {
+for (var i = 0; i < this.hiddenColumns.size (); i++) {
+var region = this.hiddenColumns.elementAt (i);
+if (column >= region[0] && column <= region[1]) {
+return false;
+}}
+}return true;
+}, "~N");
+Clazz.makeConstructor (c$,
+function (copy) {
+if (copy != null) {
+if (copy.selected != null) {
+this.selected = new java.util.Vector ();
+for (var i = 0, j = copy.selected.size (); i < j; i++) {
+this.selected.addElement (copy.selected.elementAt (i));
+}
+}if (copy.hiddenColumns != null) {
+this.hiddenColumns = new java.util.Vector (copy.hiddenColumns.size ());
+for (var i = 0, j = copy.hiddenColumns.size (); i < j; i++) {
+var rh;
+var cp;
+rh = copy.hiddenColumns.elementAt (i);
+if (rh != null) {
+cp = Clazz.newIntArray (rh.length, 0);
+System.arraycopy (rh, 0, cp, 0, rh.length);
+this.hiddenColumns.addElement (cp);
+}}
+}}}, "jalview.datamodel.ColumnSelection");
+Clazz.makeConstructor (c$,
+function () {
+});
+Clazz.defineMethod (c$, "getVisibleSequenceStrings",
+function (start, end, seqs) {
+var i;
+var iSize = seqs.length;
+var selection = new Array (iSize);
+if (this.hiddenColumns != null && this.hiddenColumns.size () > 0) {
+for (i = 0; i < iSize; i++) {
+var visibleSeq = new StringBuffer ();
+var regions = this.getHiddenColumns ();
+var blockStart = start;
+var blockEnd = end;
+var region;
+var hideStart;
+var hideEnd;
+for (var j = 0; j < regions.size (); j++) {
+region = regions.get (j);
+hideStart = region[0];
+hideEnd = region[1];
+if (hideStart < start) {
+continue;
+}blockStart = Math.min (blockStart, hideEnd + 1);
+blockEnd = Math.min (blockEnd, hideStart);
+if (blockStart > blockEnd) {
+break;
+}visibleSeq.append (seqs[i].getSequence (blockStart, blockEnd));
+blockStart = hideEnd + 1;
+blockEnd = end;
+}
+if (end > blockStart) {
+visibleSeq.append (seqs[i].getSequence (blockStart, end));
+}selection[i] = visibleSeq.toString ();
+}
+} else {
+for (i = 0; i < iSize; i++) {
+selection[i] = seqs[i].getSequenceAsString (start, end);
+}
+}return selection;
+}, "~N,~N,~A");
+Clazz.defineMethod (c$, "getVisibleContigs",
+function (start, end) {
+if (this.hiddenColumns != null && this.hiddenColumns.size () > 0) {
+var visiblecontigs = new java.util.ArrayList ();
+var regions = this.getHiddenColumns ();
+var vstart = start;
+var region;
+var hideStart;
+var hideEnd;
+for (var j = 0; vstart < end && j < regions.size (); j++) {
+region = regions.get (j);
+hideStart = region[0];
+hideEnd = region[1];
+if (hideEnd < vstart) {
+continue;
+}if (hideStart > vstart) {
+visiblecontigs.add ( Clazz.newIntArray (-1, [vstart, hideStart - 1]));
+}vstart = hideEnd + 1;
+}
+if (vstart < end) {
+visiblecontigs.add ( Clazz.newIntArray (-1, [vstart, end - 1]));
+}var vcontigs = Clazz.newIntArray (visiblecontigs.size () * 2, 0);
+for (var i = 0, j = visiblecontigs.size (); i < j; i++) {
+var vc = visiblecontigs.get (i);
+visiblecontigs.set (i, null);
+vcontigs[i * 2] = vc[0];
+vcontigs[i * 2 + 1] = vc[1];
+}
+visiblecontigs.clear ();
+return vcontigs;
+} else {
+return Clazz.newIntArray (-1, [start, end - 1]);
+}}, "~N,~N");
+Clazz.defineMethod (c$, "makeVisibleAnnotation",
+function (alignmentAnnotation) {
+this.makeVisibleAnnotation (-1, -1, alignmentAnnotation);
+}, "jalview.datamodel.AlignmentAnnotation");
+Clazz.defineMethod (c$, "makeVisibleAnnotation",
+function (start, end, alignmentAnnotation) {
+if (alignmentAnnotation.annotations == null) {
+return;
+}if (start == end && end == -1) {
+start = 0;
+end = alignmentAnnotation.annotations.length;
+}if (this.hiddenColumns != null && this.hiddenColumns.size () > 0) {
+var annels = new java.util.Vector ();
+var els = null;
+var regions = this.getHiddenColumns ();
+var blockStart = start;
+var blockEnd = end;
+var region;
+var hideStart;
+var hideEnd;
+var w = 0;
+for (var j = 0; j < regions.size (); j++) {
+region = regions.get (j);
+hideStart = region[0];
+hideEnd = region[1];
+if (hideStart < start) {
+continue;
+}blockStart = Math.min (blockStart, hideEnd + 1);
+blockEnd = Math.min (blockEnd, hideStart);
+if (blockStart > blockEnd) {
+break;
+}annels.addElement (els = new Array (blockEnd - blockStart));
+System.arraycopy (alignmentAnnotation.annotations, blockStart, els, 0, els.length);
+w += els.length;
+blockStart = hideEnd + 1;
+blockEnd = end;
+}
+if (end > blockStart) {
+annels.addElement (els = new Array (end - blockStart + 1));
+if ((els.length + blockStart) <= alignmentAnnotation.annotations.length) {
+System.arraycopy (alignmentAnnotation.annotations, blockStart, els, 0, els.length);
+} else {
+System.arraycopy (alignmentAnnotation.annotations, blockStart, els, 0, (alignmentAnnotation.annotations.length - blockStart));
+}w += els.length;
+}if (w == 0) {
+return;
+}alignmentAnnotation.annotations = new Array (w);
+w = 0;
+for (var chnk, $chnk = annels.iterator (); $chnk.hasNext () && ((chnk = $chnk.next ()) || true);) {
+System.arraycopy (chnk, 0, alignmentAnnotation.annotations, w, chnk.length);
+w += chnk.length;
+}
+} else {
+alignmentAnnotation.restrict (start, end);
+}}, "~N,~N,jalview.datamodel.AlignmentAnnotation");
+Clazz.defineMethod (c$, "invertColumnSelection",
+function (first, width) {
+var hasHidden = this.hiddenColumns != null && this.hiddenColumns.size () > 0;
+for (var i = first; i < width; i++) {
+if (this.contains (i)) {
+this.removeElement (i);
+} else {
+if (!hasHidden || this.isVisible (i)) {
+this.addElement (i);
+}}}
+}, "~N,~N");
+Clazz.defineMethod (c$, "addElementsFrom",
+function (colsel) {
+if (colsel != null && colsel.size () > 0) {
+for (var col, $col = colsel.getSelected ().iterator (); $col.hasNext () && ((col = $col.next ()) || true);) {
+if (this.hiddenColumns != null && this.isVisible (col.intValue ())) {
+if (!this.selected.contains (col)) {
+this.selected.addElement (col);
+}}}
+}}, "jalview.datamodel.ColumnSelection");
+Clazz.defineMethod (c$, "setElementsFrom",
+function (colsel) {
+this.selected = new java.util.Vector ();
+if (colsel.selected != null && colsel.selected.size () > 0) {
+if (this.hiddenColumns != null && this.hiddenColumns.size () > 0) {
+this.addElementsFrom (colsel);
+} else {
+for (var col, $col = colsel.getSelected ().iterator (); $col.hasNext () && ((col = $col.next ()) || true);) {
+this.addElement ((col).intValue ());
+}
+}}}, "jalview.datamodel.ColumnSelection");
+c$.propagateInsertions = Clazz.defineMethod (c$, "propagateInsertions",
+function (profileseq, al, input) {
+var profsqpos = 0;
+var gc = al.getGapCharacter ();
+var alandcolsel = input.getAlignmentAndColumnSelection (gc);
+var nview = alandcolsel[1];
+var origseq = (alandcolsel[0])[profsqpos];
+nview.propagateInsertions (profileseq, al, origseq);
+return nview;
+}, "jalview.datamodel.SequenceI,jalview.datamodel.AlignmentI,jalview.datamodel.AlignmentView");
+Clazz.defineMethod (c$, "propagateInsertions",
+function (profileseq, al, origseq) {
+var gc = al.getGapCharacter ();
+this.pruneDeletions (jalview.util.ShiftList.parseMap (origseq.gapMap ()));
+var viscontigs = this.getVisibleContigs (0, profileseq.getLength ());
+var spos = 0;
+var offset = 0;
+for (var v = 0; v < viscontigs.length; v += 2) {
+if (viscontigs[v] > spos) {
+var sb = new StringBuffer ();
+for (var s = 0, ns = viscontigs[v] - spos; s < ns; s++) {
+sb.append (gc);
+}
+for (var s = 0, ns = al.getHeight (); s < ns; s++) {
+var sqobj = al.getSequenceAt (s);
+if (sqobj !== profileseq) {
+var sq = al.getSequenceAt (s).getSequenceAsString ();
+if (sq.length <= spos + offset) {
+var diff = spos + offset - sq.length - 1;
+if (diff > 0) {
+sq = sq + sb;
+while ((diff = spos + offset - sq.length - 1) > 0) {
+if (diff >= sb.length ()) {
+sq += sb.toString ();
+} else {
+var buf = Clazz.newCharArray (diff, '\0');
+sb.getChars (0, diff, buf, 0);
+sq += buf.toString ();
+}}
+}sq += sb.toString ();
+} else {
+al.getSequenceAt (s).setSequence (sq.substring (0, spos + offset) + sb.toString () + sq.substring (spos + offset));
+}}}
+}spos = viscontigs[v + 1] + 1;
+}
+if ((offset + spos) < profileseq.getLength ()) {
+var sb = new StringBuffer ();
+for (var s = 0, ns = profileseq.getLength () - spos - offset; s < ns; s++) {
+sb.append (gc);
+}
+for (var s = 0, ns = al.getHeight (); s < ns; s++) {
+var sqobj = al.getSequenceAt (s);
+if (sqobj === profileseq) {
+continue;
+}var sq = sqobj.getSequenceAsString ();
+var diff = origseq.getLength () - sq.length;
+while (diff > 0) {
+if (diff >= sb.length ()) {
+sq += sb.toString ();
+} else {
+var buf = Clazz.newCharArray (diff, '\0');
+sb.getChars (0, diff, buf, 0);
+sq += buf.toString ();
+}diff = origseq.getLength () - sq.length;
+}
+}
+}}, "jalview.datamodel.SequenceI,jalview.datamodel.AlignmentI,jalview.datamodel.SequenceI");
+Clazz.defineMethod (c$, "hasSelectedColumns",
+function () {
+return (this.selected != null && this.selected.size () > 0);
+});
+Clazz.defineMethod (c$, "hasHiddenColumns",
+function () {
+return this.hiddenColumns != null && this.hiddenColumns.size () > 0;
+});
+Clazz.defineMethod (c$, "hasManyHiddenColumns",
+function () {
+return this.hiddenColumns != null && this.hiddenColumns.size () > 1;
+});
+Clazz.defineMethod (c$, "hideInsertionsFor",
+function (sr) {
+var inserts = sr.getInsertions ();
+for (var r, $r = inserts.iterator (); $r.hasNext () && ((r = $r.next ()) || true);) {
+this.hideColumns (r[0], r[1]);
+}
+}, "jalview.datamodel.SequenceI");
+Clazz.defineMethod (c$, "filterAnnotations",
+function (annotations, filterParams) {
+this.revealAllHiddenColumns ();
+this.clear ();
+var count = 0;
+do {
+if (annotations[count] != null) {
+var itemMatched = false;
+if (filterParams.getThresholdType () === jalview.viewmodel.annotationfilter.AnnotationFilterParameter.ThresholdType.ABOVE_THRESHOLD && annotations[count].value >= filterParams.getThresholdValue ()) {
+itemMatched = true;
+}if (filterParams.getThresholdType () === jalview.viewmodel.annotationfilter.AnnotationFilterParameter.ThresholdType.BELOW_THRESHOLD && annotations[count].value <= filterParams.getThresholdValue ()) {
+itemMatched = true;
+}if (filterParams.isFilterAlphaHelix () && annotations[count].secondaryStructure == 'H') {
+itemMatched = true;
+}if (filterParams.isFilterBetaSheet () && annotations[count].secondaryStructure == 'E') {
+itemMatched = true;
+}if (filterParams.isFilterTurn () && annotations[count].secondaryStructure == 'S') {
+itemMatched = true;
+}var regexSearchString = filterParams.getRegexString ();
+if (regexSearchString != null && !filterParams.getRegexSearchFields ().isEmpty ()) {
+var fields = filterParams.getRegexSearchFields ();
+try {
+if (fields.contains (jalview.viewmodel.annotationfilter.AnnotationFilterParameter.SearchableAnnotationField.DISPLAY_STRING) && annotations[count].displayCharacter.matches (regexSearchString)) {
+itemMatched = true;
+}} catch (pse) {
+if (Clazz.exceptionOf (pse, java.util.regex.PatternSyntaxException)) {
+if (annotations[count].displayCharacter.equals (regexSearchString)) {
+itemMatched = true;
+}} else {
+throw pse;
+}
+}
+if (fields.contains (jalview.viewmodel.annotationfilter.AnnotationFilterParameter.SearchableAnnotationField.DESCRIPTION) && annotations[count].description != null && annotations[count].description.matches (regexSearchString)) {
+itemMatched = true;
+}}if (itemMatched) {
+this.addElement (count);
+}}count++;
+} while (count < annotations.length);
+return false;
+}, "~A,jalview.viewmodel.annotationfilter.AnnotationFilterParameter");
+});
git://source.jalview.org / jalview.git / blobdiff