home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / Libraries / DCLAP 6d / dclap6d / DBio / DREPrint.cpp < prev    next >
Encoding:
Text File  |  1996-07-05  |  28.6 KB  |  1,071 lines  |  [TEXT/R*ch]
  1. // DREPrint.cpp
  2. // d.g.gilbert, 1991-95
  3.  
  4.  
  5. #include "DSequence.h"
  6. #include "DSeqList.h"
  7. #include "DSeqDoc.h"
  8. #include "DSeqPrint.h"
  9. #include "DSeqPrintSubs.h"
  10. #include "DREnzyme.h"
  11.  
  12. #include <ncbi.h>
  13. #include <dgg.h>
  14. #include <Dvibrant.h>
  15. #include <DControl.h>
  16. #include <DDialogText.h>
  17. #include <DWindow.h>
  18. #include <DTableView.h>
  19. #include <DApplication.h>
  20. #include <DTask.h>
  21. #include <DTracker.h>
  22. #include <DMenu.h>
  23. #include <DUtil.h>
  24.  
  25.  
  26.  
  27. // add this to ?? dgg.c
  28. inline void RectRgn(Nlm_RegioN rgn, Nlm_RectPtr r)
  29. {     Nlm_LoadRectRgn( rgn, r->left, r->top, r->right, r->bottom); }
  30.  
  31.  
  32.  
  33. // class DDrawZymeTable
  34.  
  35. // class DDrawAllZymeTable
  36.  
  37. // class DDrawNocutZymeTable
  38.  
  39.  
  40.  
  41. DDrawZymeTable::DDrawZymeTable(Nlm_FonT itsFont, DREMap * itsREMap, short rowoffset) :
  42.         fLinelist(NULL)
  43. {
  44.   fName= "";
  45.     fFont= itsFont;
  46.     if (fFont) Nlm_SelectFont(fFont);
  47.     fHeight= Nlm_LineHeight(); 
  48.     fTableTitle= "TABLE of enzymes";
  49.     fRowOffset= rowoffset;
  50. }
  51.  
  52. DDrawZymeTable::~DDrawZymeTable() 
  53. { 
  54.     for (short i=0; i<fLinecount; i++) MemFree( fLinelist[i]);
  55.     MemFree( fLinelist); 
  56. }
  57.  
  58.  
  59. char* DDrawZymeTable::TableLine(short atline) 
  60. { 
  61.     //if (atline == 0) return fTableTitle; else 
  62.     if (atline>=0 && atline<fLinecount) return fLinelist[atline];  
  63.     else return "";
  64. }
  65.  
  66. void  DDrawZymeTable::Clip( Nlm_RecT& r, short row, long startitem, long stopitem,
  67.                                          Nlm_RecT& viewr, Nlm_RegioN cliprgn)
  68. {
  69.     //Nlm_ClipRgn( cliprgn);
  70.     Nlm_RecT clipr= r;
  71.     clipr.left= viewr.left + 10;
  72.     clipr.right= viewr.right - 10;
  73.     clipr.bottom= Min( r.bottom, viewr.bottom);
  74.     clipr.top= Max(r.top, viewr.top);
  75.     Nlm_ClipRect( &clipr);
  76. }
  77.  
  78. void DDrawZymeTable::Draw( Nlm_RecT& r, short row, short col, long startitem, long stopitem)
  79. {
  80.     short     chleft, chvert, atline;
  81.     char  * tabline;
  82.     
  83.     chleft = r.left;
  84.     chvert = r.bottom-2;
  85.     atline = row - fRowOffset;
  86.     tabline= TableLine(atline);
  87.     if (tabline) {
  88.         if (col) { 
  89.           if (StrLen(tabline)>col) tabline += col; // ??? offset TableLine by # cols ?
  90.             else tabline= "";
  91.             }
  92.         if (fFont) Nlm_SelectFont(fFont);
  93.       if (atline == 0) {
  94.             Nlm_MoveTo( chleft, chvert-1);
  95.              Nlm_PaintString( tabline);
  96.             Nlm_MoveTo( r.left, r.bottom-1);
  97.             Nlm_LineTo( r.right, r.bottom-1);
  98.           }
  99.         else if (atline >= 0 && atline < fLinecount) {
  100.             Nlm_MoveTo( chleft, chvert);
  101.             Nlm_PaintString( tabline);
  102.             }
  103.         }
  104. }
  105.  
  106. const char* DDrawZymeTable::Write( short row, short col, long startitem, long stopitem)
  107. { 
  108.     long   len, atline;
  109.     char   * cp;
  110.  
  111.     atline = row - fRowOffset;
  112.     len= Min( kMaxLinebuf, 80);
  113.   if (atline == 0) {
  114.         Nlm_MemFill( fLinebuf, '_', len);
  115.          StrCpy( fLinebuf, TableLine(atline));
  116.          cp= StrChr(fLinebuf, '\0');
  117.          if (cp) *cp= ' ';
  118.       }
  119.     else if (atline >= 0 && atline < fLinecount) {
  120.         Nlm_MemFill( fLinebuf, ' ', len);
  121.         cp = TableLine(atline);
  122.         StrCpy( fLinebuf, cp);
  123.          cp= StrChr(fLinebuf, '\0');
  124.          if (cp) *cp= ' ';
  125.         }
  126.     else {
  127.         Nlm_MemFill( fLinebuf, ' ', len);
  128.         }
  129.     fLinebuf[len]= 0;
  130.     return fLinebuf;
  131. }
  132.  
  133.  
  134.  
  135. DDrawAllZymeTable::DDrawAllZymeTable(Nlm_FonT itsFont, DREMap * itsREMap, short rowoffset) :
  136.         DDrawZymeTable( itsFont, itsREMap, rowoffset)
  137. { 
  138.     fTableTitle= "TABLE of all enzymes";
  139.     if (1) {
  140.         char  * zymeline = NULL;
  141.         long  i, nzymes, linelen, linecount;
  142.         char  buf[128], comma;
  143.  
  144.         nzymes= DREMap::fREnzymes->GetSize();
  145.         linecount= 4 + nzymes / 4;
  146.         fLinelist= (char**) MemNew( linecount * sizeof(char*)); 
  147.         fLinecount= 0;
  148.         sprintf( buf, "  TABLE of All Enzymes  (name: cut count)");
  149.         fLinelist[fLinecount++]= StrDup(buf);
  150.         //sprintf( buf, " ");
  151.         //fLinelist[fLinecount++]= StrDup(buf);
  152.     
  153.         for (i=0, comma = ','; i<nzymes; i++) {
  154.             if (i == nzymes-1) comma= ' ';
  155.             DREnzyme* re= (DREnzyme*) DREMap::fREnzymes->At(i);
  156.             if (re) {
  157.                 //sprintf( buf, "%10s:%3d%c  ", re->fName, re->fCutcount, comma);
  158.                 sprintf( buf, "%9s:%3d  ", re->fName, re->fCutcount, comma);
  159.                 if (zymeline)  
  160.                     zymeline= Dgg_StrExtendCat( &zymeline, buf);
  161.                 else {
  162.                     zymeline= StrDup(buf);
  163.                     }
  164.               linelen= StrLen(zymeline);
  165.                 if (linelen > 70) {
  166.                     fLinelist[fLinecount++]= zymeline;
  167.                     zymeline= NULL;
  168.                     }
  169.                 }
  170.  
  171.           if (fLinecount >= linecount) {
  172.               linecount += 10;
  173.               fLinelist= (char**) Nlm_MemMore( fLinelist, linecount * sizeof(char*));
  174.               }
  175.             }
  176.         if (zymeline) fLinelist[fLinecount++]= zymeline;
  177.         }
  178. }
  179.  
  180.  
  181. DDrawNocutZymeTable::DDrawNocutZymeTable( Nlm_FonT itsFont, DREMap * itsREMap,
  182.              short rowoffset, short mincuts, short maxcuts) :
  183.         DDrawZymeTable( itsFont, itsREMap, rowoffset)
  184. { 
  185.     if (maxcuts) fTableTitle= "TABLE of excluded enzymes";
  186.     else fTableTitle= "TABLE of non-cutting enzymes";
  187.     if (1) {
  188.         char  * zymeline = NULL;
  189.         long  i, nzymes, linelen, linecount;
  190.         char  buf[128], comma;
  191.         Boolean dolist;
  192.         
  193.         nzymes= DREMap::fREnzymes->GetSize();
  194.         linecount= 4 + nzymes / 6;
  195.         fLinelist= (char**) MemNew( linecount * sizeof(char*)); 
  196.         fLinecount= 0;
  197.         if (maxcuts) sprintf( buf, "  TABLE of Excluded Enzymes");
  198.         else sprintf( buf, "  TABLE of Noncutting Enzymes");
  199.         fLinelist[fLinecount++]= StrDup(buf);
  200.         if (maxcuts) {
  201.             sprintf( buf, "  (cut with less than %d or more than %d cuts)", mincuts, maxcuts);
  202.             fLinelist[fLinecount++]= StrDup(buf);
  203.             }
  204.             
  205.         for (i=0, comma = ','; i<nzymes; i++) {
  206.             //if (i == nzymes-1) comma= ' ';
  207.             DREnzyme* re= (DREnzyme*) DREMap::fREnzymes->At(i);
  208.             if (re) {
  209.                 if (maxcuts)  
  210.                     dolist= (re->fCutcount > 0 && (re->fCutcount < mincuts || re->fCutcount > maxcuts));  
  211.                 else 
  212.                     dolist= re->fCutcount == 0;
  213.                 if (dolist) {
  214.                     //sprintf( buf, "%9s%c ", re->fName,comma);
  215.                     sprintf( buf, "%9s ", re->fName);
  216.                     if (zymeline)  
  217.                         zymeline= Dgg_StrExtendCat( &zymeline, buf);
  218.                     else {
  219.                         zymeline= StrDup(buf);
  220.                         }
  221.                   linelen= StrLen(zymeline);
  222.                     if (linelen > 60) {
  223.                         fLinelist[fLinecount++]= zymeline;
  224.                         zymeline= NULL;
  225.                         }
  226.                     }
  227.                 }
  228.  
  229.           if (fLinecount >= linecount) {
  230.               linecount += 10;
  231.               fLinelist= (char**) Nlm_MemMore( fLinelist, linecount * sizeof(char*));
  232.               }
  233.             }
  234.         if (zymeline) fLinelist[fLinecount++]= zymeline;
  235.         }
  236. }
  237.  
  238.  
  239.  
  240.  
  241.  
  242.  
  243.  
  244.  
  245. // class DDrawZymeCutTable
  246.  
  247.  
  248. #ifdef WIN_MSWIN
  249. static int LIBCALLBACK
  250. #else
  251. static int
  252. #endif
  253. zymenameCompare(void* a, void* b)
  254. {
  255.     short diff = StringCmp(((DRECutsItem*)a)->fREnzyme->fName, ((DRECutsItem*)b)->fREnzyme->fName);
  256.     if (diff == 0) {
  257.         return ((DRECutsItem*)a)->fSeqIndex - ((DRECutsItem*)b)->fSeqIndex;
  258.         }
  259.     else 
  260.         return diff;
  261. }
  262.  
  263.  
  264.  
  265. DDrawZymeCutTable::DDrawZymeCutTable(Nlm_FonT itsFont, DREMap * itsREMap, short rowoffset) :
  266.         DDrawZymeTable( itsFont, itsREMap, rowoffset),
  267.         fCutList(NULL), fCutcount(0), fCuttersCount(0)
  268. { 
  269.     fTableTitle= "TABLE of cut points";
  270.     if (itsREMap) {
  271.         fCutcount= itsREMap->fCutcount;
  272.         fCuttersCount= itsREMap->fCuttersCount;
  273.         fCutList= (DRECutsItem*) Nlm_MemDup( itsREMap->fSeqCuts, fCutcount * sizeof(DRECutsItem));
  274.         if (fCutList) {
  275.             long  i, at, lastat, linecount, linelen;
  276.             char  *name, *zymeline = NULL, *lastname="";
  277.             char  buf[128];
  278.             
  279.             Nlm_HeapSort( fCutList, fCutcount, sizeof(DRECutsItem), zymenameCompare);
  280.             
  281.             // what if we need more than one line for zyme cut list !!
  282.             for (i=0, linecount= 0; i<fCutcount; i++) {
  283.                 name= fCutList[i].fREnzyme->fName;
  284.                 if (StringCmp(name, lastname)!=0) linecount++;
  285.                 lastname= name;
  286.                 }
  287.           linecount += 3;
  288.             fLinelist= (char**) MemNew( linecount * sizeof(char*)); 
  289.             
  290.             fLinecount= 0;
  291.             sprintf( buf, "  TABLE of Cut Points");
  292.             fLinelist[fLinecount++]= StrDup(buf);
  293.             //sprintf( buf, " ");
  294.             //fLinelist[fLinecount++]= StrDup(buf);
  295.  
  296.           linelen= 0;
  297.             lastname= ""; lastat= -1;
  298.             for (i=0; i<fCutcount && fLinecount < linecount; i++) {
  299.                 name= fCutList[i].fREnzyme->fName;
  300.                 at= fCutList[i].fSeqIndex;
  301.                 if (StringCmp(name, lastname)==0 && linelen<70) { 
  302.                     if (at != lastat) {
  303.                       sprintf(buf, " %d", at);
  304.                         if (zymeline) { 
  305.                           zymeline= Dgg_StrExtendCat( &zymeline, buf);
  306.                           linelen= StrLen(zymeline);
  307.                           }
  308.                       }
  309.                     }
  310.                 else {
  311.                     if (zymeline) fLinelist[fLinecount++]= zymeline;
  312.                     sprintf(buf, "%s: %d", name, at);
  313.                     zymeline= (char*) MemNew(StrLen(buf)+1);
  314.                     Nlm_StringCpy(zymeline, buf);
  315.                     linelen= StrLen(buf);
  316.                     }
  317.                     
  318.                 lastname= name;
  319.                 lastat= at;
  320.               if (fLinecount >= linecount) {
  321.                   linecount += 10;
  322.                   fLinelist= (char**) Nlm_MemMore( fLinelist, linecount * sizeof(char*));
  323.                   }
  324.                 }
  325.             if (zymeline) fLinelist[fLinecount++]= zymeline;
  326.             }
  327.         }
  328. }
  329.  
  330.  
  331. DDrawZymeCutTable::~DDrawZymeCutTable() 
  332. { 
  333.     MemFree( fCutList); 
  334. }
  335.  
  336. char* DDrawZymeCutTable::TableLine(short atline) 
  337. { 
  338.     //if (atline == 0) return fTableTitle; else 
  339.     if (atline>=0 && atline<fLinecount) {
  340.         char * name = fLinelist[atline];
  341.         char * cp= StrChr(name,':'); 
  342.         if (cp) cp++; else cp= name;
  343.         return cp;  
  344.         }
  345.     else return "";
  346. }
  347.  
  348. char* DDrawZymeCutTable::GetName(short row) 
  349. { 
  350.     enum { kNameLen = 80 };
  351.     static char name[kNameLen];
  352.     short atline = row - fRowOffset;
  353.   if (atline == 0) {
  354.         return "ENZYME";
  355.         }
  356.     else if (atline> 0 && atline < fLinecount) {
  357.         StrNCpy(name, fLinelist[atline], kNameLen-1);
  358.         name[kNameLen-1]= 0;
  359.         char* cp= StrChr(name,':'); if (cp) *cp= 0;
  360.         return name;
  361.         }
  362.     else
  363.         return fName; 
  364. }
  365.  
  366.  
  367.  
  368. // class DDrawZymeRow
  369.  
  370.  
  371. DDrawZymeRow::DDrawZymeRow(Nlm_FonT itsFont, DSequence* itsSeq) : 
  372.       fSeq( itsSeq), fGoodMap(false), fCoSeq(NULL), fCutList(NULL),
  373.       fMinCuts(DSeqPrintPrefs::gREMinCuts), 
  374.       fMaxCuts(DSeqPrintPrefs::gREMaxCuts)
  375. { 
  376.   fName= "zyme";
  377.     fFont= itsFont;
  378.     if (fFont) Nlm_SelectFont(fFont);
  379.     fHeight= 4 * Nlm_LineHeight(); // ! need to calc line height for each row !?
  380.     fREMap= new DREMap();
  381.     if (fREMap) {
  382.         fREMap->MapSeq(fSeq);
  383.         fCoSeq= fREMap->fCoSeq;
  384.         fCutList= fREMap->fSeqCuts;
  385.         }
  386.     fGoodMap= (fREMap && fCoSeq && fCutList);
  387. }
  388.  
  389. void  DDrawZymeRow::Clip( Nlm_RecT& r, short row, long startitem, long stopitem,
  390.                                          Nlm_RecT& viewr, Nlm_RegioN cliprgn)
  391. {
  392.     //Nlm_ClipRgn( cliprgn);
  393.     Nlm_RecT clipr= r;
  394.     clipr.left= viewr.left + 10;
  395.     clipr.right= viewr.right - 10;
  396.     clipr.bottom= Min( r.bottom, viewr.bottom);
  397.     clipr.top= Max(r.top, viewr.top);
  398.     Nlm_ClipRect( &clipr);
  399. }
  400.  
  401.  
  402. #define znameCenter 0
  403.  
  404. short DDrawZymeRow::DrawOrMeasure( Nlm_Boolean doDraw, Nlm_RecT& r, short row, long startitem, long stopitem)
  405. {
  406. /*==== 
  407.         gctcggctgctgctcggctg
  408.                 ||        | ||
  409.              abcI    cbaII
  410.                                     hcgX
  411. ====*/
  412.  
  413.     short        nameHeight, rowLeft, rowTop;
  414.     short        chwidth, chleft, ncuts, cutindx;
  415.     short        cuts, wd, ws, rowBot, lasti, i;
  416.     Nlm_PoinT        at;
  417.     Boolean         first,overlap;
  418.     char             * lastzyme, * zymes;    
  419.     Nlm_RecT        fillRect, bRect, cRect;
  420.     Nlm_RegioN     filledArea, aRgn;
  421.  
  422.     if (!fGoodMap) return 0;
  423.     cutindx = 0; //cutindx= fLastZymeCut;
  424.     fREMap->CutsAtBase( startitem, cutindx, ncuts);    //!? don't care if startbase has no cuts
  425.     //fLastZymeCut= cutindx; // ????
  426.     
  427.     if (fFont) Nlm_SelectFont(fFont); 
  428.  
  429.     //atcellh= col;
  430.     nameHeight= Nlm_FontHeight(); // cHeight;
  431.     rowTop= r.top;
  432.     rowLeft= r.left;
  433.     rowBot= rowTop;
  434.     chwidth= (r.right - r.left) / (stopitem - startitem); 
  435.     
  436.     filledArea= Nlm_CreateRgn();
  437.     aRgn= Nlm_CreateRgn();
  438.     
  439.     chleft= rowLeft + kNucSpace;
  440.     Nlm_LoadRect( &fillRect, chleft, rowTop, chleft+1, rowTop+1);
  441.     RectRgn( filledArea, &fillRect); //must start w/ non-empty rgn
  442.     Nlm_MoveTo( chleft, rowTop);
  443.     for ( i= startitem; i<=stopitem; i++) {        
  444.         while (fCutList[cutindx].fSeqIndex < i) cutindx++;  
  445.         first= true;
  446.         lasti= -1; 
  447.         lastzyme= "";
  448.         while (fCutList[cutindx].fSeqIndex == i) {
  449.             zymes= fCutList[cutindx].fREnzyme->fName;
  450.             cuts = fCutList[cutindx].fREnzyme->fCutcount;
  451.             cutindx++;
  452.             if (cuts < fMinCuts || cuts > fMaxCuts)  goto nextZyme;  
  453.                 //! Kludge til we fix REMap to stop dups
  454.             if ( i==lasti && StringCmp(zymes,lastzyme)==0) goto nextZyme; 
  455.             lasti= i; 
  456.             lastzyme= zymes;
  457.             
  458.             if (first) {
  459.                 Nlm_MoveTo( chleft, rowTop);
  460.                 if (doDraw) Nlm_LineTo( chleft, rowTop+2/*kTicSize*/);
  461.                 else Nlm_MoveTo( chleft, rowTop+2);
  462.                 }
  463.  
  464.             ws= Nlm_StringWidth( zymes);
  465.             wd= 2 + ws / 2;
  466.             do {
  467.                 Nlm_GetPen( &at);
  468. #if znameCenter
  469.                 Nlm_LoadRect( &cRect, at.x-wd, at.y, at.x+wd, at.y+nameHeight);
  470. #else
  471.                 Nlm_LoadRect( &cRect, at.x-1, at.y, at.x+ws+1, at.y+nameHeight);
  472. #endif
  473.                 overlap= Nlm_RectInRgn( &cRect, filledArea); 
  474.             
  475.                 if (doDraw && overlap && !first) {
  476.                     //!? replace this w/ draw top to bottom of line, then overwrite zyme names 
  477.                     Nlm_LoadRect( &bRect, at.x, at.y-nameHeight, at.x+1, at.y);
  478.                     if (!Nlm_RectInRgn( &bRect, filledArea)) {
  479.                         Nlm_MoveTo( chleft, at.y-nameHeight+1);
  480.                         Nlm_LineTo( chleft, at.y);
  481.                         }
  482.                     }
  483.                 first= false;
  484.                 Nlm_MoveTo( chleft, at.y+nameHeight);
  485.             } while (overlap);
  486.     
  487.             RectRgn( aRgn, &cRect);
  488.             Nlm_UnionRgn(filledArea, aRgn, filledArea);
  489. #if znameCenter
  490.             Nlm_MoveTo( chleft - (ws / 2), at.y+nameHeight);
  491. #else
  492.             Nlm_MoveTo( chleft, at.y+nameHeight);
  493. #endif
  494.             if (doDraw) {
  495.                 //TextMode(srcCopy);  //erase line overlaps...
  496.                 Nlm_PaintString( zymes); 
  497.                 //TextMode(srcOr);
  498.                 }
  499.             Nlm_GetPen( &at);
  500.             rowBot = Max( rowBot, at.y);   
  501. nextZyme:            
  502.             lasti= i;
  503.             }
  504.             
  505.         //spaceright();
  506.         //chright= chleft + GetColWidth(atCellh) - fColInset;
  507.         //chleft = chright + fColInset;
  508.         //atcellh++;
  509.         chleft += chwidth;
  510.         }
  511.     Nlm_DestroyRgn( filledArea);
  512.     Nlm_DestroyRgn( aRgn);
  513.     return (rowBot - rowTop + 2); //+ 12); /* lineHeight + fudge factor*/    
  514. }
  515.  
  516.  
  517.  
  518.  
  519. const char* DDrawZymeRow::Write( short row, short col, long startitem, long stopitem)
  520. { 
  521. /*==== 
  522.         gctcggctgctgctcggctg
  523.                 ||        | ||
  524.              abcI    cbaII
  525.                                     hcgX
  526. ====*/
  527.  
  528.     short        chleft, ncuts, cutindx;
  529.     short        cuts, ws, lasti;
  530.     Boolean         first,overlap;
  531.     char             * lastzyme, * zymes;    
  532.  
  533.     short    linelen;
  534.     long  len, i, nlines, maxlines;
  535.     char ** lines;
  536.     short zlen, zat, atleft, atline;
  537.  
  538.  
  539.     if (!fGoodMap) return 0;
  540.     len= Min( kMaxLinebuf, stopitem-startitem);
  541.     Nlm_MemFill( fLinebuf, ' ', kMaxLinebuf);
  542.  
  543.     linelen= stopitem-startitem + 5; // +2;
  544.     maxlines= kMaxLinebuf / linelen;
  545.     lines= (char**) MemNew( (maxlines+1) * sizeof(char*));
  546.     for (i=0; i<maxlines; i++) lines[i]= fLinebuf + (linelen * i);
  547.     nlines= 0;
  548.     
  549.     cutindx = 0; //cutindx= fLastZymeCut;
  550.     fREMap->CutsAtBase( startitem, cutindx, ncuts);    //!? don't care if startbase has no cuts
  551.     //fLastZymeCut= cutindx; // ????
  552.         
  553.     for ( i= startitem; i<=stopitem; i++) {        
  554.         while (fCutList[cutindx].fSeqIndex < i) cutindx++;  
  555.         first= true;
  556.         lasti= -1; 
  557.         lastzyme= "";
  558.         chleft= i - startitem;
  559.         while (fCutList[cutindx].fSeqIndex == i) {
  560.             zymes= fCutList[cutindx].fREnzyme->fName;
  561.             cuts = fCutList[cutindx].fREnzyme->fCutcount;
  562.             cutindx++;
  563.             if (cuts < fMinCuts || cuts > fMaxCuts)  goto nextZyme;  
  564.                 //! Kludge til we fix REMap to stop dups
  565.             if ( i==lasti && StringCmp(zymes,lastzyme)==0) goto nextZyme; 
  566.             lasti= i; 
  567.             lastzyme= zymes;
  568.             
  569.             if (first) {
  570.                 lines[0][chleft]= '|';
  571.                 first= false;
  572.                 }
  573.  
  574.             ws= StrLen( zymes);
  575. #if znameCenter
  576.             wd= ws / 2;
  577.             atleft= chleft - wd;
  578. #else
  579.             atleft= chleft;
  580. #endif
  581.             atline= 1;
  582.             do {
  583.               for (zlen=0, zat=atleft, overlap= false; zlen<ws; zlen++, zat++) 
  584.                   if (lines[atline][zat] != ' ') { overlap= true; break; }
  585.               if (overlap) atline++;
  586.             } while (overlap && atline<maxlines);
  587.             MemCpy( lines[atline]+atleft, zymes, ws);
  588.             if (++atline > nlines) nlines= atline;
  589.             first= false;
  590.             
  591. nextZyme:            
  592.             lasti= i;
  593.             }
  594.             
  595.         }
  596.  
  597.     //return  (rowBot - rowTop + 12); /* lineHeight + fudge factor*/    
  598.  
  599.     for (i=1; i<nlines; i++) *(lines[i]-1)= '\n';
  600.     if (nlines) lines[nlines-1][linelen-1]= 0;
  601.     MemFree(lines);
  602.     fLinebuf[kMaxLinebuf]= 0;
  603.     return fLinebuf;
  604. }
  605.  
  606.  
  607.  
  608. short DDrawZymeRow::GetHeight( Nlm_RecT& r, short row, long startitem, long stopitem)
  609. { 
  610.     return DrawOrMeasure( false, r, row, startitem, stopitem);
  611. }
  612.  
  613. void DDrawZymeRow::Draw( Nlm_RecT& r, short row, short col, long startitem, long stopitem)
  614. {
  615.     if (col) { startitem += col; } // ??? 
  616.     (void) DrawOrMeasure( true, r, row, startitem, stopitem);
  617. }
  618.  
  619.  
  620.  
  621.  
  622. // class DDrawORFRow
  623.  
  624.  
  625.  
  626. DDrawORFRow::DDrawORFRow(Nlm_FonT itsFont, DSeqPrintView* itsView, DSequence* itsSeq,
  627.                                  DList* itsStyles, char* name, ulong* colors, short frame) : 
  628.     DDrawSeqRow( itsFont, itsView, itsSeq, itsStyles, name, colors),
  629.     fAAseq(NULL), fFrame( frame) 
  630. {
  631.     Boolean iscomp = frame > 2;
  632.     short   offset = frame % 3;
  633.     sprintf( fNameStore, "orf%d", frame);
  634.     fName= fNameStore;
  635.     if (iscomp) {
  636.         itsSeq->SetSelection( -1,-1);
  637.         itsSeq= itsSeq->Reverse();
  638.             // strange patches...
  639.         if (offset==1) offset= 2;     
  640.         else if (offset==2) offset= 1; 
  641.         if (offset==2) itsSeq->InsertSpacers(itsSeq->LengthF(),offset,'?');   
  642.         }
  643.     itsSeq->SetSelection( offset, itsSeq->LengthF() - offset);
  644.     fAAseq= itsSeq->OnlyORF(' ');
  645.     if (iscomp) { delete itsSeq; itsSeq= NULL; }
  646.     if (fAAseq) {
  647.         fBases= fAAseq->Bases();
  648.         fLength= fAAseq->LengthF();
  649.         if (iscomp) { 
  650.             fAAseq->SetSelection( -1,-1);
  651.             DSequence* unrevAA= fAAseq->Reverse(); 
  652.             delete fAAseq; 
  653.             fAAseq= unrevAA; 
  654.             fBases= fAAseq->Bases();
  655.             fLength= fAAseq->LengthF();
  656.             }
  657.             
  658.         // ?? convert orf bases to some symbol? e.g.,  ...[#####]...
  659.         }
  660. }
  661.  
  662. DDrawORFRow::~DDrawORFRow() 
  663. { 
  664.     if (fAAseq) delete fAAseq; 
  665. }
  666.  
  667. void DDrawORFRow::Draw( Nlm_RecT& r, short row, short col, long startitem, long stopitem)
  668. {
  669.     DDrawSeqRow::Draw(r, row, col, startitem, stopitem );
  670. }
  671.  
  672. const char* DDrawORFRow::Write( short row, short col, long startitem, long stopitem)
  673. { 
  674. /*==== 
  675.         gctcggctgctgctcggctg
  676.                 [---------] [--]
  677.                    [-----------]
  678. ====*/
  679.  
  680.     return DDrawSeqRow::Write( row, col, startitem, stopitem );
  681. }
  682.     
  683.  
  684.  
  685.  
  686.  
  687.  
  688.  
  689.  
  690. // class DREMapPrintView
  691.  
  692.  
  693. DREMapPrintView::DREMapPrintView( long id, DView* itsSuper, DSeqPrintDoc* itsDocument,
  694.                                  DSeqList* itsSeqList, long firstbase, long nbases, long pixwidth, long pixheight):
  695.     DSeqPrintView( id, itsSuper, itsDocument, itsSeqList, firstbase, 
  696.                             nbases, pixwidth, pixheight)
  697. { 
  698.     Initialize();
  699. }
  700.  
  701. void DREMapPrintView::IndexFromRow( long row, long& itemrow, long& seqline, long& startitem, long& stopitem)
  702. {
  703.         // !! modify itemrow to return drawer item row for tables after all of sequence as been drawn
  704.   if (row > fMaxseqrow) {
  705. #if 1
  706.         short i, n = fDrawRowList->GetSize();
  707.         itemrow= fLinesPerParag;
  708.     seqline= row - fMaxseqrow - 2; //??
  709.         for (i= fLinesPerParag; i<n; i++) {
  710.             DDrawMapRow* drawer= (DDrawMapRow*) fDrawRowList->At(i);
  711.             if (drawer && 
  712.                   row >= drawer->fRowOffset && row < drawer->fRowOffset + drawer->fLinecount) { 
  713.                   itemrow= i;
  714.                   seqline= row - drawer->fRowOffset; //??
  715.                   break; 
  716.                     }
  717.             }
  718. #else
  719.     itemrow= fLinesPerParag; // need to adjust this for each spacer, etc...
  720.       if (row > fMaxseqrow + 1) itemrow++;
  721.     seqline= row - fMaxseqrow - 2; //??
  722. #endif
  723.         startitem = seqline;
  724.         stopitem  = startitem+1; //??
  725.       }
  726.   else {
  727.         itemrow    = (row % fLinesPerParag);  
  728.         seqline = (row / fLinesPerParag) * fSeqsperparag;   
  729.         if (fOneseq) seqline += Max( 0, itemrow - fTopPerparag);
  730. #if 1
  731.         startitem = fFirstBase + seqline * fBasesPerLine;
  732.         stopitem  = Min(startitem + fBasesPerLine, fFirstBase+fNbases);
  733. #else
  734.         startitem = seqline * fBasesPerLine;
  735.         stopitem  = startitem + fBasesPerLine;
  736. #endif
  737.         }
  738. }
  739.  
  740. void DREMapPrintView::Initialize()
  741. {
  742.     DSeqPrintView::Initialize();
  743.  
  744.     fSeqLinesPerParag= 1;
  745.     fOneseq= false;
  746.     fDoMidIndex= fDoTopIndex;
  747.     fDoTopIndex= false;
  748.     fDoSeqLine= true;
  749.     fDoCoseqLine= DSeqPrintPrefs::gShowComplement;
  750.     fDoZymeLine= true;
  751.   
  752.     fDoAAline[0]= DSeqPrintPrefs::gShowAA1;
  753.     fDoAAline[1]= DSeqPrintPrefs::gShowAA2;
  754.     fDoAAline[2]= DSeqPrintPrefs::gShowAA3;
  755.     fDoAAline[3]= DSeqPrintPrefs::gShowCompAA1;
  756.     fDoAAline[4]= DSeqPrintPrefs::gShowCompAA2;
  757.     fDoAAline[5]= DSeqPrintPrefs::gShowCompAA3;    
  758.     
  759. }
  760.  
  761. void DREMapPrintView::SetScrollPage()
  762. {
  763.     fItemHeight= Nlm_stdLineHeight;
  764.     DTableView::SetScrollPage();
  765. }
  766.  
  767. void DREMapPrintView::MakeDrawList()
  768. {
  769.     short i, n;
  770.     ulong * colors = NULL;
  771.     DDrawZymeRow * zymerow = NULL;
  772.     DSequence* coseq = NULL;
  773.     Boolean anyamino;
  774.     
  775.     FreeLists();
  776.     //fDrawRowList= FreeListIfObject(fDrawRowList);
  777.     fDrawRowList= new DList(); // NULL, DList::kDeleteObjects << bad
  778.     fDrawRowList->InsertLast(new DDrawSpacer());
  779.     if (fDoTopIndex) 
  780.         fDrawRowList->InsertLast(new DDrawIndexRow(fNumFont,fBaseWidth));
  781.  
  782.     if (fDoZymeLine) {
  783.         fSeq->SetSelection(fFirstBase, fNbases);  // !? zyme map for only selected section
  784.         zymerow= new DDrawZymeRow( fNameFont, fSeq);
  785.         if (zymerow) {
  786.             if (!zymerow->fGoodMap) { delete zymerow; zymerow= NULL; }
  787.             else coseq= zymerow->fCoSeq;
  788.             }
  789.         }
  790.     else if (fDoCoseqLine) {
  791.         fSeq->SetSelection(0,0); // for Complement...
  792.         coseq= fSeq->Complement();
  793.         }
  794.     
  795.     anyamino= false;
  796.     for (i=0; i<6; i++) if (fDoAAline[i]) anyamino= true;
  797.  
  798.     //fStyles= FreeListIfObject(fStyles);
  799.     fStyles= new DList(); // NULL,DList::kDeleteObjects << bad
  800.     n= DStyleTable::fStyles->GetSize();
  801.     for (i=0; i<n; i++) fStyles->InsertLast( DStyleTable::fStyles->At(i));
  802.     
  803. #if 1
  804.     /* if (dospacer) */ fLinesPerParag = 1; fTopPerparag= 1;
  805.     if (fDoTopIndex) { fLinesPerParag++; fTopPerparag++; }
  806.     if (fDoSeqLine)
  807.         fDrawRowList->InsertLast( 
  808.             new DDrawSeqRow( fBaseFont, this, fSeq, fStyles, fSeq->Name(), colors));
  809.     if (fDoSeqLine) { fLinesPerParag++;  }
  810.     if (fDoMidIndex) 
  811.         fDrawRowList->InsertLast(new DDrawIndexRow(fNumFont,fBaseWidth,false));
  812.     if (fDoMidIndex) { fLinesPerParag++;  }
  813.     if (fDoCoseqLine && coseq)
  814.         fDrawRowList->InsertLast( 
  815.             new DDrawSeqRow( fBaseFont, this, coseq, fStyles, "compl", colors));
  816.     if (fDoCoseqLine && coseq) { fLinesPerParag++;}
  817.     if (fDoZymeLine && zymerow)
  818.         fDrawRowList->InsertLast( zymerow);
  819.     if (fDoZymeLine && zymerow) { fLinesPerParag++; }
  820.     if (anyamino)
  821.         fDrawRowList->InsertLast(new DDrawSpacer()); fLinesPerParag++;
  822.         
  823.     for (i= 0; i<3; i++) if (fDoAAline[i])
  824.         fDrawRowList->InsertLast( new DDrawAminoRow( fBaseFont, fSeq, i));
  825.     for (i= 0; i<3; i++) if (fDoAAline[i]) { fLinesPerParag++;  }
  826.     if (fDoMidIndex) 
  827.         fDrawRowList->InsertLast(new DDrawIndexRow(fNumFont,fBaseWidth,false));
  828.     if (fDoMidIndex) { fLinesPerParag++;  }
  829.     for (i= 3; i<6; i++) if (fDoAAline[i] && coseq)
  830.         fDrawRowList->InsertLast( new DDrawAminoRow( fBaseFont, coseq, i));
  831.     for (i= 3; i<6; i++) if (fDoAAline[i]) fLinesPerParag++;
  832.  
  833.     fDrawRowList->InsertLast(new DDrawSpacer()); fLinesPerParag++;
  834.     
  835. #else
  836.     for (i= 0; i<3; i++) if (fDoAAline[i])
  837.         fDrawRowList->InsertLast( new DDrawAminoRow( fBaseFont, fSeq, i));
  838.     if (fDoSeqLine)
  839.         fDrawRowList->InsertLast( 
  840.             new DDrawSeqRow( fBaseFont, this, fSeq, fStyles, fSeq->Name(), colors));
  841.     if (fDoMidIndex) 
  842.         fDrawRowList->InsertLast(new DDrawIndexRow(fNumFont,fBaseWidth,false));
  843.     if (fDoMidIndex) { fLinesPerParag++;  }
  844.     if (fDoCoseqLine && coseq)
  845.         fDrawRowList->InsertLast( 
  846.             new DDrawSeqRow( fBaseFont, this, coseq, fStyles, "compl", colors));
  847.     for (i= 3; i<6; i++) if (fDoAAline[i] && coseq)
  848.         fDrawRowList->InsertLast( new DDrawAminoRow( fBaseFont, coseq, i));
  849.     if (fDoZymeLine && zymerow)
  850.         fDrawRowList->InsertLast( zymerow);
  851.     /* if (dospacer) */ fLinesPerParag = 1; fTopPerparag= 1;
  852.     if (fDoTopIndex) { fLinesPerParag++; fTopPerparag++; }
  853.     for (i= 0; i<3; i++) if (fDoAAline[i]) { fLinesPerParag++; fTopPerparag++; }
  854.     if (fDoSeqLine) { fLinesPerParag++;  }
  855.     if (fDoCoseqLine && coseq) { fLinesPerParag++;}
  856.     for (i= 3; i<6; i++) if (fDoAAline[i]) fLinesPerParag++;
  857.     if (fDoZymeLine) { fLinesPerParag++; }
  858. #endif
  859.  
  860.     fMaxseqrow= 1 + (fMaxbases / fBasesPerLine);
  861.     fMaxseqrow *= fLinesPerParag;
  862.     if (zymerow && DSeqPrintPrefs::gShowCutpoints) {
  863.         fDrawRowList->InsertLast(new DDrawSpacer()); fExtrarows++;
  864.         DDrawZymeCutTable* ztab= new DDrawZymeCutTable( gTextFont/*fNumFont*/,  
  865.                                                                     zymerow->fREMap, fMaxseqrow+fExtrarows);  
  866.         fDrawRowList->InsertLast( ztab);  
  867.     fExtrarows += ztab->fLinecount + 1;
  868.     }
  869.     if (zymerow && DSeqPrintPrefs::gShowAllZymes) {
  870.         fDrawRowList->InsertLast(new DDrawSpacer()); fExtrarows++;
  871.         DDrawAllZymeTable* ztab= new DDrawAllZymeTable( gTextFont, zymerow->fREMap, 
  872.                                                                         fMaxseqrow+fExtrarows);  
  873.         fDrawRowList->InsertLast( ztab);  
  874.     fExtrarows += ztab->fLinecount + 1;
  875.     }
  876.     if (zymerow && DSeqPrintPrefs::gShowNoncutters) {
  877.         fDrawRowList->InsertLast(new DDrawSpacer()); fExtrarows++;
  878.         DDrawNocutZymeTable* ztab= new DDrawNocutZymeTable( gTextFont, zymerow->fREMap, 
  879.                                                                         fMaxseqrow+fExtrarows);  
  880.         fDrawRowList->InsertLast( ztab);  
  881.     fExtrarows += ztab->fLinecount + 1;
  882.     }
  883.     if (zymerow && DSeqPrintPrefs::gShowExcludedCutters) {
  884.         fDrawRowList->InsertLast(new DDrawSpacer()); fExtrarows++;
  885.         DDrawNocutZymeTable* ztab= new DDrawNocutZymeTable( gTextFont, zymerow->fREMap, 
  886.                                                                         fMaxseqrow+fExtrarows, 
  887.                                                                         DSeqPrintPrefs::gREMinCuts,
  888.                                                                         DSeqPrintPrefs::gREMaxCuts);  
  889.         fDrawRowList->InsertLast( ztab);  
  890.     fExtrarows += ztab->fLinecount + 1;
  891.     }
  892.      
  893. }
  894.  
  895.  
  896.  
  897. // class DREMapPrintDoc
  898.  
  899. DREMapPrintDoc::DREMapPrintDoc( long id, DSeqDoc* itsDoc, DSeqList* itsSeqList, long firstbase, long nbases) :
  900.     DSeqPrintDoc( id, itsDoc, itsSeqList, firstbase, nbases)
  901. {
  902.     short width= 450, height= 350;
  903.     //super->GetNextPosition( &nps);
  904.     //width = MAX( 40, fgWinRect.right - fgWinRect.left) - Nlm_vScrollBarWidth  - nps.x; 
  905.     //height= MAX( 60, fgWinRect.bottom - fgWinRect.top) - Nlm_hScrollBarHeight - nps.y;   
  906.     fView= new DREMapPrintView(0,this,this,fSeqList,fFirstBase,fNbases,width,height);
  907.  
  908.     char title[256];
  909.     DSequence * aSeq= (DSequence*) fSeqList->At(0);
  910.     if (aSeq)  
  911.         StrCpy(title, aSeq->Name());
  912.     else
  913.         itsDoc->GetTitle( title, sizeof(title)); 
  914.     StrCat( title, " Restr. Map");
  915.     SetTitle( title);
  916. }
  917.  
  918.  
  919.  
  920.  
  921.  
  922.  
  923.  
  924.  
  925. // class DAsmPrintView
  926.  
  927.  
  928. DAsmPrintView::DAsmPrintView( long id, DView* itsSuper, DSeqPrintDoc* itsDocument,
  929.                                  DSeqList* itsSeqList, long firstbase, long nbases, long pixwidth, long pixheight):
  930.     DSeqPrintView( id, itsSuper, itsDocument, itsSeqList, firstbase, 
  931.                             nbases, pixwidth, pixheight)
  932. { 
  933.     Initialize();
  934. }
  935.  
  936. void DAsmPrintView::IndexFromRow( long row, long& itemrow, long& seqline, long& startitem, long& stopitem)
  937. {
  938.         // !! modify itemrow to return drawer item row for tables after all of sequence as been drawn
  939.   if (row > fMaxseqrow) {
  940.         short i, n = fDrawRowList->GetSize();
  941.         itemrow= fLinesPerParag;
  942.     seqline= row - fMaxseqrow - 2; //??
  943.         for (i= fLinesPerParag; i<n; i++) {
  944.             DDrawMapRow* drawer= (DDrawMapRow*) fDrawRowList->At(i);
  945.             if (drawer && 
  946.                   row >= drawer->fRowOffset && row < drawer->fRowOffset + drawer->fLinecount) { 
  947.                   itemrow= i;
  948.                   seqline= row - drawer->fRowOffset; //??
  949.                   break; 
  950.                     }
  951.             }
  952.         startitem = seqline;
  953.         stopitem  = startitem+1; //??
  954.       }
  955.   else {
  956.         itemrow    = (row % fLinesPerParag);  
  957.         seqline = (row / fLinesPerParag) * fSeqsperparag;   
  958.         if (fOneseq) seqline += Max( 0, itemrow - fTopPerparag);
  959.         startitem = fFirstBase + seqline * fBasesPerLine;
  960.         stopitem  = Min(startitem + fBasesPerLine, fFirstBase+fNbases);
  961.         }
  962. }
  963.  
  964. void DAsmPrintView::Initialize()
  965. {
  966.     DSeqPrintView::Initialize();
  967.  
  968.     fSeqLinesPerParag= 1;
  969.     fOneseq= false;
  970.     fDoMidIndex= fDoTopIndex;
  971.     fDoTopIndex= false;
  972.     fDoSeqLine= true;
  973.     fDoCoseqLine= DSeqPrintPrefs::gShowComplement;
  974.     fDoZymeLine= true;
  975.   
  976.     fDoAAline[0]= false;
  977.     fDoAAline[1]= false;
  978.     fDoAAline[2]= false;
  979.     fDoAAline[3]= false;
  980.     fDoAAline[4]= false;
  981.     fDoAAline[5]= false;    
  982.     
  983. }
  984.  
  985. void DAsmPrintView::SetScrollPage()
  986. {
  987.     fItemHeight= Nlm_stdLineHeight;
  988.     DTableView::SetScrollPage();
  989. }
  990.  
  991. void DAsmPrintView::MakeDrawList()
  992. {
  993.     short i, n;
  994.     ulong * colors = NULL;
  995.     DDrawZymeRow * zymerow = NULL;
  996.     DSequence* coseq = NULL;
  997.     Boolean anyamino;
  998.     
  999.     FreeLists();
  1000.     fDrawRowList= new DList(); // NULL, DList::kDeleteObjects << bad
  1001.     fDrawRowList->InsertLast(new DDrawSpacer());
  1002.     if (fDoTopIndex) 
  1003.         fDrawRowList->InsertLast(new DDrawIndexRow(fNumFont,fBaseWidth));
  1004.  
  1005.     if (fDoZymeLine) {
  1006.         fSeq->SetSelection(fFirstBase, fNbases);  // !? zyme map for only selected section
  1007.         zymerow= new DDrawZymeRow( fNameFont, fSeq);
  1008.         if (zymerow) {
  1009.             if (!zymerow->fGoodMap) { delete zymerow; zymerow= NULL; }
  1010.             else coseq= zymerow->fCoSeq;
  1011.             }
  1012.         }
  1013.     else if (fDoCoseqLine) {
  1014.         fSeq->SetSelection(0,0); // for Complement...
  1015.         coseq= fSeq->Complement();
  1016.         }
  1017.     
  1018.     anyamino= false;
  1019.  
  1020.     fStyles= new DList(); // NULL,DList::kDeleteObjects << bad
  1021.     n= DStyleTable::fStyles->GetSize();
  1022.     for (i=0; i<n; i++) fStyles->InsertLast( DStyleTable::fStyles->At(i));
  1023.     
  1024.     /* if (dospacer) */ fLinesPerParag = 1; fTopPerparag= 1;
  1025.     if (fDoTopIndex) { fLinesPerParag++; fTopPerparag++; }
  1026.     if (fDoSeqLine)
  1027.         fDrawRowList->InsertLast( 
  1028.             new DDrawSeqRow( fBaseFont, this, fSeq, fStyles, fSeq->Name(), colors));
  1029.     if (fDoSeqLine) { fLinesPerParag++;  }
  1030.     if (fDoMidIndex) 
  1031.         fDrawRowList->InsertLast(new DDrawIndexRow(fNumFont,fBaseWidth,false));
  1032.     if (fDoMidIndex) { fLinesPerParag++;  }
  1033.     if (fDoCoseqLine && coseq)
  1034.         fDrawRowList->InsertLast( 
  1035.             new DDrawSeqRow( fBaseFont, this, coseq, fStyles, "compl", colors));
  1036.     if (fDoCoseqLine && coseq) { fLinesPerParag++;}
  1037.     if (fDoZymeLine && zymerow)
  1038.         fDrawRowList->InsertLast( zymerow);
  1039.     if (fDoZymeLine && zymerow) { fLinesPerParag++; }
  1040.  
  1041.     fDrawRowList->InsertLast(new DDrawSpacer()); fLinesPerParag++;
  1042.     
  1043.     fMaxseqrow= 1 + (fMaxbases / fBasesPerLine);
  1044.     fMaxseqrow *= fLinesPerParag;
  1045.  
  1046.      
  1047. }
  1048.  
  1049.  
  1050.  
  1051. // class DAsmPrintDoc 
  1052.  
  1053. DAsmPrintDoc::DAsmPrintDoc( long id, DSeqDoc* itsDoc, DSeqList* itsSeqList, long firstbase, long nbases) :
  1054.     DSeqPrintDoc( id, itsDoc, itsSeqList, firstbase, nbases)
  1055. {
  1056.     short width= 450, height= 350;
  1057.     fView= new DAsmPrintView(0,this,this,fSeqList,fFirstBase,fNbases,width,height);
  1058.  
  1059.     char title[256];
  1060.     DSequence * aSeq= (DSequence*) fSeqList->At(0);
  1061.     if (aSeq)  
  1062.         StrCpy(title, aSeq->Name());
  1063.     else
  1064.         itsDoc->GetTitle( title, sizeof(title)); 
  1065.     StrCat( title, " Assembly");
  1066.     SetTitle( title);
  1067. }
  1068.  
  1069.  
  1070.  
  1071.