a2fbae6e90d06cb308aa2e050cd8f77c60c6cc96
galt
  Mon Feb 13 14:38:47 2017 -0800
Oops. fixing accidentally messed up indentation. refs #18737

diff --git src/hg/lib/hui.c src/hg/lib/hui.c
index dbb4428..ec4c0ad 100644
--- src/hg/lib/hui.c
+++ src/hg/lib/hui.c
@@ -438,32 +438,31 @@
 {
 return cfgOptionDefault("browser.documentRoot", DOCUMENT_ROOT);
 }
 
 char *hHelpFile(char *fileRoot)
 /* Given a help file root name (e.g. "hgPcrResult" or "cutters"),
 * prepend the complete help directory path and add .html suffix.
 * Do not free the statically allocated result. */
 {
 static char helpName[PATH_LEN];
 /* This cfgOption comes from Todd Lowe's hgTrackUi.c addition (r1.230): */
 char *helpDir = cfgOption("help.html");
 if (helpDir != NULL)
     safef(helpName, sizeof(helpName), "%s/%s.html", helpDir, fileRoot);
 else
-safef(helpName, sizeof(helpName), "%s%s/%s.html", hDocumentRoot(),
-      HELP_DIR, fileRoot);
+    safef(helpName, sizeof(helpName), "%s%s/%s.html", hDocumentRoot(), HELP_DIR, fileRoot);
 return helpName;
 }
 
 char *hFileContentsOrWarning(char *file)
 /* Return the contents of the html file, or a warning message.
 * The file path may begin with hDocumentRoot(); if it doesn't, it is
 * assumed to be relative and hDocumentRoot() will be prepended. */
 {
 if (isEmpty(file))
     return cloneString("<BR>Program Error: Empty file name for include file"
 		       "<BR>\n");
 char path[PATH_LEN];
 char *docRoot = hDocumentRoot();
 if (startsWith(docRoot, file))
     safecpy(path, sizeof path, file);
@@ -721,31 +720,32 @@
 void hideShowDropDownWithClassAndExtra(char *varName, boolean show, char *class, struct slPair *events)
 // Make hide/show dropdown for varName
 {
 static char *hideShow[] =
     {
     "hide",
     "show"
     };
 cgiMakeDropListClassWithStyleAndJavascript(varName, hideShow, ArraySize(hideShow),
 				       hideShow[show], class, TV_DROPDOWN_STYLE, events);
 }
 
 
 /****** Some stuff for stsMap related controls *******/
 
-static char *stsMapOptions[] = {
+static char *stsMapOptions[] = 
+    {
     "All Genetic",
     "Genethon",
     "Marshfield",
     "deCODE",
     "GeneMap 99",
     "Whitehead YAC",
     "Whitehead RH",
     "Stanford TNG",
     };
 
 enum stsMapOptEnum smoeStringToEnum(char *string)
 /* Convert from string to enum representation. */
 {
 int x = stringIx(string, stsMapOptions);
 if (x < 0)
@@ -756,93 +756,96 @@
 char *smoeEnumToString(enum stsMapOptEnum x)
 /* Convert from enum to string representation. */
 {
 return stsMapOptions[x];
 }
 
 void smoeDropDown(char *var, char *curVal)
 /* Make drop down of options. */
 {
 cgiMakeDropList(var, stsMapOptions, ArraySize(stsMapOptions),
     curVal);
 }
 
 /****** Some stuff for stsMapMouseNew related controls *******/
 
-static char *stsMapMouseOptions[] = {
+static char *stsMapMouseOptions[] = 
+    {
     "All Genetic",
     "WICGR Genetic Map",
     "MGD Genetic Map",
     "RH",
     };
 
 enum stsMapMouseOptEnum smmoeStringToEnum(char *string)
 /* Convert from string to enum representation. */
 {
 int x = stringIx(string, stsMapMouseOptions);
 if (x < 0)
     errAbort("Unknown option %s", string);
 return x;
 }
 
 char *smmoeEnumToString(enum stsMapMouseOptEnum x)
 /* Convert from enum to string representation. */
 {
 return stsMapMouseOptions[x];
 }
 
 void smmoeDropDown(char *var, char *curVal)
 /* Make drop down of options. */
 {
 cgiMakeDropList(var, stsMapMouseOptions, ArraySize(stsMapMouseOptions),
     curVal);
 }
 
 /****** Some stuff for stsMapRat related controls *******/
 
-static char *stsMapRatOptions[] = {
+static char *stsMapRatOptions[] = 
+    {
     "All Genetic",
     "FHHxACI",
     "SHRSPxBN",
     "RH",
     };
 
 enum stsMapRatOptEnum smroeStringToEnum(char *string)
 /* Convert from string to enum representation. */
 {
 int x = stringIx(string, stsMapRatOptions);
 if (x < 0)
     errAbort("Unknown option %s", string);
 return x;
 }
 
 char *smroeEnumToString(enum stsMapRatOptEnum x)
 /* Convert from enum to string representation. */
 {
 return stsMapRatOptions[x];
 }
 
 void smroeDropDown(char *var, char *curVal)
 /* Make drop down of options. */
 {
 cgiMakeDropList(var, stsMapRatOptions, ArraySize(stsMapRatOptions),
     curVal);
 }
 
 /****** Some stuff for fishClones related controls *******/
 
-static char *fishClonesOptions[] = {
+static char *fishClonesOptions[] = 
+    {
     "Fred Hutchinson CRC",
     "National Cancer Institute",
     "Sanger Centre",
     "Roswell Park Cancer Institute",
     "Cedars-Sinai Medical Center",
     "Los Alamos National Lab",
     "UC San Francisco",
     };
 
 enum fishClonesOptEnum fcoeStringToEnum(char *string)
 /* Convert from string to enum representation. */
 {
 int x = stringIx(string, fishClonesOptions);
 if (x < 0)
     errAbort("Unknown option %s", string);
@@ -852,31 +855,32 @@
 char *fcoeEnumToString(enum fishClonesOptEnum x)
 /* Convert from enum to string representation. */
 {
 return fishClonesOptions[x];
 }
 
 void fcoeDropDown(char *var, char *curVal)
 /* Make drop down of options. */
 {
 cgiMakeDropList(var, fishClonesOptions, ArraySize(fishClonesOptions),
     curVal);
 }
 
 /****** Some stuff for recombRate related controls *******/
 
-static char *recombRateOptions[] = {
+static char *recombRateOptions[] = 
+    {
     "deCODE Sex Averaged Distances",
     "deCODE Female Distances",
     "deCODE Male Distances",
     "Marshfield Sex Averaged Distances",
     "Marshfield Female Distances",
     "Marshfield Male Distances",
     "Genethon Sex Averaged Distances",
     "Genethon Female Distances",
     "Genethon Male Distances",
     };
 
 enum recombRateOptEnum rroeStringToEnum(char *string)
 /* Convert from string to enum representation. */
 {
 int x = stringIx(string, recombRateOptions);
@@ -888,89 +892,92 @@
 char *rroeEnumToString(enum recombRateOptEnum x)
 /* Convert from enum to string representation. */
 {
 return recombRateOptions[x];
 }
 
 void rroeDropDown(char *var, char *curVal)
 /* Make drop down of options. */
 {
 cgiMakeDropList(var, recombRateOptions, ArraySize(recombRateOptions),
     curVal);
 }
 
 /****** Some stuff for recombRateRat related controls *******/
 
-static char *recombRateRatOptions[] = {
+static char *recombRateRatOptions[] = 
+    {
     "SHRSPxBN Sex Averaged Distances",
     "FHHxACI Sex Averaged Distances",
     };
 
 enum recombRateRatOptEnum rrroeStringToEnum(char *string)
 /* Convert from string to enum representation. */
 {
 int x = stringIx(string, recombRateRatOptions);
 if (x < 0)
     errAbort("Unknown option %s", string);
 return x;
 }
 
 char *rrroeEnumToString(enum recombRateRatOptEnum x)
 /* Convert from enum to string representation. */
 {
 return recombRateRatOptions[x];
 }
 
 void rrroeDropDown(char *var, char *curVal)
 /* Make drop down of options. */
 {
 cgiMakeDropList(var, recombRateRatOptions, ArraySize(recombRateRatOptions),
     curVal);
 }
 
 /****** Some stuff for recombRateMouse related controls *******/
 
-static char *recombRateMouseOptions[] = {
+static char *recombRateMouseOptions[] = 
+    {
     "WI Genetic Map Sex Averaged Distances",
     "MGD Genetic Map Sex Averaged Distances",
     };
 
 enum recombRateMouseOptEnum rrmoeStringToEnum(char *string)
 /* Convert from string to enum representation. */
 {
 int x = stringIx(string, recombRateMouseOptions);
 if (x < 0)
     errAbort("Unknown option %s", string);
 return x;
 }
 
 char *rrmoeEnumToString(enum recombRateMouseOptEnum x)
 /* Convert from enum to string representation. */
 {
 return recombRateMouseOptions[x];
 }
 
 void rrmoeDropDown(char *var, char *curVal)
 /* Make drop down of options. */
 {
 cgiMakeDropList(var, recombRateMouseOptions, ArraySize(recombRateMouseOptions),
     curVal);
 }
 
 /****** Some stuff for CGH NCI60 related controls *******/
 
-static char *cghNci60Options[] = {
+static char *cghNci60Options[] = 
+    {
     "Tissue Averages",
     "BREAST",
     "CNS",
     "COLON",
     "LEUKEMIA",
     "LUNG",
     "MELANOMA",
     "OVARY",
     "PROSTATE",
     "RENAL",
     "All Cell Lines",
     };
 
 enum cghNci60OptEnum cghoeStringToEnum(char *string)
 /* Convert from string to enum representation. */
@@ -984,31 +991,32 @@
 char *cghoeEnumToString(enum cghNci60OptEnum x)
 /* Convert from enum to string representation. */
 {
 return cghNci60Options[x];
 }
 
 void cghoeDropDown(char *var, char *curVal)
 /* Make drop down of options. */
 {
 cgiMakeDropList(var, cghNci60Options, ArraySize(cghNci60Options),
     curVal);
 }
 
 /****** Some stuff for nci60 related controls *******/
 
-static char *nci60Options[] = {
+static char *nci60Options[] = 
+    {
     "Tissue Averages",
     "All Cell Lines",
     "BREAST",
     "CNS",
     "COLON",
     "LEUKEMIA",
     "MELANOMA",
     "OVARIAN",
     "PROSTATE",
     "RENAL",
     "NSCLC",
     "DUPLICATE",
     "UNKNOWN"
     };
 
@@ -1236,38 +1244,35 @@
 struct trackDb *tdbLevel = tdb;
 if (differentString(tdb->track, name) && tdb->parent != NULL)
     tdbLevel = tdb->parent;
 
 boolean apropos = indelAppropriate(tdb);
 if (apropos && (basesPerPixel > 0.0))
     {
     // check indel max zoom
     float showIndelMaxZoom = trackDbFloatSettingOrDefault(tdbLevel, "showIndelMaxZoom", -1.0);
     if ((showIndelMaxZoom >= 0)
 	&& ((basesPerPixel > showIndelMaxZoom) || (showIndelMaxZoom == 0.0)))
 	apropos = FALSE;
     }
 
 if (retDoubleInsert)
-*retDoubleInsert = apropos &&
-		   tdbOrCartBoolean(cart, tdbLevel, INDEL_DOUBLE_INSERT, "off");
+    *retDoubleInsert = apropos && tdbOrCartBoolean(cart, tdbLevel, INDEL_DOUBLE_INSERT, "off");
 if (retQueryInsert)
-*retQueryInsert = apropos &&
-		  tdbOrCartBoolean(cart, tdbLevel, INDEL_QUERY_INSERT, "off");
+    *retQueryInsert = apropos && tdbOrCartBoolean(cart, tdbLevel, INDEL_QUERY_INSERT, "off");
 if (retPolyA)
-*retPolyA = apropos &&
-	    tdbOrCartBoolean(cart, tdbLevel, INDEL_POLY_A, "off");
+    *retPolyA = apropos && tdbOrCartBoolean(cart, tdbLevel, INDEL_POLY_A, "off");
 }
 
 void indelEnabled(struct cart *cart, struct trackDb *tdb, float basesPerPixel,
 	      boolean *retDoubleInsert, boolean *retQueryInsert,
 	      boolean *retPolyA)
 /* Query cart & trackDb to determine what indel display (if any) is enabled. Set
 * basesPerPixel to 0.0 to disable check for zoom level.  */
 {
 indelEnabledByName(cart,tdb,tdb->track,basesPerPixel,retDoubleInsert,retQueryInsert,retPolyA);
 }
 
 static void indelShowOptionsWithNameExt(struct cart *cart, struct trackDb *tdb, char *name,
 				    char *queryTerm,
 				    boolean includeDoubleInsert, boolean includePolyA)
 /* Make HTML inputs for indel display options if any are applicable. */
@@ -1310,120 +1315,125 @@
 
 static void indelShowOptionsWithName(struct cart *cart, struct trackDb *tdb, char *name)
 /* Make HTML inputs for indel display options if any are applicable. */
 {
 indelShowOptionsWithNameExt(cart, tdb, name, "query", TRUE, TRUE);
 }
 
 void indelShowOptions(struct cart *cart, struct trackDb *tdb)
 /* Make HTML inputs for indel display options if any are applicable. */
 {
 indelShowOptionsWithName(cart, tdb, tdb->track);
 }
 
 /****** base position (ruler) controls *******/
 
-static char *zoomOptions[] = {
+static char *zoomOptions[] = 
+    {
     ZOOM_1PT5X,
     ZOOM_3X,
     ZOOM_10X,
     ZOOM_100X,
     ZOOM_BASE
     };
 
 void zoomRadioButtons(char *var, char *curVal)
 /* Make a list of radio buttons for all zoom options */
 {
 int i;
 int size = ArraySize(zoomOptions);
 for (i = 0; i < size; i++)
     {
     char *s = zoomOptions[i];
     cgiMakeRadioButton(var, s, sameString(s, curVal));
     printf(" %s &nbsp;&nbsp;", s);
     }
 }
 
 /****** Some stuff for affy related controls *******/
 
-static char *affyOptions[] = {
+static char *affyOptions[] = 
+    {
     "Chip Type",
     "Chip ID",
     "Tissue Averages"
     };
 
 enum affyOptEnum affyStringToEnum(char *string)
 /* Convert from string to enum representation. */
 {
 int x = stringIx(string, affyOptions);
 if (x < 0)
     errAbort("hui::affyStringToEnum() - Unknown option %s", string);
 return x;
 }
 
 char *affyEnumToString(enum affyOptEnum x)
 /* Convert from enum to string representation. */
 {
 return affyOptions[x];
 }
 
 void affyDropDown(char *var, char *curVal)
 /* Make drop down of options. */
 {
 cgiMakeDropList(var, affyOptions, ArraySize(affyOptions),
     curVal);
 }
 
 /****** Some stuff for affy all exon related controls *******/
 
-static char *affyAllExonOptions[] = {
+static char *affyAllExonOptions[] = 
+    {
     "Chip",
     "Tissue Averages"
     };
 
 enum affyAllExonOptEnum affyAllExonStringToEnum(char *string)
 /* Convert from string to enum representation. */
 {
 int x = stringIx(string, affyAllExonOptions);
 if (x < 0)
     errAbort("hui::affyAllExonStringToEnum() - Unknown option %s", string);
 return x;
 }
 
 char *affyAllExonEnumToString(enum affyAllExonOptEnum x)
 /* Convert from enum to string representation. */
 {
 return affyAllExonOptions[x];
 }
 
 void affyAllExonDropDown(char *var, char *curVal)
 /* Make drop down of options. */
 {
 cgiMakeDropList(var, affyAllExonOptions, ArraySize(affyAllExonOptions),
     curVal);
 }
 
 /****** Some stuff for Rosetta related controls *******/
 
-static char *rosettaOptions[] = {
+static char *rosettaOptions[] = 
+    {
     "All Experiments",
     "Common Reference and Other",
     "Common Reference",
     "Other Exps"
     };
 
-static char *rosettaExonOptions[] = {
+static char *rosettaExonOptions[] = 
+    {
     "Confirmed Only",
     "Predicted Only",
     "All",
     };
 
 enum rosettaOptEnum rosettaStringToEnum(char *string)
 /* Convert from string to enum representation. */
 {
 int x = stringIx(string, rosettaOptions);
 if (x < 0)
     errAbort("hui::rosettaStringToEnum() - Unknown option %s", string);
 return x;
 }
 
 char *rosettaEnumToString(enum rosettaOptEnum x)
@@ -1449,31 +1459,32 @@
 }
 
 char *rosettaExonEnumToString(enum rosettaExonOptEnum x)
 /* Convert from enum to string representation of exon types. */
 {
 return rosettaExonOptions[x];
 }
 
 void rosettaExonDropDown(char *var, char *curVal)
 /* Make drop down of exon type options. */
 {
 cgiMakeDropList(var, rosettaExonOptions, ArraySize(rosettaExonOptions), curVal);
 }
 
 /****** Options for the net track level display options *******/
-static char *netLevelOptions[] = {
+static char *netLevelOptions[] = 
+    {
     NET_LEVEL_0,
     NET_LEVEL_1,
     NET_LEVEL_2,
     NET_LEVEL_3,
     NET_LEVEL_4,
     NET_LEVEL_5,
     NET_LEVEL_6
     };
 
 enum netLevelEnum netLevelStringToEnum(char *string)
 /* Convert from string to enum representation. */
 {
 int x = stringIx(string, netLevelOptions);
 if (x < 0)
     errAbort("hui::netLevelStringToEnum() - Unknown option %s", string);
@@ -1481,205 +1492,212 @@
 }
 
 char *netLevelEnumToString(enum netLevelEnum x)
 /* Convert from enum to string representation. */
 {
 return netLevelOptions[x];
 }
 
 void netLevelDropDown(char *var, char *curVal)
 /* Make drop down of options. */
 {
 cgiMakeDropList(var, netLevelOptions, ArraySize(netLevelOptions), curVal);
 }
 
 /****** Options for the net track color options *******/
-static char *netColorOptions[] = {
+static char *netColorOptions[] = 
+    {
     CHROM_COLORS,
     GRAY_SCALE
     };
 
 enum netColorEnum netColorStringToEnum(char *string)
 /* Convert from string to enum representation. */
 {
 int x = stringIx(string, netColorOptions);
 if (x < 0)
     errAbort("hui::netColorStringToEnum() - Unknown option %s", string);
 return x;
 }
 
 char *netColorEnumToString(enum netColorEnum x)
 /* Convert from enum to string representation. */
 {
 return netColorOptions[x];
 }
 
 void netColorDropDown(char *var, char *curVal)
 /* Make drop down of options. */
 {
 cgiMakeDropList(var, netColorOptions, ArraySize(netColorOptions), curVal);
 }
 
 /****** Options for the chain track color options *******/
-static char *chainColorOptions[] = {
+static char *chainColorOptions[] = 
+    {
     CHROM_COLORS,
     SCORE_COLORS,
     NO_COLORS
     };
 
 enum chainColorEnum chainColorStringToEnum(char *string)
 /* Convert from string to enum representation. */
 {
 int x = stringIx(string, chainColorOptions);
 if (x < 0)
     errAbort("hui::chainColorStringToEnum() - Unknown option %s", string);
 return x;
 }
 
 char *chainColorEnumToString(enum chainColorEnum x)
 /* Convert from enum to string representation. */
 {
 return chainColorOptions[x];
 }
 
 void chainColorDropDown(char *var, char *curVal)
 /* Make drop down of options. */
 {
 cgiMakeDropList(var, chainColorOptions, ArraySize(chainColorOptions), curVal);
 }
 
 /****** Options for the wiggle track Windowing *******/
 
-static char *wiggleWindowingOptions[] = {
+static char *wiggleWindowingOptions[] = 
+    {
     "mean+whiskers",
     "maximum",
     "mean",
     "minimum",
     };
 
 enum wiggleWindowingEnum wiggleWindowingStringToEnum(char *string)
 /* Convert from string to enum representation. */
 {
 int x = stringIx(string, wiggleWindowingOptions);
 if (x < 0)
     errAbort("hui::wiggleWindowingStringToEnum() - Unknown option %s", string);
 return x;
 }
 
 char *wiggleWindowingEnumToString(enum wiggleWindowingEnum x)
 /* Convert from enum to string representation. */
 {
 return wiggleWindowingOptions[x];
 }
 
 void wiggleWindowingDropDown(char *var, char *curVal)
 /* Make drop down of options. */
 {
 cgiMakeDropList(var, wiggleWindowingOptions, ArraySize(wiggleWindowingOptions),
     curVal);
 }
 
 /****** Options for the wiggle track Smoothing *******/
 
-static char *wiggleSmoothingOptions[] = {
+static char *wiggleSmoothingOptions[] = 
+    {
     "OFF", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11",
     "12", "13", "14", "15", "16"
     };
 
 enum wiggleSmoothingEnum wiggleSmoothingStringToEnum(char *string)
 /* Convert from string to enum representation. */
 {
 int x = stringIx(string, wiggleSmoothingOptions);
 if (x < 0)
     errAbort("hui::wiggleSmoothingStringToEnum() - Unknown option %s", string);
 return x;
 }
 
 char *wiggleSmoothingEnumToString(enum wiggleSmoothingEnum x)
 /* Convert from enum to string representation. */
 {
 return wiggleSmoothingOptions[x];
 }
 
 void wiggleSmoothingDropDown(char *var, char *curVal)
 /* Make drop down of options. */
 {
 cgiMakeDropList(var, wiggleSmoothingOptions, ArraySize(wiggleSmoothingOptions),
     curVal);
 }
 
 /****** Options for the wiggle track y Line Mark On/Off *******/
 
-static char *wiggleYLineMarkOptions[] = {
+static char *wiggleYLineMarkOptions[] = 
+    {
     "OFF",
     "ON"
     };
 
 enum wiggleYLineMarkEnum wiggleYLineMarkStringToEnum(char *string)
 /* Convert from string to enum representation. */
 {
 int x = stringIx(string, wiggleYLineMarkOptions);
 if (x < 0)
     errAbort("hui::wiggleYLineMarkStringToEnum() - Unknown option %s", string);
 return x;
 }
 
 char *wiggleYLineMarkEnumToString(enum wiggleYLineMarkEnum x)
 /* Convert from enum to string representation. */
 {
 return wiggleYLineMarkOptions[x];
 }
 
 void wiggleYLineMarkDropDown(char *var, char *curVal)
 /* Make drop down of options. */
 {
 cgiMakeDropList(var, wiggleYLineMarkOptions, ArraySize(wiggleYLineMarkOptions),
     curVal);
 }
 
 /****** Options for the wiggle track AutoScale *******/
 
-static char *wiggleScaleOptions[] = {
+static char *wiggleScaleOptions[] = 
+    {
     "use vertical viewing range setting",
     "auto-scale to data view"
     };
 
 enum wiggleScaleOptEnum wiggleScaleStringToEnum(char *string)
 /* Convert from string to enum representation. */
 {
 int x = stringIx(string, wiggleScaleOptions);
 if (x < 0)
     errAbort("hui::wiggleScaleStringToEnum() - Unknown option %s", string);
 return x;
 }
 
 char *wiggleScaleEnumToString(enum wiggleScaleOptEnum x)
 /* Convert from enum to string representation. */
 {
 return wiggleScaleOptions[x];
 }
 
 void wiggleScaleDropDown(char *var, char *curVal)
 /* Make drop down of options. */
 {
 cgiMakeDropList(var, wiggleScaleOptions, ArraySize(wiggleScaleOptions),
     curVal);
 }
 
 /****** Options for the wiggle track type of graph *******/
 
-static char *wiggleGraphOptions[] = {
+static char *wiggleGraphOptions[] = 
+    {
     "points",
     "bar",
     };
 
 enum wiggleGraphOptEnum wiggleGraphStringToEnum(char *string)
 /* Convert from string to enum representation. */
 {
 int x = stringIx(string, wiggleGraphOptions);
 if (x < 0)
     errAbort("hui::wiggleGraphStringToEnum() - Unknown option %s", string);
 return x;
 }
 
 char *wiggleGraphEnumToString(enum wiggleGraphOptEnum x)
 /* Convert from enum to string representation. */
@@ -1719,169 +1737,176 @@
 /* Convert from string to enum representation. */
 {
 int x = stringIx(string, aggregateValues);
 if (x < 0)
     errAbort("hui::wiggleAggregateFunctionStringToEnum() - Unknown option %s", string);
 return x;
 }
 
 void aggregateDropDown(char *var, char *curVal)
 /* Make drop down menu for aggregate strategy */
 {
 cgiMakeDropListFull(var, aggregateLabels, aggregateValues,
     ArraySize(aggregateValues), curVal, NULL, NULL);
 }
 
-static char *wiggleTransformFuncOptions[] = {
+static char *wiggleTransformFuncOptions[] = 
+    {
     "NONE",
     "LOG"
     };
 
-static char *wiggleTransformFuncLabels[] = {
+static char *wiggleTransformFuncLabels[] = 
+    {
     "NONE",
     "LOG (ln(1+x))"
     };
 
 enum wiggleTransformFuncEnum wiggleTransformFuncToEnum(char *string)
 /* Convert from string to enum representation. */
 {
 int x = stringIx(string, wiggleTransformFuncOptions);
 if (x < 0)
     errAbort("hui::wiggleTransformFuncToEnum() - Unknown option %s", string);
 return x;
 }
 
 void wiggleTransformFuncDropDown(char *var, char *curVal)
 /* Make drop down of options. */
 {
 cgiMakeDropListFull(var, wiggleTransformFuncLabels, wiggleTransformFuncOptions,
 ArraySize(wiggleTransformFuncOptions), curVal, NULL, NULL);
 }
 
-static char *wiggleAlwaysZeroOptions[] = {
+static char *wiggleAlwaysZeroOptions[] = 
+    {
     "OFF",
     "ON"
     };
 
 enum wiggleAlwaysZeroEnum wiggleAlwaysZeroToEnum(char *string)
 /* Convert from string to enum representation. */
 {
 int x = stringIx(string, wiggleAlwaysZeroOptions);
 if (x < 0)
     errAbort("hui::wiggleAlwaysZeroToEnum() - Unknown option %s", string);
 return x;
 }
 
 void wiggleAlwaysZeroDropDown(char *var, char *curVal)
 /* Make drop down of options. */
 {
 cgiMakeDropList(var, wiggleAlwaysZeroOptions,
 ArraySize(wiggleAlwaysZeroOptions), curVal);
 }
 
 
 /****** Options for the wiggle track horizontal grid lines *******/
 
-static char *wiggleGridOptions[] = {
+static char *wiggleGridOptions[] = 
+    {
     "ON",
     "OFF"
     };
 
 enum wiggleGridOptEnum wiggleGridStringToEnum(char *string)
 /* Convert from string to enum representation. */
 {
 int x = stringIx(string, wiggleGridOptions);
 if (x < 0)
     errAbort("hui::wiggleGridStringToEnum() - Unknown option %s", string);
 return x;
 }
 
 char *wiggleGridEnumToString(enum wiggleGridOptEnum x)
 /* Convert from enum to string representation. */
 {
 return wiggleGridOptions[x];
 }
 
 void wiggleGridDropDown(char *var, char *curVal)
 /* Make drop down of options. */
 {
 cgiMakeDropList(var, wiggleGridOptions, ArraySize(wiggleGridOptions),
     curVal);
 }
 
 /****** Some stuff for wiggle track related controls *******/
 
-static char *wiggleOptions[] = {
+static char *wiggleOptions[] = 
+    {
     "samples only",
     "linear interpolation"
     };
 
 enum wiggleOptEnum wiggleStringToEnum(char *string)
 /* Convert from string to enum representation. */
 {
 int x = stringIx(string, wiggleOptions);
 if (x < 0)
     errAbort("hui::wiggleStringToEnum() - Unknown option %s", string);
 return x;
 }
 
 char *wiggleEnumToString(enum wiggleOptEnum x)
 /* Convert from enum to string representation. */
 {
 return wiggleOptions[x];
 }
 
 void wiggleDropDown(char *var, char *curVal)
 /* Make drop down of options. */
 {
 cgiMakeDropList(var, wiggleOptions, ArraySize(wiggleOptions),
     curVal);
 }
 
 
 /****** Some stuff for GCwiggle track related controls *******/
 
-static char *GCwiggleOptions[] = {
+static char *GCwiggleOptions[] = 
+    {
     "samples only",
     "linear interpolation"
     };
 
 enum GCwiggleOptEnum GCwiggleStringToEnum(char *string)
 /* Convert from string to enum representation. */
 {
 int x = stringIx(string, GCwiggleOptions);
 if (x < 0)
     errAbort("hui::GCwiggleStringToEnum() - Unknown option %s", string);
 return x;
 }
 
 char *GCwiggleEnumToString(enum GCwiggleOptEnum x)
 /* Convert from enum to string representation. */
 {
 return GCwiggleOptions[x];
 }
 
 void GCwiggleDropDown(char *var, char *curVal)
 /* Make drop down of options. */
 {
 cgiMakeDropList(var, GCwiggleOptions, ArraySize(GCwiggleOptions),
     curVal);
 }
 
 /****** Some stuff for chimp track related controls *******/
 
-static char *chimpOptions[] = {
+static char *chimpOptions[] = 
+    {
     "samples only",
     "linear interpolation"
     };
 
 enum chimpOptEnum chimpStringToEnum(char *string)
 /* Convert from string to enum representation. */
 {
 int x = stringIx(string, chimpOptions);
 if (x < 0)
     errAbort("hui::chimpStringToEnum() - Unknown option %s", string);
 return x;
 }
 
 char *chimpEnumToString(enum chimpOptEnum x)
 /* Convert from enum to string representation. */
@@ -2088,31 +2113,32 @@
 if (tdbList == NULL || *tdbList == NULL)
     {
     theTdbs = hTrackDb(db);
     if (tdbList != NULL)
 	*tdbList = theTdbs;
     }
 else
     theTdbs = *tdbList;
 struct hash *trackHash = newHash(7);
 rAddTrackListToHash(trackHash, theTdbs, chrom, !withComposites);
 return trackHash;
 }
 
 /****** Stuff for acembly related options *******/
 
-static char *acemblyOptions[] = {
+static char *acemblyOptions[] = 
+    {
     "all genes",
     "main",
     "putative",
     };
 
 enum acemblyOptEnum acemblyStringToEnum(char *string)
 /* Convert from string to enum representation. */
 {
 int x = stringIx(string, acemblyOptions);
 if (x < 0)
     errAbort("hui::acemblyStringToEnum() - Unknown option %s", string);
 return x;
 }
 
 char *acemblyEnumToString(enum acemblyOptEnum x)