66330ff4742dfc3b8f924017caf1c6419907bbbf
braney
  Sat Jul 25 11:16:24 2020 -0700
make merged Gencode filters much more similar to old style

diff --git src/hg/hgTracks/bigBedTrack.c src/hg/hgTracks/bigBedTrack.c
index 26e5afb..e45ad57 100644
--- src/hg/hgTracks/bigBedTrack.c
+++ src/hg/hgTracks/bigBedTrack.c
@@ -160,30 +160,93 @@
             || sameString(setting, FILTERBY_MULTIPLE_LIST_ONLY_OR))
                 filter->comparisonType = COMPARE_HASH_LIST_OR;
     else if (sameString(setting, FILTERBY_MULTIPLE_LIST_AND) 
             || sameString(setting, FILTERBY_MULTIPLE_LIST_ONLY_AND))
                 filter->comparisonType = COMPARE_HASH_LIST_AND;
     }
 filter->valueHash = newHash(5);
 filter->numValuesInHash = slCount(choices);
 
 for(; choices; choices = choices->next)
     hashStore(filter->valueHash, choices->name);
 
 return filter;
 }
 
+static void addGencodeFilters(struct cart *cart, struct trackDb *tdb, struct bigBedFilter **pFilters)
+/* Add GENCODE custom bigBed filters. */
+{
+struct bigBedFilter *filter;
+char varName[64];
+struct hash *hash;
+
+/* canonical */
+safef(varName, sizeof(varName), "%s.show.spliceVariants", tdb->track);
+boolean option = cartUsualBoolean(cart, varName, TRUE);
+if (!option)
+    {
+    AllocVar(filter);
+    slAddHead(pFilters, filter);
+    filter->fieldNum = 25;
+    filter->comparisonType = COMPARE_HASH_LIST_OR;
+    hash = newHash(5);
+    filter->valueHash = hash;
+    filter->numValuesInHash = 1;
+    hashStore(hash, "canonical" );
+    }
+
+/* transcript class */
+AllocVar(filter);
+slAddHead(pFilters, filter);
+filter->fieldNum = 20;
+filter->comparisonType = COMPARE_HASH;
+hash = newHash(5);
+filter->valueHash = hash;
+filter->numValuesInHash = 1;
+hashStore(hash,"coding");  // coding is always included
+
+safef(varName, sizeof(varName), "%s.show.noncoding", tdb->track);
+if (cartUsualBoolean(cart, varName, TRUE))
+    {
+    filter->numValuesInHash++;
+    hashStore(hash,"nonCoding");
+    }
+
+safef(varName, sizeof(varName), "%s.show.pseudo", tdb->track);
+if (cartUsualBoolean(cart, varName, FALSE))
+    {
+    filter->numValuesInHash++;
+    hashStore(hash,"pseudo");
+    }
+
+/* tagged sets */
+safef(varName, sizeof(varName), "%s.show.set", tdb->track);
+char *setString = cartUsualString(cart, varName, "basic");
+
+if (differentString(setString, "all"))
+    {
+    AllocVar(filter);
+    slAddHead(pFilters, filter);
+    filter->fieldNum = 23;
+    filter->comparisonType = COMPARE_HASH_LIST_OR;
+    hash = newHash(5);
+    filter->valueHash = hash;
+    filter->numValuesInHash = 1;
+    hashStore(hash, setString);
+    }
+}
+
 struct bigBedFilter *bigBedBuildFilters(struct cart *cart, struct bbiFile *bbi, struct trackDb *tdb)
 /* Build all the numeric and filterBy filters for a bigBed */
 {
 struct bigBedFilter *filters = NULL, *filter;
 struct trackDbFilter *tdbFilters = tdbGetTrackNumFilters(tdb);
 
 if ((tdbFilters == NULL) && !trackDbSettingOn(tdb, "noScoreFilter"))
     {
     AllocVar(filter);
     slAddHead(&filters, filter);
     filter->fieldNum = 4;
     filter->comparisonType = COMPARE_MORE;
     char buffer[2048];
     safef(buffer, sizeof buffer, "%s.scoreFilter", tdb->track);
     filter->value1 = cartUsualDouble(cart, buffer, 0.0);
@@ -202,30 +265,34 @@
     if ((filter = bigBedMakeFilterText(cart, bbi, tdb, tdbFilters->name,  tdbFilters->fieldName)) != NULL)
         slAddHead(&filters, filter);
     }
 
 filterBy_t *filterBySet = filterBySetGet(tdb, cart,NULL);
 filterBy_t *filterBy = filterBySet;
 for (;filterBy != NULL; filterBy = filterBy->next)
     {
     if (filterBy->slChoices && differentString(filterBy->slChoices->name, "All")) 
         {
         if ((filter = bigBedMakeFilterBy(cart, bbi, tdb, filterBy->column, filterBy->slChoices)) != NULL)
             slAddHead(&filters, filter);
         }
     }
 
+/* custom gencode filters */
+if (startsWith("gencodeV", tdb->track))
+    addGencodeFilters(cart, tdb, &filters);
+
 return filters;
 }
 
 
 boolean bigBedFilterInterval(char **bedRow, struct bigBedFilter *filters)
 /* Go through a row and filter based on filters.  Return TRUE if all filters are passed. */
 {
 struct bigBedFilter *filter;
 for(filter = filters; filter; filter = filter->next)
     {
     double val = atof(bedRow[filter->fieldNum]);
 
     switch(filter->comparisonType)
         {
         case COMPARE_WILDCARD: