491bae89e94aedf11666a9e662d2d80012cc312d
markd
  Wed Jan 25 07:38:10 2017 -0800
add more information to display of transmap source gene

diff --git src/hg/hgc/transMapClick.c src/hg/hgc/transMapClick.c
index fdff8a3..bc7f82e 100644
--- src/hg/hgc/transMapClick.c
+++ src/hg/hgc/transMapClick.c
@@ -29,51 +29,78 @@
 
 #include "common.h"
 #include "hgc.h"
 #include "hui.h"
 #include "hCommon.h"
 #include "transMapClick.h"
 #include "bigTransMap.h"
 #include "bigBed.h"
 #include "bigPsl.h"
 #include "transMapStuff.h"
 #include "transMapInfo.h"
 #include "transMapSrc.h"
 #include "transMapGene.h"
 #include "genbank.h"
 
+enum geneSrcSetType
+/* constants for source sets */
+{
+    ENSEMBL_SRC_SET,
+    REFSEQ_SRC_SET,
+    RNA_SRC_SET,
+    EST_SRC_SET,
+    UCSC_GENES_SRC_SET,
+    UNKNOWN_SRC_SET
+};
 
 struct transMapBag
 /* object contain collected information on a specific transMap mapping
 * this has both PSL and bigTransMap objects */
 {
     struct psl *psl;              // transMap alignment
     struct bigTransMap *meta;     // bigTransMap record for metadata
+    enum geneSrcSetType srcSet;   // source data set (not owned)
     boolean srcDbIsActive;        // source database is active
 };
 
 static char *guessTranscriptType(struct transMapGene *gene)
 /* guess the transcript type when not known */
 {
 if (gene == NULL)
     return "unknown";  // EST
 else if (sameString(gene->cds, "n/a") || sameString(gene->cds, ""))
     return "non_coding";
 else    
     return "protein_coding";
 }
 
+static enum geneSrcSetType guessGeneSrcSet(struct trackDb *tdb)
+/* guess the the source set from the table name for table
+ * based-transmap */
+{
+if (stringIn("UcscGenes", tdb->table))
+    return UCSC_GENES_SRC_SET;
+else if (stringIn("RefSeq", tdb->table))
+    return REFSEQ_SRC_SET;
+else if (stringIn("MRna", tdb->table))
+    return RNA_SRC_SET;
+else if (stringIn("SplicedEst", tdb->table))
+    return EST_SRC_SET;
+else
+    return UNKNOWN_SRC_SET;
+}
+
 static char *chainSubsetToBigStr(enum transMapInfoChainSubset cs)
 /* convert chain subset type to string used in bigTransMap */
 {
 switch (cs)
     {
     case transMapInfoUnknown:
         assert(FALSE);
         return "unknown";
     case transMapInfoAll:
         return "all";
     case transMapInfoSyn:
         return "syn";
     case transMapInfoRbest:
         return "rbest";
     }
@@ -118,167 +145,214 @@
 struct transMapBag *bag;
 AllocVar(bag);
 bag->psl = getAlignments(conn, tdb->table, mappedId);
 
 char *transMapInfoTbl = trackDbRequiredSetting(tdb, transMapInfoTblSetting);
 struct transMapInfo *info = transMapInfoQuery(conn, transMapInfoTbl, mappedId);
 
 char *transMapSrcTbl = trackDbRequiredSetting(tdb, transMapSrcTblSetting);
 struct transMapSrc *src = transMapSrcQuery(conn, transMapSrcTbl, info->srcDb, info->srcId);
 
 struct transMapGene *gene = NULL;
 char *transMapGeneTbl = trackDbSetting(tdb, transMapGeneTblSetting);
 if (transMapGeneTbl != NULL)
     gene = transMapGeneQuery(conn, transMapGeneTbl,
                              info->srcDb, transMapIdToSeqId(info->srcId));
+bag->srcSet = guessGeneSrcSet(tdb);
 bag->srcDbIsActive = hDbIsActive(info->srcDb);
 bag->meta = buildFakeBigTransMapRec(info, src, gene);
 transMapInfoFree(&info);
 transMapSrcFree(&src);
 transMapGeneFree(&gene);
 hFreeConn(&conn);
 return bag;
 }
 
+static enum geneSrcSetType getGeneSrcSet(struct trackDb *tdb)
+/* get the geneSrcSetType from trackDb */
+{
+char *srcSet = trackDbRequiredSetting(tdb, "transMapSrcSet");
+if (sameString(srcSet, "ensembl"))
+    return ENSEMBL_SRC_SET;
+else if (sameString(srcSet, "refseq"))
+    return REFSEQ_SRC_SET;
+else if (sameString(srcSet, "rna"))
+    return RNA_SRC_SET;
+else if (sameString(srcSet, "est"))
+    return EST_SRC_SET;
+else
+    return UNKNOWN_SRC_SET;
+}
+
+static char *formatGeneSrcSet(enum geneSrcSetType srcSet)
+/* get display version of source set */
+{
+switch (srcSet)
+    {
+    case ENSEMBL_SRC_SET:
+        return "Ensembl";
+    case REFSEQ_SRC_SET:
+        return "RefSeq RNA";
+    case RNA_SRC_SET:
+        return "GenBank RNA";
+    case EST_SRC_SET:
+        return "GenBank EST";
+    case UCSC_GENES_SRC_SET:
+        return "UCSC Genes";
+    case UNKNOWN_SRC_SET:
+        return "Unknown";
+    }
+return "Unknown";
+}
+
 static struct transMapBag *transMapBagLoadBig(struct trackDb *tdb, char *mappedId)
 /* load information from bigTransMap file */
 {
 struct sqlConnection *conn = hAllocConn(database);
 struct transMapBag *bag;
 AllocVar(bag);
 
 char *fileName = bbiNameFromSettingOrTable(tdb, conn, tdb->table);
 char *chrom = cartString(cart, "c");
 struct bbiFile *bbi = bigBedFileOpen(fileName);
 struct lm *lm = lmInit(0);
 int fieldIx;
 struct bptFile *bpt = bigBedOpenExtraIndex(bbi, "name", &fieldIx);
 struct bigBedInterval *bb = bigBedNameQuery(bbi, bpt, fieldIx, mappedId, lm);
 if (slCount(bb) != 1)
     errAbort("expected 1 item named \"%s\", got %d from %s", mappedId, slCount(bb), fileName);
 char *fields[bbi->fieldCount];
 char startBuf[32], endBuf[32];
 int bbFieldCount = bigBedIntervalToRow(bb, chrom, startBuf, endBuf, fields,
                                        bbi->fieldCount);
 if (bbFieldCount != BIGTRANSMAP_NUM_COLS)
     errAbort("expected %d fields in bigTransMap record, got %d in %s",
              BIGTRANSMAP_NUM_COLS, bbFieldCount, fileName);
 bag->psl = pslFromBigPsl(chrom, bb, 0, NULL, NULL); 
 bag->meta = bigTransMapLoad(fields);
+bag->srcSet = getGeneSrcSet(tdb);
 bag->srcDbIsActive = hDbIsActive(bag->meta->srcDb);
 
 bigBedFileClose(&bbi);
 lmCleanup(&lm);
 hFreeConn(&conn);
 return bag;
 }
 
 static void transMapBagFree(struct transMapBag **bagPtr)
 /* free the bag */
 {
 struct transMapBag *bag = *bagPtr;
 if (bag != NULL)
     {
     pslFree(&bag->psl);
     bigTransMapFree(&bag->meta);
     freez(bagPtr);
     }
 }
 
-static void prOrgScientific(char *db)
-/* print organism and scientific name for a database. */
+static void prOrgScientificDb(char *db)
+/* print organism and scientific name for a database.
+ */
 {
 char *org = hOrganism(db);
 char *sciName = hScientificName(db);
 if ((org != NULL) && (sciName != NULL))
     printf("%s (%s)", org, sciName);
 else
     printf("n/a");
 freeMem(org);
 freeMem(sciName);
 }
 
 static void displayMapped(struct transMapBag *bag)
 /* display information about the mapping alignment */
 {
 printf("<TABLE class=\"transMap\">\n");
 printf("<CAPTION>TransMap Alignment</CAPTION>\n");
 printf("<TBODY>\n");
 
 // organism/assembly
 printf("<TR CLASS=\"transMapLeft\"><TD>Organism<TD>");
-prOrgScientific(database);
+prOrgScientificDb(database);
 printf("</TR>\n");
 printf("<TR CLASS=\"transMapLeft\"><TD>Genome<TD>%s</TR>\n", database);
 
 // position
 printf("<TR CLASS=\"transMapLeft\">");
 printf("<TD>Position<TD CLASS=\"transMapNoWrap\">");
 printf("<A HREF=\"%s&position=%s:%d-%d\">",
       hgTracksPathAndSettings(),
       bag->psl->tName, bag->psl->tStart, bag->psl->tEnd);
 printf("%s:%d-%d</A>", bag->psl->tName, bag->psl->tStart, bag->psl->tEnd);
 printf("</TR>\n");
 
 // % identity and % aligned
 printf("<TR CLASS=\"transMapLeft\"><TD>Identity<TD>%0.1f%%</TR>\n",
        100.0*pslIdent(bag->psl));
 printf("<TR CLASS=\"transMapLeft\"><TD>Aligned<TD>%0.1f%%</TR>\n",
        100.0*pslQueryAligned(bag->psl));
 
 // chain type used in mapping
 printf("<TR CLASS=\"transMapLeft\"><TD>Chain subset<TD>%s</TR>\n",
        bag->meta->chainType);
 printf("</TBODY></TABLE>\n");
 }
 
 static void displaySource(struct transMapBag *bag)
 /* display information about the source gene that was mapped */
 {
 printf("<TABLE class=\"transMap\">\n");
 printf("<CAPTION>Source Alignment</CAPTION>\n");
+
 printf("<TBODY>\n");
 // organism/assembly
-printf("<TR CLASS=\"transMapLeft\"><TD>Organism<TD>");
-prOrgScientific(bag->meta->srcDb);
-printf("</TR>\n");
+printf("<TR CLASS=\"transMapLeft\"><TD>Organism<TD>%s (%s)</TR>\n",
+       bag->meta->commonName, bag->meta->scientificName);
 printf("<TR CLASS=\"transMapLeft\"><TD>Genome<TD>%s</TR>\n", bag->meta->srcDb);
+printf("<TR CLASS=\"transMapLeft\"><TD>Source<TD>%s</TR>\n", formatGeneSrcSet(bag->srcSet));
 
 // position
 printf("<TR CLASS=\"transMapLeft\"><TD>Position\n");
 printf("<TD CLASS=\"transMapNoWrap\">");
 if (bag->srcDbIsActive)
     printf("<A HREF=\"%s?db=%s&position=%s:%d-%d\" target=_blank>"
            "%s:%d-%d</A>",
            hgTracksName(), bag->meta->srcDb,
            bag->meta->srcChrom, bag->meta->srcChromStart, bag->meta->srcChromEnd,
            bag->meta->srcChrom, bag->meta->srcChromStart, bag->meta->srcChromEnd);
 else
     printf("%s:%d-%d", bag->meta->srcChrom, bag->meta->srcChromStart, bag->meta->srcChromEnd);
 printf("</TR>\n");
 
 // % identity and % aligned, values stored as 1000*fraction ident
 printf("<TR CLASS=\"transMapLeft\"><TD>Identity<TD>%0.1f%%</TR>\n",
        bag->meta->srcScore/10.0);
 printf("<TR CLASS=\"transMapLeft\"><TD>Aligned<TD>%0.1f%%</TR>\n",
        bag->meta->srcAligned/10.0);
 
 // gene and CDS
 printf("<TR CLASS=\"transMapLeft\"><TD>Gene<TD>%s</TR>\n",
        strOrNbsp(bag->meta->geneName));
 printf("<TR CLASS=\"transMapLeft\"><TD>Gene Id<TD>%s</TR>\n",
        strOrNbsp(bag->meta->geneId));
+printf("<TR CLASS=\"transMapLeft\"><TD>Gene Type<TD>%s</TR>\n",
+       strOrNbsp(bag->meta->geneType));
+printf("<TR CLASS=\"transMapLeft\"><TD>Transcript Id<TD>%s</TR>\n",
+       transMapIdToAcc(bag->meta->name));
+printf("<TR CLASS=\"transMapLeft\"><TD>Transcript Type<TD>%s</TR>\n",
+       strOrNbsp(bag->meta->transcriptType));
 printf("<TR CLASS=\"transMapLeft\"><TD>CDS<TD>%s</TR>\n",
        strOrNbsp(bag->meta->oCDS));
 printf("</TBODY></TABLE>\n");
 }
 
 static void displayAligns(struct trackDb *tdb, struct transMapBag *bag)
 /* display cDNA alignments */
 {
 int start = cartInt(cart, "o");
 printf("<H3>mRNA/Genomic Alignments</H3>");
 printAlignmentsSimple(bag->psl, start, "hgcTransMapCdnaAli", tdb->table, bag->psl->qName);
 }
 
 void transMapClickHandler(struct trackDb *tdb, char *mappedId)
 /* Handle click on a transMap tracks */