void checkTrackDb(struct trackDb *trackObjs, char *composite,
struct hash *mdbHash)
// check through trackDb for tables that begin with composite
// and check to see if they are represented in the metaDb.ra
{
struct trackDb *trackObj;
verbose(1, "----------------------------------------------\n");
verbose(1, "Checking that tables in trackDb are in metaDb \n");
verbose(1, "----------------------------------------------\n");
for(trackObj = trackObjs; trackObj; trackObj = trackObj->next)
{
char *table = trackObj->table;
if (table == NULL)
table = trackObj->track;
if (startsWith(composite, table))
{
char *compSetting = trackDbSetting(trackObj, "compositeTrack");
if ((compSetting != NULL) && sameString("on", compSetting))
continue;
char *viewSetting = trackDbSetting(trackObj, "view");
if (viewSetting != NULL)
continue;
if (hashLookup(mdbHash, table) == NULL)
warn("trackDb entry %s isn't in metaDb", table);
}
else
if (! onlyCompTdb)
warn("trackDb entry %s doesn't start with %s", table, composite);
}
}
static struct customTrack *chromGraphLoader(struct customFactory *fac,
struct hash *chromHash, struct customPp *cpp, struct customTrack *track,
boolean dbRequested)
/* Load up chromGraph data until get next track line. */
{
/* See if binary file has already been made. If so then
* no need for rest of this routine. */
struct trackDb *tdb = track->tdb;
struct hash *settings = tdb->settingsHash;
char *binaryFileName = hashFindVal(settings, "binaryFile");
if (binaryFileName != NULL)
{
if (fileExists(binaryFileName))
return track;
else
return NULL;
}
return chromGraphParser(track->genomeDb, cpp,
trackDbSettingOrDefault(tdb, "formatType", cgfFormatGuess),
trackDbSettingOrDefault(tdb, "markerType", cgfMarkerGuess),
trackDbSettingOrDefault(tdb, "columnLabels", cgfColLabelGuess),
trackDbSetting(tdb, "name"),
trackDbSetting(tdb, "description"),
tdb->settingsHash, FALSE);
}
struct consWiggle *wigMafWiggles(char *db, struct trackDb *tdb)
/* get conservation wiggle table names and labels from trackDb setting,
ignoring those where table doesn't exist */
{
char *fields[20];
int fieldCt;
int i;
char *wigTable, *wigLabel;
struct consWiggle *wig, *wigList = NULL;
char *setting = trackDbSetting(tdb, CONS_WIGGLE);
if (!setting)
return NULL;
fieldCt = chopLine(cloneString(setting), fields);
for (i = 0; i < fieldCt; i += 3)
{
wigTable = fields[i];
if (hTableExists(db, wigTable));
{
AllocVar(wig);
wig->table = cloneString(wigTable);
wigLabel = (i+1 == fieldCt ? DEFAULT_CONS_LABEL : fields[i+1]);
wig->leftLabel = cloneString(wigLabel);
wigLabel = (i+2 >= fieldCt ? wig->leftLabel : fields[i+2]);
wig->uiLabel = cloneString(wigLabel);
slAddTail(&wigList, wig);
}
}
return wigList;
}
static void getXrefInfo(struct sqlConnection *conn,
char **retXrefTable, char **retIdField,
char **retAliasField)
/* See if curTrack specifies an xref/alias table for lookup of IDs. */
{
char *xrefSpec = curTrack ? trackDbSetting(curTrack, "idXref") : NULL;
char *xrefTable = NULL, *idField = NULL, *aliasField = NULL;
if (xrefSpec != NULL)
{
char *words[3];
chopLine(cloneString(xrefSpec), words);
if (isEmpty(words[2]))
errAbort("trackDb error: track %s, setting idXref must be followed "
"by three words (xrefTable, idField, aliasField).",
curTrack->track);
xrefTable = words[0];
idField = words[1];
aliasField = words[2];
if (!sqlTableExists(conn, xrefTable) ||
sqlFieldIndex(conn, xrefTable, idField) < 0 ||
sqlFieldIndex(conn, xrefTable, aliasField) < 0)
xrefTable = idField = aliasField = NULL;
}
if (retXrefTable != NULL)
*retXrefTable = xrefTable;
if (retIdField != NULL)
*retIdField = idField;
if (retAliasField != NULL)
*retAliasField = aliasField;
}
static void parseIntRangeSetting(struct trackDb *tdb, char *settingName,
int *retMin, int *retMax)
/* If setting is an integer range, store the values into retMin and retMax */
// This is highly similar to lib/wiggleCart.c's static void parseColonRange,
// though that expects doubles. For quality scores we do want unsigned.
{
char *range = trackDbSetting(tdb, settingName);
if (range != NULL)
{
char rangeCopy[16]; // if it's longer than this, there's a problem.
safecpy(rangeCopy, sizeof(rangeCopy), range);
char *words[3];
int wordCount = chopByChar(rangeCopy, ':', words, ArraySize(words));
if (wordCount == 2)
{
if (retMin != NULL)
*retMin = sqlUnsigned(words[0]);
if (retMax != NULL)
*retMax = sqlUnsigned(words[1]);
return;
}
else
warn("track %s table %s: setting %s should be integer range min:max but is %s",
tdb->track, tdb->table, settingName, range);
}
}
struct bbiFile *fetchBbiForTrack(struct track *track)
/* Fetch bbiFile from track, opening it if it is not already open. */
{
struct bbiFile *bbi = track->bbiFile;
if (bbi == NULL)
{
char *fileName = NULL;
if (track->parallelLoading) // do not use mysql during parallel fetch
{
fileName = cloneString(trackDbSetting(track->tdb, "bigDataUrl"));
}
else
{
struct sqlConnection *conn = NULL;
if (!trackHubDatabase(database))
conn = hAllocConnTrack(database, track->tdb);
fileName = bbiNameFromSettingOrTable(track->tdb, conn, track->table);
hFreeConn(&conn);
}
#ifdef USE_GBIB_PWD
#include "gbib.c"
#endif
bbi = track->bbiFile = bigBedFileOpen(fileName);
}
return bbi;
}
static struct trackDb * pruneRelease(struct trackDb *tdbList)
/* Prune out alternate track entries for another release */
{
/* Build up list that only includes things in this release. Release
* can be inherited from parents. */
struct trackDb *tdb;
struct trackDb *relList = NULL;
struct hash *haveHash = hashNew(3);
while ((tdb = slPopHead(&tdbList)) != NULL)
{
char *rel = trackDbSetting(tdb, "release");
unsigned trackRelBits = buildReleaseBits(rel);
if (trackRelBits & releaseBit)
{
/* we want to include this track, check to see if we already have it */
struct hashEl *hel;
if ((hel = hashLookup(haveHash, tdb->track)) != NULL)
errAbort("found two copies of table %s: one with release %s, the other %s\n",
tdb->track, (char *)hel->val, release);
hashAdd(haveHash, tdb->track, rel);
hashRemove(tdb->settingsHash, "release");
slAddHead(&relList, tdb);
}
else
verbose(3,"pruneRelease: removing '%s', release: '%s' != '%s'\n",
tdb->track, rel, release);
}
freeHash(&haveHash);
return relList;
}
static void bigWigLoadItems(struct track *tg)
/* Fill up tg->items with bedGraphItems derived from a bigWig file */
{
char *extTableString = trackDbSetting(tg->tdb, "extTable");
if (extTableString != NULL)
{
// if there's an extra table, read this one in too
struct sqlConnection *conn = hAllocConnTrack(database, tg->tdb);
char *fileName = bbiNameFromTable(conn, tg->table);
struct bbiFile *bbiFile = bigWigFileOpen(fileName);
slAddHead(&tg->bbiFile, bbiFile);
fileName = bbiNameFromTable(conn, extTableString);
bbiFile = bigWigFileOpen(fileName);
slAddHead(&tg->bbiFile, bbiFile);
hFreeConn(&conn);
}
else
{
if (tg->bbiFile == NULL)
{
/* Figure out bigWig file name. */
struct sqlConnection *conn = hAllocConnTrack(database, tg->tdb);
char *fileName = bbiNameFromTable(conn, tg->table);
tg->bbiFile = bigWigFileOpen(fileName);
hFreeConn(&conn);
}
}
}
void bamMethods(struct track *track)
/* Methods for BAM alignment files. */
{
knetUdcInstall();
boolean isBamWig = cartUsualBooleanClosestToHome(cart, track->tdb, FALSE,
BAMWIG_MODE, (trackDbSettingClosestToHome(track->tdb, BAMWIG_MODE) != NULL));
if (isBamWig)
{
bamWigMethods(track, track->tdb, 0, NULL);
return;
}
track->canPack = TRUE;
boolean isPaired = cartUsualBooleanClosestToHome(cart, track->tdb, FALSE,
BAM_PAIR_ENDS_BY_NAME,
(trackDbSettingClosestToHome(track->tdb, BAM_PAIR_ENDS_BY_NAME) != NULL));
char *tdbShowNames = trackDbSetting(track->tdb, BAM_SHOW_NAMES);
boolean showNames = cartUsualBooleanClosestToHome(cart, track->tdb, FALSE,
BAM_SHOW_NAMES, SETTING_IS_ON(tdbShowNames));
char *colorMode = cartOrTdbString(cart, track->tdb, BAM_COLOR_MODE, BAM_COLOR_MODE_DEFAULT);
char *userTag = cartOrTdbString(cart, track->tdb, BAM_COLOR_TAG, BAM_COLOR_TAG_DEFAULT);
if (sameString(colorMode, BAM_COLOR_MODE_TAG) && userTag != NULL)
{
if (! (isalpha(userTag[0]) && isalnum(userTag[1]) && userTag[2] == '\0'))
{
warn("%s: BAM tag '%s' is not valid -- must be a letter followed by a letter or number.",
track->tdb->shortLabel, htmlEncode(userTag));
cartRemoveVariableClosestToHome(cart, track->tdb, FALSE, BAM_COLOR_TAG);
}
}
addBamBaseAndIndelSettings(track->tdb);
if (isPaired)
{
linkedFeaturesSeriesMethods(track);
track->loadItems = bamPairedLoadItems;
track->drawItems = bamLinkedFeaturesSeriesDraw;
track->drawItemAt = bamPairedDrawAt;
}
else
{
linkedFeaturesMethods(track);
track->loadItems = bamLoadItems;
track->drawItems = bamLinkedFeaturesDraw;
track->drawItemAt = bamDrawAt;
}
if (!showNames)
{
track->drawName = TRUE; // ironic, but this is how to suppress item labels in pack mode.
track->drawLeftLabels = maybeDrawLeftLabels;
}
track->nextItemButtonable = track->nextExonButtonable = FALSE;
track->nextPrevItem = NULL;
track->nextPrevExon = NULL;
if (sameString(colorMode, BAM_COLOR_MODE_GRAY))
track->colorShades = shadesOfGray;
}
static int trackDbViewCmp(const void *va, const void *vb)
/* *** I couldn't find anything like this in hgTracks or hui, but clearly views end up
* *** being ordered alphabetically somehow. Anyway...
* Compare two trackDbs, first by view if both have a view setting, then the usual way
* (by priority, then by shortLabel). */
{
const struct trackDb *a = *((struct trackDb **)va);
const struct trackDb *b = *((struct trackDb **)vb);
// The casts are necessary here unless one adds const to trackDbSetting decl
char *viewA = trackDbSetting((struct trackDb *)a, "view");
char *viewB = trackDbSetting((struct trackDb *)b, "view");
int diff = 0;
if (isNotEmpty(viewA) && isNotEmpty(viewB))
diff = strcmp(viewA, viewB);
if (diff != 0)
return diff;
return trackDbCmp(va, vb);
}
void bigBedCustomClick(struct trackDb *tdb)
/* Display details for BigWig custom tracks. */
{
char *fileName = trackDbSetting(tdb, "bigDataUrl");
char *item = cartOptionalString(cart, "i");
int start = cartInt(cart, "o");
int end = cartInt(cart, "t");
bigBedClick(fileName, tdb, item, start, end, 0);
}
void doPeakClusters(struct trackDb *tdb, char *item)
/* Display detailed info about a cluster of DNase peaks from other tracks. */
{
int start = cartInt(cart, "o");
char *table = tdb->table;
int rowOffset = hOffsetPastBin(database, seqName, table);
char query[256];
struct sqlResult *sr;
char **row;
struct bed *cluster = NULL;
struct sqlConnection *conn = hAllocConn(database);
cartWebStart(cart, database, "%s item details", tdb->shortLabel);
sqlSafef(query, sizeof(query),
"select * from %s where name = '%s' and chrom = '%s' and chromStart = %d",
table, item, seqName, start);
sr = sqlGetResult(conn, query);
row = sqlNextRow(sr);
if (row != NULL)
cluster = bedLoadN(row+rowOffset, 5);
sqlFreeResult(&sr);
if (cluster != NULL)
{
/* Get list of subgroups to display */
char *inputTableFieldDisplay = trackDbSetting(tdb, "inputTableFieldDisplay");
if (inputTableFieldDisplay != NULL)
{
struct slName *fieldList = stringToSlNames(inputTableFieldDisplay);
char *inputTrackTable = trackDbRequiredSetting(tdb, "inputTrackTable");
/* Print out some information about the cluster overall. */
printf("<B>Items in Cluster:</B> %s of %d<BR>\n", cluster->name,
sqlRowCount(conn, sqlCheckIdentifier(inputTrackTable)));
printf("<B>Cluster Score (out of 1000):</B> %d<BR>\n", cluster->score);
printPos(cluster->chrom, cluster->chromStart, cluster->chromEnd, NULL, TRUE, NULL);
/* In a new section put up list of hits. */
webNewSection("List of Items in Cluster");
webPrintLinkTableStart();
printClusterTableHeader(fieldList, FALSE, FALSE, TRUE);
printPeakClusterInfo(tdb, cart, conn, inputTrackTable, fieldList, cluster);
}
else
errAbort("Missing required trackDb setting %s for track %s",
"inputTableFieldDisplay", tdb->track);
webPrintLinkTableEnd();
}
printf("<A HREF=\"%s&g=htcListItemsAssayed&table=%s\" TARGET_blank>", hgcPathAndSettings(),
tdb->track);
printf("List all items assayed");
printf("</A><BR>\n");
webNewSection("Track Description");
printTrackHtml(tdb);
hFreeConn(&conn);
}
char *bigFileNameFromCtOrHub(char *table, struct sqlConnection *conn)
/* If table is a custom track or hub track, return the bigDataUrl setting;
* otherwise return NULL. Do a freeMem on returned string when done. */
{
char *fileName = NULL;
if (isCustomTrack(table))
{
struct customTrack *ct = ctLookupName(table);
if (ct != NULL)
fileName = cloneString(trackDbSetting(ct->tdb, "bigDataUrl"));
}
else if (isHubTrack(table))
{
struct trackDb *tdb = hashFindVal(fullTableToTdbHash, table);
assert(tdb != NULL);
fileName = cloneString(trackDbSetting(tdb, "bigDataUrl"));
assert(fileName != NULL);
}
return fileName;
}
static void addTablesAccordingToTrackType(char *db, struct slName **pList, struct hash *uniqHash,
struct trackDb *track)
/* Parse out track->type and if necessary add some tables from it. */
{
struct slName *name;
char *trackDupe = cloneString(track->type);
if (trackDupe != NULL && trackDupe[0] != 0)
{
char *s = trackDupe;
char *type = nextWord(&s);
if (sameString(type, "wigMaf"))
{
static char *wigMafAssociates[] = {"frames", "summary"};
int i;
for (i=0; i<ArraySize(wigMafAssociates); ++i)
{
char *setting = wigMafAssociates[i];
char *table = trackDbSetting(track, setting);
if (table != NULL)
{
name = slNameNew(table);
slAddHead(pList, name);
hashAdd(uniqHash, table, NULL);
}
}
/* include conservation wiggle tables */
struct consWiggle *wig, *wiggles = wigMafWiggles(db, track);
slReverse(&wiggles);
for (wig = wiggles; wig != NULL; wig = wig->next)
{
name = slNameNew(wig->table);
slAddHead(pList, name);
hashAdd(uniqHash, wig->table, NULL);
}
}
if (track->subtracks)
{
struct slName *subList = NULL;
struct slRef *tdbRefList = trackDbListGetRefsToDescendantLeaves(track->subtracks);
slSort(&tdbRefList, trackDbRefCmp);
struct slRef *tdbRef;
for (tdbRef = tdbRefList; tdbRef != NULL; tdbRef = tdbRef->next)
{
struct trackDb *subTdb = tdbRef->val;
name = slNameNew(subTdb->table);
slAddTail(&subList, name);
hashAdd(uniqHash, subTdb->table, NULL);
}
pList = slCat(pList, subList);
}
}
freez(&trackDupe);
}
void doHalMaf(struct trackDb *parentTrack, char *table, struct sqlConnection *conn)
/* Output regions as MAF. maf tables look bed-like enough for
* cookedBedsOnRegions to handle intersections. */
{
#ifdef USE_HAL
struct region *region = NULL, *regionList = getRegions();
struct trackDb *tdb;
if ((tdb = findTrackDb(parentTrack, table)) == NULL)
errAbort("cannot find track named %s under %s\n", table, parentTrack->table);
char *fileName = trackDbSetting(tdb, "bigDataUrl");
char *otherSpecies = trackDbSetting(tdb, "otherSpecies");
int handle = halOpenLOD(fileName);
struct hal_species_t *speciesList = halGetSpecies(handle);
for(; speciesList; speciesList = speciesList->next)
{
if (sameString(speciesList->name, otherSpecies))
break;
}
if (speciesList == NULL)
errAbort("cannot find species %s in hal file %s\n",
otherSpecies, fileName);
speciesList->next = NULL;
textOpen();
for (region = regionList; region != NULL; region = region->next)
{
halGetMAF(stdout, handle, speciesList,
trackHubSkipHubName(database), region->chrom,
region->start, region->end, FALSE);
}
#else // USE_HAL
errAbort("hgTables not compiled with HAL support.");
#endif // USE_HAL
}
static void vcfTabixLoadItems(struct track *tg)
/* Load items in window from VCF file using its tabix index file. */
{
char *fileOrUrl = NULL;
/* Figure out url or file name. */
if (tg->parallelLoading)
{
/* do not use mysql during parallel-fetch load */
fileOrUrl = trackDbSetting(tg->tdb, "bigDataUrl");
}
else
{
struct sqlConnection *conn = hAllocConnTrack(database, tg->tdb);
fileOrUrl = bbiNameFromSettingOrTableChrom(tg->tdb, conn, tg->table, chromName);
hFreeConn(&conn);
}
if (isEmpty(fileOrUrl))
return;
int vcfMaxErr = -1;
struct vcfFile *vcff = NULL;
boolean hapClustEnabled = cartOrTdbBoolean(cart, tg->tdb, VCF_HAP_ENABLED_VAR, TRUE);
/* protect against temporary network error */
struct errCatch *errCatch = errCatchNew();
if (errCatchStart(errCatch))
{
vcff = vcfTabixFileMayOpen(fileOrUrl, chromName, winStart, winEnd, vcfMaxErr, -1);
if (vcff != NULL)
{
filterRecords(vcff, tg->tdb);
if (hapClustEnabled && vcff->genotypeCount > 1 && vcff->genotypeCount < 3000 &&
(tg->visibility == tvPack || tg->visibility == tvSquish))
vcfHapClusterOverloadMethods(tg, vcff);
else
{
tg->items = vcfFileToPgSnp(vcff, tg->tdb);
// pgSnp bases coloring/display decision on count of items:
tg->customInt = slCount(tg->items);
}
// Don't vcfFileFree here -- we are using its string pointers!
}
}
errCatchEnd(errCatch);
if (errCatch->gotError || vcff == NULL)
{
if (isNotEmpty(errCatch->message->string))
tg->networkErrMsg = cloneString(errCatch->message->string);
tg->drawItems = bigDrawWarning;
tg->totalHeight = bigWarnTotalHeight;
}
errCatchFree(&errCatch);
}
static void checkOneSubGroups(char *compositeName,
struct trackDb *td, struct subGroupData *sgd)
{
char *subGroups = trackDbSetting(td, "subGroups");
verbose(2, " checkOne %s %s\n", compositeName, td->track);
if (subGroups && (sgd->nameHash == NULL))
{
errAbort("subTrack %s has groups not defined in parent %s\n",
td->track, compositeName);
}
else if (!subGroups && (sgd->nameHash != NULL))
{
errAbort("subtrack %s is missing subGroups defined in parent %s\n",
td->track, compositeName);
}
if (!subGroups && (sgd->nameHash == NULL))
return; /* nothing to do */
assert(sgd->nameHash != NULL);
struct slPair *slPair, *slPairList = slPairFromString(subGroups);
struct hash *foundHash = newHash(3);
for (slPair = slPairList; slPair; slPair = slPair->next)
{
struct hashEl *hel = hashLookup( sgd->nameHash, slPair->name);
if (hel == NULL)
errAbort("subtrack %s has subGroup (%s) not found in parent\n",
td->track, slPair->name);
struct hash *subHash = hel->val;
hashStore(foundHash, slPair->name);
if (hashLookup(subHash, slPair->val) == NULL)
{
errAbort("subtrack %s has subGroup (%s) with value (%s) not found in parent\n",
td->track, slPair->name, (char *)slPair->val);
}
}
struct hashCookie cookie = hashFirst(sgd->nameHash);
struct hashEl *hel;
while ((hel = hashNext(&cookie)) != NULL)
{
if (hashLookup(foundHash, hel->name) == NULL)
errAbort("subtrack %s is missing required subGroup %s\n",
td->track, hel->name);
}
}
void bedDrawSimpleAt(struct track *tg, void *item,
struct hvGfx *hvg, int xOff, int y,
double scale, MgFont *font, Color color, enum trackVisibility vis)
/* Draw a single simple bed item at position. */
{
struct bed *bed = item;
int heightPer = tg->heightPer;
int s = max(bed->chromStart, winStart), e = min(bed->chromEnd, winEnd);
if (s > e)
return;
int x1 = round((s-winStart)*scale) + xOff;
int x2 = round((e-winStart)*scale) + xOff;
int w = x2 - x1;
if (w < 1)
w = 1;
struct trackDb *tdb = tg->tdb;
int scoreMin = atoi(trackDbSettingClosestToHomeOrDefault(tdb, "scoreMin", "0"));
int scoreMax = atoi(trackDbSettingClosestToHomeOrDefault(tdb, "scoreMax", "1000"));
char *directUrl = trackDbSetting(tdb, "directUrl");
boolean withHgsid = (trackDbSetting(tdb, "hgsid") != NULL);
boolean thickDrawItem = (trackDbSetting(tdb, "thickDrawItem") != NULL);
if (tg->itemColor != NULL)
{
color = tg->itemColor(tg, bed, hvg);
}
else if (tg->colorShades)
{
adjustBedScoreGrayLevel(tdb, bed, scoreMin, scoreMax);
color = tg->colorShades[grayInRange(bed->score, scoreMin, scoreMax)];
}
/* Keep the item at least 4 pixels wide at all viewpoints */
if (thickDrawItem && (w < 4))
{
x1 -= ((5-w) >> 1);
w = 4;
x2 = x1 + w;
}
static void bamWigLoadItems(struct track *tg)
{
char *fileName = NULL;
/* Figure out bigWig file name. */
if (tg->parallelLoading)
{
/* do not use mysql during parallel-fetch load */
fileName = trackDbSetting(tg->tdb, "bigDataUrl");
}
else
{
struct sqlConnection *conn = hAllocConnTrack(database, tg->tdb);
/* this should call bamFileNameFromTable with logic from bamLoadItemsCore to
* check the bigDataUrl setting. Fix this if bamWigs end up being
* a supported type. It may be that this code gets rolled into
* normal BAM display... since that's the plan ;-).
*/
fileName = bbiNameFromSettingOrTable(tg->tdb, conn, tg->table);
hFreeConn(&conn);
}
/* Allocate predraw area. */
struct bamWigTrackData *bwData;
double scale = (double)insideWidth/(winEnd - winStart);
struct preDrawContainer *pre = tg->preDrawContainer = initPreDrawContainer(insideWidth);
AllocVar(bwData);
bwData->preDraw = pre->preDraw;
bwData->scale = scale;
bwData->width = insideWidth;
bwData->preDrawZero = pre->preDrawZero;
char posForBam[512];
safef(posForBam, sizeof(posForBam), "%s:%d-%d", chromName, winStart, winEnd);
bamFetch(fileName, posForBam, countBam, bwData, NULL);
/* fill in rest of predraw */
int preDrawZero = pre->preDrawZero;
int i;
for (i=0; i<insideWidth; ++i)
{
struct preDrawElement *pe = &bwData->preDraw[i + preDrawZero];
pe->min = pe->count;
pe->max = pe->count;
pe->sumData = pe->count / scale;
pe->sumSquares = (pe->count * pe->count)/scale;
}
}
void genericBigWigClick(struct sqlConnection *conn, struct trackDb *tdb,
char *item, int start)
/* Display details for BigWig built in tracks. */
{
char *fileName = trackDbSetting(tdb, "bigDataUrl");
if (fileName == NULL)
{
char query[256];
sqlSafef(query, sizeof(query), "select fileName from %s", tdb->table);
fileName = sqlQuickString(conn, query);
if (fileName == NULL)
errAbort("Missing fileName in %s table", tdb->table);
}
bigWigClick(tdb, fileName);
}
static struct hash *buildCompositeHash(char *database,struct trackDb *tdbList)
/* Create a hash of all composite tracks. This is keyed by their name with
* subGroupData values. */
{
struct hash *compositeHash = newHash(8);
/* process all composite tracks */
struct trackDb *td, *tdNext;
for (td = tdbList; td != NULL; td = tdNext)
{
tdNext = td->next;
if (trackDbLocalSetting(td, "compositeTrack"))
{
int i;
struct subGroupData *sgd;
char subGroupName[256];
AllocVar(sgd);
sgd->compositeTdb = td;
verbose(3,"getting subgroups for %s\n", td->track);
for(i=1; ; i++)
{
safef(subGroupName, sizeof(subGroupName), "subGroup%d", i);
char *sgSetting = trackDbSetting(td, subGroupName);
if (!sgSetting)
break;
sgSetting = cloneString(sgSetting);
char *sgWord = sgSetting;
char *sgName = nextWord(&sgWord);
validateTag(database,td,subGroupName,sgName,TRUE);
nextWord(&sgWord); /* skip word not used */
struct hash *subGroupHash = newHash(3);
struct slPair *slPair, *slPairList = slPairListFromString(sgWord,TRUE); // respect ""
for (slPair = slPairList; slPair; slPair = slPair->next)
{
validateTag(database,td,sgName,slPair->name,TRUE);
hashAdd(subGroupHash, slPair->name, slPair->val);
}
if (sgd->nameHash == NULL)
sgd->nameHash = newHash(3);
verbose(3," adding group %s\n", sgName);
hashAdd(sgd->nameHash, sgName, subGroupHash);
}
hashAdd(compositeHash, td->track, sgd);
}
}
return compositeHash;
}
void doMiddle(struct cart *theCart)
/* Set up globals and make web page */
{
char *db = NULL;
char *ignored;
struct trackDb *tracks;
struct trackRef *tr;
struct group *group, *groups = NULL;
cart = theCart;
cartWebStart(cart, NULL, "ENCODE Track Data Versions (%s)", db);
getDbAndGenome(cart, &db, &ignored, NULL);
tracks = hTrackDb(db);
groups = groupTracks(db, tracks);
for (group = groups; group != NULL; group = group->next)
{
if (group->tracks == NULL || !startsWith("encode", group->name))
continue;
hTableStart();
puts("<TR>");
puts("<TH align=LEFT colspan=3 BGCOLOR=#536ED3>");
printf("<B> %s</B> ", wrapWhiteFont(group->label));
printf(" ");
puts("</TH>\n");
puts("</TR>");
for (tr = group->tracks; tr != NULL; tr = tr->next)
{
char *version = trackDbSetting(tr->track, "dataVersion");
if (version)
stripString(version, "ENCODE ");
puts("<TR><TD>");
printf(" %s", tr->track->shortLabel);
puts("</TD><TD>");
printf(" %s", version ? version : " ");
puts("</TD><TD>");
printf(" %s", tr->track->longLabel);
puts("</TD></TR>");
}
/*
printf("\t%s\t%s\t%s\n", version,
tr->track->shortLabel, tr->track->longLabel);
*/
hTableEnd();
puts("<BR>");
}
cartWebEnd();
}
static struct dbTable *extraTableList(char *prefix)
/* Get list of tables (other than the primary table)
* where we are displaying fields. */
{
struct hashEl *varList = NULL, *var;
int prefixSize = strlen(prefix);
struct dbTable *dtList = NULL, *dt;
/* Build up list of tables to show by looking at
* variables with right prefix in cart. */
varList = cartFindPrefix(cart, prefix);
for (var = varList; var != NULL; var = var->next)
{
if (cartBoolean(cart, var->name))
{
/* From variable name parse out database and table. */
char *dbTab = cloneString(var->name + prefixSize);
char *db = dbTab;
char *table = strchr(db, '.');
if (table == NULL)
internalErr();
*table++ = 0;
dt = dbTableNew(db, table);
slAddHead(&dtList, dt);
freez(&dbTab);
}
}
if (varList == NULL && curTrack != NULL)
{
char *defaultLinkedTables = trackDbSetting(curTrack, "defaultLinkedTables");
if (defaultLinkedTables != NULL)
{
struct slName *t, *tables = slNameListFromString(defaultLinkedTables, ',');
for (t = tables; t != NULL; t = t->next)
{
char varName[1024];
safef(varName, sizeof(varName), "%s%s.%s", prefix, database, t->name);
cartSetBoolean(cart, varName, TRUE);
dt = dbTableNew(database, t->name);
slAddHead(&dtList, dt);
}
}
}
slSort(&dtList, dbTableCmp);
return dtList;
}
static struct trackDb *getFullTrackList(struct cart *cart, char *db, struct grp **pHubGroups)
{
struct trackDb *list = hTrackDb(db);
struct customTrack *ctList, *ct;
/* exclude any track with a 'tableBrowser off' setting */
struct trackDb *tdb, *nextTdb, *newList = NULL;
for (tdb = list; tdb != NULL; tdb = nextTdb)
{
nextTdb = tdb->next;
if (tdbIsDownloadsOnly(tdb) || tdb->table == NULL)
{
//freeMem(tdb); // should not free tdb's.
// While hdb.c should and says it does cache the tdbList, it doesn't.
// The most notable reason that the tdbs are not cached is this hgTables CGI !!!
// It needs to be rewritten to make tdbRef structures for the lists it creates here!
continue;
}
char *tbOff = trackDbSetting(tdb, "tableBrowser");
if (useAC && tbOff != NULL && startsWithWord("off", tbOff))
slAddHead(&forbiddenTrackList, tdb);
else
slAddHead(&newList, tdb);
}
slReverse(&newList);
list = newList;
/* add wikiTrack if enabled */
if (wikiTrackEnabled(db, NULL))
slAddHead(&list, wikiTrackDb());
slSort(&list, trackDbCmp);
// Add hub tracks at head of list
struct trackDb *hubTdbList = hubCollectTracks(db, pHubGroups);
list = slCat(list, hubTdbList);
// Add custom tracks at head of list
ctList = customTracksParseCart(db, cart, NULL, NULL);
for (ct = ctList; ct != NULL; ct = ct->next)
{
slAddHead(&list, ct->tdb);
}
return list;
}
static void lookupTransMapLabels(struct track *tg)
/* This converts the transMap ids to labels. */
{
struct sqlConnection *conn = hAllocConn(database);
char *transMapInfoTbl = trackDbRequiredSetting(tg->tdb, transMapInfoTblSetting);
char *transMapGeneTbl = trackDbSetting(tg->tdb, transMapGeneTblSetting);
struct sqlConnection *geneConn = NULL;
if (transMapGeneTbl != NULL)
geneConn = hAllocConnDbTbl(transMapGeneTbl, &transMapGeneTbl, database);
struct linkedFeatures *lf;
unsigned labelSet = getLabelTypes(tg);
for (lf = tg->items; lf != NULL; lf = lf->next)
getItemLabel(conn, transMapInfoTbl, geneConn, transMapGeneTbl, labelSet, lf);
hFreeConn(&geneConn);
hFreeConn(&conn);
}
static void getVocab(struct trackDb *tdb, struct cart *cart,
char **vocabFile, struct hash **vocabHash)
/* Get vocabulary info from trackDb settings (CV or vocab tables) */
{
char *file = NULL;
struct hash *hash = NULL;
char *vocab = trackDbSetting(tdb, "controlledVocabulary");
if (vocabSettingIsEncode(vocab))
{
file = cloneFirstWord(vocab);
hash = getVocabHash(file);
}
else
{
hash = vocabBasicFromSetting(tdb, cart);
}
if (vocabFile != NULL)
*vocabFile = file;
if (hash != NULL)
*vocabHash = hash;
}
void doPeakClusterListItemsAssayed()
/* Put up a page that shows all experiments associated with a cluster track. */
{
struct trackDb *clusterTdb = tdbForTableArg();
cartWebStart(cart, database, "List of items assayed in %s", clusterTdb->shortLabel);
struct sqlConnection *conn = hAllocConn(database);
char *inputTableFieldDisplay = trackDbSetting(clusterTdb, "inputTableFieldDisplay");
webPrintLinkTableStart();
if (inputTableFieldDisplay)
{
struct slName *fieldList = stringToSlNames(inputTableFieldDisplay);
printClusterTableHeader(fieldList, FALSE, FALSE, FALSE);
char *inputTrackTable = trackDbRequiredSetting(clusterTdb, "inputTrackTable");
printPeakClusterInfo(clusterTdb, cart, conn, inputTrackTable, fieldList, NULL);
}
else
errAbort("Missing required trackDb setting %s for track %s", "inputTableFieldDisplay",
clusterTdb->track);
webPrintLinkTableEnd();
hFreeConn(&conn);
}
static struct hash *accessControlInit(struct sqlConnection *conn)
/* Return a hash associating restricted table/track names in the given db/conn
* with virtual hosts, or NULL if there is no tableAccessControl table and no
* forbiddenTrackList (see getFullTrackList). */
{
struct hash *acHash = NULL;
if (sqlTableExists(conn, "tableAccessControl"))
{
struct sqlResult *sr = NULL;
char **row = NULL;
acHash = newHash(0);
sr = sqlGetResult(conn, "NOSQLINJ select name,host from tableAccessControl");
while ((row = sqlNextRow(sr)) != NULL)
hashAddSlName(acHash, row[0], chopAtFirstDot(row[1]));
sqlFreeResult(&sr);
}
if (forbiddenTrackList != NULL)
{
if (acHash == NULL)
acHash = newHash(0);
struct trackDb *tdb;
for (tdb = forbiddenTrackList; tdb != NULL; tdb = tdb->next)
{
char *tbOff = cloneString(trackDbSetting(tdb, "tableBrowser"));
if (isEmpty(tbOff))
errAbort("bug: tdb for %s is in forbiddenTrackList without 'tableBrowser off' setting",
tdb->track);
hashAddSlName(acHash, tdb->table, "-");
// skip "off" and look for additional table names:
nextWord(&tbOff);
char *tbl;
while ((tbl = nextWord(&tbOff)) != NULL)
hashAddSlName(acHash, tbl, "-");
}
}
return acHash;
}
static void layerOnHtml(char *dirName, struct trackDb *tdbList, char *database)
/* Read in track HTML call bottom-up. */
{
char fileName[512];
struct trackDb *td;
for (td = tdbList; td != NULL; td = td->next)
{
if (isEmpty(td->html))
{
char *htmlName = trackDbSetting(td, "html");
if (htmlName == NULL)
htmlName = td->track;
safef(fileName, sizeof(fileName), "%s/%s.html", dirName, htmlName);
if (fileExists(fileName))
{
td->html = readHtmlRecursive(fileName, database);
// Check for note ASCII characters at higher levels of verboseness.
// Normally, these are acceptable ISO-8859-1 characters
if ((verboseLevel() >= 2) && hasNonAsciiChars(td->html))
verbose(2, "Note: non-printing or non-ASCII characters in %s\n", fileName);
}
}
}
}
static void bigBedClick(char *fileName, struct trackDb *tdb,
char *item, int start, int end, int bedSize)
/* Handle click in generic bigBed track. */
{
boolean showUrl = FALSE;
char *chrom = cartString(cart, "c");
/* Open BigWig file and get interval list. */
struct bbiFile *bbi = bigBedFileOpen(fileName);
struct lm *lm = lmInit(0);
int ivStart = start, ivEnd = end;
if (start == end)
{
// item is an insertion; expand the search range from 0 bases to 2 so we catch it:
ivStart = max(0, start-1);
ivEnd++;
}
struct bigBedInterval *bbList = bigBedIntervalQuery(bbi, chrom, ivStart, ivEnd, 0, lm);
/* Get bedSize if it's not already defined. */
if (bedSize == 0)
{
bedSize = bbi->definedFieldCount;
showUrl = TRUE;
}
char *scoreFilter = cartOrTdbString(cart, tdb, "scoreFilter", NULL);
int minScore = 0;
if (scoreFilter)
minScore = atoi(scoreFilter);
/* Find particular item in list - matching start, and item if possible. */
boolean found = FALSE;
boolean firstTime = TRUE;
struct bigBedInterval *bb;
for (bb = bbList; bb != NULL; bb = bb->next)
{
if (!(bb->start == start && bb->end == end))
continue;
if (bedSize > 3)
{
char *name = cloneFirstWordByTab(bb->rest);
boolean match = sameString(name, item);
freez(&name);
if (!match)
continue;
}
found = TRUE;
if (firstTime)
printf("<BR>\n");
int seq1Seq2Fields = 0;
// check for seq1 and seq2 in columns 7+8 (eg, pairedTagAlign)
boolean seq1Seq2 = sameOk(trackDbSetting(tdb, BASE_COLOR_USE_SEQUENCE), "seq1Seq2");
if (seq1Seq2 && bedSize == 6)
seq1Seq2Fields = 2;
char *fields[bedSize+seq1Seq2Fields];
char startBuf[16], endBuf[16];
char *rest = cloneString(bb->rest);
int bbFieldCount = bigBedIntervalToRow(bb, chrom, startBuf, endBuf, fields,
bedSize+seq1Seq2Fields);
if (bbFieldCount != bedSize+seq1Seq2Fields)
{
errAbort("Disagreement between trackDb field count (%d) and %s fieldCount (%d)",
bedSize, fileName, bbFieldCount);
}
struct bed *bed = bedLoadN(fields, bedSize);
if (bedSize >= 6 && scoreFilter && bed->score < minScore)
continue;
if (showUrl && (bedSize >= 4))
printCustomUrl(tdb, item, TRUE);
bedPrintPos(bed, bedSize, tdb);
// display seq1 and seq2
if (seq1Seq2 && bedSize+seq1Seq2Fields == 8)
printf("<table><tr><th>Sequence 1</th><th>Sequence 2</th></tr>"
"<tr><td> %s </td><td> %s </td></tr></table>", fields[6], fields[7]);
else if (isNotEmpty(rest))
{
char *restFields[256];
int restCount = chopTabs(rest, restFields);
int restBedFields = bedSize - 3;
if (restCount > restBedFields)
{
if (0 == extraFieldsPrint(tdb,NULL,restFields + restBedFields,restCount - restBedFields))
{
int i;
char label[20];
safef(label, sizeof(label), "nonBedFieldsLabel");
printf("<B>%s </B>",
trackDbSettingOrDefault(tdb, label, "Non-BED fields:"));
for (i = restBedFields; i < restCount; i++)
printf("%s%s", (i > 0 ? "\t" : ""), restFields[i]);
printf("<BR>\n");
}
}
}
if (isCustomTrack(tdb->track))
{
time_t timep = bbiUpdateTime(bbi);
printBbiUpdateTime(&timep);
}
}
if (!found)
{
printf("No item %s starting at %d\n", emptyForNull(item), start);
}
lmCleanup(&lm);
bbiFileClose(&bbi);
}
