f63a7870053591e873ee5492217294d82edd88f8
braney
  Sun Jan 14 15:13:25 2024 -0800
when a track overflows and it's a track that can do density coverage we
go straight into density coverage mode instead of reducing visibility

diff --git src/hg/hgTracks/simpleTracks.c src/hg/hgTracks/simpleTracks.c
index 5e35448..61532b2 100644
--- src/hg/hgTracks/simpleTracks.c
+++ src/hg/hgTracks/simpleTracks.c
@@ -372,30 +372,33 @@
 {
 boolean doWiggle = FALSE;
 char *setting = trackDbSetting(tg->tdb, "maxWindowCoverage" );
 if (setting)
     {
     unsigned size = sqlUnsigned(setting);
     if ((size > 0) && ((winEnd - winStart) > size))
         doWiggle = TRUE;
     }
 return doWiggle;
 }
 
 boolean checkIfWiggling(struct cart *cart, struct track *tg)
 /* Check to see if a track should be drawing as a wiggle. */
 {
+if (tg->limitWiggle)
+    return TRUE;
+
 boolean doWiggle = cartOrTdbBoolean(cart, tg->tdb, "doWiggle" , FALSE);
 
 if (!doWiggle)
     doWiggle = winTooBigDoWiggle(cart, tg);
 
 if (doWiggle && isEmpty(tg->networkErrMsg))
     {
     tg->drawLeftLabels = wigLeftLabels;
     tg->colorShades = shadesOfGray;
     tg->mapsSelf = TRUE;
     }
 
 return doWiggle;
 }
 
@@ -11284,30 +11287,36 @@
 subtrack->subTrackVis = enabled;
 return enabled;
 }
 
 static int subtrackCount(struct track *trackList)
 /* Count the number of visible subtracks in (sub)trackList. */
 {
 struct track *subtrack;
 int ct = 0;
 for (subtrack = trackList; subtrack; subtrack = subtrack->next)
     if (isSubtrackVisible(subtrack))
         ct++;
 return ct;
 }
 
+static boolean canWiggle(struct track *tg)
+/* Is this a track type that can wiggle. */
+{
+return tg->isBigBed;
+}
+
 enum trackVisibility limitVisibility(struct track *tg)
 /* Return default visibility limited by number of items and
  * by parent visibility if part of a coposite track.
  * This also sets tg->height. */
 {
 if (!tg->limitedVisSet)
     {
     tg->limitedVisSet = TRUE;  // Prevents recursive loop!
 
     // optional setting to draw labels onto the feature boxes, not next to them
     char *setting = cartOrTdbString(cart, tg->tdb, "labelOnFeature", NULL);
     if (setting)
         {
         if (sameString(setting, "on") || sameString(setting, "true"))
             tg->drawLabelInBox = TRUE;
@@ -11328,60 +11337,76 @@
         return tvHide;
         }
     if (tg->subtracks != NULL)
         {
         struct track *subtrack;
         int subCnt = subtrackCount(tg->subtracks);
         maxHeight = maxHeight * max(subCnt,1);
         //if (subCnt > 4)
         //    maxHeight *= 2; // NOTE: Large composites should suffer an additional restriction.
         if (!tg->syncChildVisToSelf)
             {
             for (subtrack = tg->subtracks;  subtrack != NULL; subtrack = subtrack->next)
                 limitVisibility(subtrack);
             }
         }
+    if (canWiggle(tg))   // if this is a track type that can wiggle, we want to go straight to that rather than reduce visibility
+        {
+        while  ((h = tg->totalHeight(tg, vis)) > maxHeight && vis != tvDense)
+            {
+            tg->limitWiggle = TRUE;
+            }
+        if ( tg->limitWiggle)   // auto-density coverage is alway tvFull
+            tg->visibility = tg->limitedVis = tvFull;
+        else
+            tg->limitedVis = vis;
+        }
+    else
+        {
         while ((h = tg->totalHeight(tg, vis)) > maxHeight && vis != tvDense)
             {
             if (vis == tvFull && tg->canPack)
                 vis = tvPack;
             else if (vis == tvPack)
                 vis = tvSquish;
             else
                 vis = tvDense;
             }
-    tg->height = h;
+
         if (tg->limitedVis == tvHide)
             tg->limitedVis = vis;
         else
             tg->limitedVis = tvMin(vis,tg->limitedVis);
+        }
 
+    tg->height = h;
     if (tg->syncChildVisToSelf)
         {
         struct track *subtrack;
 	for (subtrack = tg->subtracks;  subtrack != NULL; subtrack = subtrack->next)
 	    {
 	    subtrack->visibility = tg->visibility;
 	    subtrack->limitedVis = tg->limitedVis;
             subtrack->limitedVisSet = tg->limitedVisSet;
             }
         }
     else if (tdbIsComposite(tg->tdb)) // If a composite is restricted,
         {                             // it's children should be atleast as restricted.
         struct track *subtrack;
         for (subtrack = tg->subtracks;  subtrack != NULL; subtrack = subtrack->next)
             {
+            if ( tg->limitWiggle) // these are always in tvFull
                 subtrack->limitedVis = tvMin(subtrack->limitedVis, tg->limitedVis);
             // But don't prevent subtracks from being further restricted!
             //subtrack->limitedVisSet = tg->limitedVisSet;
             }
         }
 
     if (tg->height == 0 && tg->limitedVis != tvHide)
         tg->limitedVisSet = FALSE;  // Items may not be loaded yet, so going to need to check again
     }
 return tg->limitedVis;
 }
 
 void compositeTrackVis(struct track *track)
 /* set visibilities of subtracks */
 {