home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / Libraries / DCLAP 6d / dclap6d / DBio / DSeqViews.cpp < prev    next >
Encoding:
Text File  |  1996-07-05  |  47.4 KB  |  2,069 lines  |  [TEXT/R*ch]
  1. // DSeqViews.cpp
  2.  
  3. #define MASKS 1
  4.  
  5. #include "DSeqViews.h"
  6.  
  7. #include <ncbi.h>
  8. #include <dgg.h>
  9. #include <Dvibrant.h>
  10. #include <DApplication.h>
  11. #include <DClipboard.h>
  12. #include <DControl.h>
  13. #include <DWindow.h>
  14. #include <DRichViewNu.h>
  15. #include <DTableView.h>
  16. #include <DViewCentral.h>
  17. #include <DTask.h>
  18. #include <DTracker.h>
  19. #include <DMenu.h>
  20. #include <DUtil.h>
  21. #include <DFindDlog.h>
  22. #include "DSeqFile.h"
  23. #include "DSeqEd.h"
  24. #include "DSeqMail.h"
  25. #include "DSeqCmds.h"
  26. #include "DSeqChildApp.h"
  27. #include "DSeqPrint.h"
  28. #include "DSeqPict.h"
  29. #include "DSeqDoc.h"
  30.  
  31.  
  32.  
  33. #define BACKCOLOR
  34. #define TESTVARHEIGHT
  35. #undef TESTZOOM
  36.  
  37.  
  38. Local short gAlnCharWidth = 12;
  39. Local short gAlnCharHeight = 15;
  40. Local short kORFxtraHeight = 4; // also in DSeqAsmView.cpp !
  41.  
  42. //Local short gMinCommonPercent = 0;
  43. Local Boolean gSwapBackground = false;
  44. typedef unsigned long  colorVal;
  45.  
  46. extern "C" void Nlm_SelectBackColor(Nlm_Uint1 red, Nlm_Uint1 green, Nlm_Uint1 blue);
  47. extern "C" void Nlm_SetBackColor (Nlm_Uint4 color);
  48.  
  49.  
  50. #define ETEXT 1
  51.  
  52.  
  53. extern "C" void Nlm_HScrollText (Nlm_BaR sb, Nlm_GraphiC t,
  54.                                Nlm_Int2 newval, Nlm_Int2 oldval);
  55. extern "C" void Nlm_DoActivate(void* g, Nlm_Boolean saveport);
  56. //extern Nlm_Boolean   gDialogTextMultiline;
  57. extern "C" void Nlm_SetTextColumns( Nlm_GraphiC t, Nlm_Int2 ncolumns);
  58.  
  59.  
  60.  
  61. // class DAlnSequence
  62.  
  63. #ifdef  WIN_MAC
  64. #define kTextLineCharwidth    1
  65. #else
  66. #define kTextLineCharwidth    charwidth
  67. #endif
  68.  
  69. DAlnSequence::DAlnSequence(long id, DAlnView* itsSuperior, short charwidth):
  70.         DTextLine(id, itsSuperior->fDoc, NULL, kTextLineCharwidth, gSeqFont),  
  71.         fSeq(NULL),fVisible(false), fNcols(0)
  72. {
  73.     fAlnView= itsSuperior;
  74.     SetMultilineText(false);
  75. }
  76.  
  77. void DAlnSequence::Scroll(Boolean vertical, DView* scrollee, long newval, long oldval) 
  78. {
  79.     if (fVisible && !vertical) { 
  80. #ifndef WIN_MAC
  81.     long curlen= Nlm_TextLength(fText);
  82.     if (newval > curlen) newval= curlen;
  83. #endif
  84.         Nlm_HScrollText( NULL, (Nlm_GraphiC)GetNlmObject(), newval, oldval);
  85.         }
  86. }
  87.  
  88. void DAlnSequence::SetColumns( long ncolumns)
  89. {
  90.     if (fNcols != ncolumns) {
  91.         fNcols= ncolumns;
  92.         Nlm_SetTextColumns( (Nlm_GraphiC)GetNlmObject(), ncolumns);
  93.         }
  94. }
  95.  
  96. void DAlnSequence::Select(long start, long length)
  97. {
  98.     Nlm_SelectText(fText, start, length + start);
  99. }
  100.  
  101. Boolean DAlnSequence::IsMyAction(DTaskMaster* action) 
  102. {
  103.     switch(action->Id()) {
  104.         case DApplication::kFind:
  105.         case DApplication::kFindAgain:
  106.             return gApplication->DoMenuTask(action->Id(), NULL);
  107.         case DSeqDoc::cFindORF:
  108.             return fAlnView->fDoc->DoMenuTask( action->Id(), NULL);
  109.         default:
  110.             return DDialogText::IsMyAction(action);
  111.         }
  112. }
  113.  
  114.  
  115.  
  116. void DAlnSequence::ShowEdit(Boolean newseq)
  117. {
  118.     if (newseq && fSeq) {
  119.         SetText( fSeq->Bases());
  120.         }
  121.     if (!fVisible) {
  122.         fVisible= true;
  123.         Show(); 
  124.         Enable();
  125.         }
  126.         // may need this for MSWIN
  127.     //Nlm_DoActivate(GetNlmObject(),false); 
  128. }
  129.  
  130. void DAlnSequence::HideEdit()
  131. {
  132.     if (fVisible) {
  133.         fVisible= false;
  134.         Disable();
  135.         Hide();
  136.         }
  137. }
  138.  
  139. void DAlnSequence::selectAction()
  140. {
  141.     DTextLine::selectAction();
  142.     //gCursor->ibeam();
  143.     SetKeyHandler(this); //?? also need this call in a window activate/deactivate method??
  144. }
  145.  
  146. void DAlnSequence::deselectAction()
  147. {
  148.     SetKeyHandler(NULL); //?? also need this call in a window activate/deactivate method??
  149.     //fDoc->SetEditText(NULL);
  150.     //gCursor->arrow();
  151.     DTextLine::deselectAction();
  152. }
  153.  
  154. void DAlnSequence::ProcessKey( char c)
  155. {
  156.     enum moves {
  157.         down1 =  1,
  158.         up1        = -1,
  159.         downPage= 10,  // this is arbitrary...
  160.         upPage  = -10,
  161.         toBottom=  25000,
  162.         toTop        = -25000
  163.         };
  164.         
  165.     if ( IsEnabled() && !gKeys->command()) { 
  166.         // dang vibrant doens't have means to change this key, and default handlers still get
  167.         // a crack at it...
  168.  
  169.         switch (c) {
  170.         
  171. #if 0
  172.             case chTab: 
  173.               //? do horizontal shift here ?
  174.                 break;
  175.  
  176.             case chRight:
  177.                 if (gKeys->shift()) ;
  178.                 else ;
  179.             case chLeft:
  180.                 if (gKeys->shift()) ;
  181.                 else ;
  182.                 
  183.             case chUp:
  184.                 if (gKeys->shift()) vertMove(toTop);
  185.                 else vertMove(up1);
  186.                 break;
  187.                 
  188.             case chDown:
  189.             case chEnter:
  190.             case chReturn:
  191.                 if (gKeys->shift())  vertMove(toBottom);
  192.                 else vertMove(down1);
  193.                 break;
  194.                 
  195.             case chPageDown    :    vertMove( downPage); break;
  196.             case chPageUp        :    vertMove( upPage); break;
  197.             case chHome            : vertMove( toTop); break;
  198.             case chEnd             : vertMove( toBottom); break;    
  199. #endif
  200.         
  201.             default: 
  202.                 if (!fSeq->GoodChar(c)) Nlm_Beep(); 
  203.                 break; 
  204.             }
  205.         }
  206. }
  207.  
  208.  
  209.  
  210. class DMaskSelector : public DTabSelector 
  211. {
  212. public:
  213.     enum { cMaskSelector = 20732 };
  214.     short fMaskLevel;
  215.     DSeqList* fSeqList;
  216.     
  217.     DMaskSelector( DTableView* itsTable, short masklevel, DSeqList* seqlist) : 
  218.         DTabSelector( itsTable),
  219.         fSeqList( seqlist),  fMaskLevel(masklevel) 
  220.         {
  221.         fNumber= cMaskSelector;
  222.         }
  223.     virtual void DoItWork(); 
  224. };
  225.  
  226.  
  227. void DMaskSelector::DoItWork()  
  228. {
  229.     if (fMovedOnce || fDoExtend) {
  230. #if MASKS
  231.             // select masks... instead of, or as well as, table sel rect??
  232.         if (fMaskLevel>0) {
  233.             short row, col, top, bot, left, right;
  234.             Nlm_RecT viewr;
  235.             top= fNewSelection.top;
  236.             bot= fNewSelection.bottom;
  237.             left= fNewSelection.left;
  238.             right= fNewSelection.right;
  239.             for (row= top; row<bot; row++) {
  240.                 DSequence* sq= fSeqList->SeqAt(row);
  241.                 if (sq) {
  242.                     for (col= left; col<right; col++) 
  243.                       if (fDoExtend) sq->SetMaskAt(col,fMaskLevel);
  244.                         else sq->FlipMaskAt(col, fMaskLevel);
  245.                     }                
  246.                 }
  247.             ((DTableView*)fView)->GetCellRect(fNewSelection,viewr);
  248.             ((DTableView*)fView)->InvalRect( viewr);
  249.             }
  250.         else
  251. #endif
  252.         ((DTableView*)fView)->SelectCells( fNewSelection, 
  253.                 fDoExtend,  DTabSelection::kHighlight,  DTabSelection::kSelect);
  254.         }
  255. }
  256.  
  257.  
  258.  
  259.  
  260. static short gBaseCharWidth = 12;
  261.  
  262. //inline 
  263. static short BaseCharWidth()
  264. {
  265. #ifdef TESTZOOM
  266.     if (gBaseCharWidth>1) gBaseCharWidth= Nlm_CharWidth('G');
  267. #else
  268.     gBaseCharWidth= Nlm_CharWidth('G');
  269. #endif
  270.     return gBaseCharWidth;
  271.     //return Nlm_MaxCharWidth(); 
  272.     //return Nlm_stdCharWidth;
  273. }
  274.  
  275.  
  276.  
  277.  
  278. //class DAlnView : public DTableView  
  279.  
  280.     // test var for fEditSeq bomb...
  281. DAlnView* gLastEditView = NULL;
  282.  
  283.  
  284. DAlnView::DAlnView( long id, DView* itsSuper, DSeqDoc* itsDocument, DSeqList* itsSeqList, 
  285.                                 long pixwidth, long pixheight) :
  286.     DTableView( id, itsSuper, pixwidth, pixheight, 0, 0, Nlm_stdCharWidth, 2+Nlm_stdFontHeight,
  287.                         true, true),
  288.     fDoc(itsDocument), fSeqList(itsSeqList), fSlider(NULL),
  289.     fEditRow(-1), fMaskLevel(0), fCurSeq(NULL), fEditSeq(NULL),
  290.     fLocked(false), fOwnSeqlist(false), 
  291.     fColorBases(kBaseBlack), fColcolors(NULL), fNcolcolors(0)
  292. { 
  293.     fKind= kindAlnView;
  294. #ifdef TESTZOOM
  295.     if (gKeys->shift()) gBaseCharWidth= 1; else gBaseCharWidth= Nlm_stdCharWidth;
  296. #endif
  297.     gAlnCharWidth= gBaseCharWidth; //Nlm_stdCharWidth; //BaseCharWidth();   
  298.     gAlnCharHeight= Nlm_stdLineHeight;
  299.     this->SetResize( DView::relsuper, DView::relsuper);
  300.     this->SetTableFont(gSeqFont);
  301.     //fSlider= new DAlnSlider( fDoc, this, 0);
  302. }
  303.  
  304.  
  305. enum { 
  306.      kAlnIndexName = 0,
  307.      kAlnIndexSize,
  308.      kAlnIndexKind,
  309.      kAlnIndexRow,
  310.      kAlnIndexChecksum,
  311.      kAlnIndexCols,            // end of listings
  312.      kAlnIndexShowORF,     // hide this one for now
  313.      knada
  314.      };
  315.  
  316. DAlnIndex::DAlnIndex( long id, DView* itsSuper, DSeqDoc* itsDocument, DSeqList* itsSeqList,
  317.                  long pixwidth, long pixheight) :
  318.     DTableView( id, itsSuper, pixwidth, pixheight, 0, kAlnIndexCols,
  319.             5*Nlm_stdCharWidth, 2+Nlm_stdFontHeight, false, true),
  320.     fNameWidth(15),
  321.     fSizeWidth(8),
  322.     fKindWidth(8),
  323.     fDoc(itsDocument),
  324.     fSeqList(itsSeqList)
  325. { 
  326.     //this->SetSlateBorder(false);
  327.     this->SetResize( DView::fixed, DView::relsuper);
  328.     this->SetTableFont(gTextFont);
  329.     //fChangedFont= gItalicTextFont;
  330. }
  331.  
  332. DAlnITitle::DAlnITitle( long id, DView* itsSuper, long pixwidth, long pixheight) :
  333.     DTableView( id, itsSuper, pixwidth, pixheight, 1, kAlnIndexCols,
  334.             5*Nlm_stdCharWidth, 2+Nlm_stdFontHeight, false, false),
  335.     fNameWidth(15),
  336.     fSizeWidth(8),
  337.     fKindWidth(8)
  338. { 
  339.     //this->SetSlateBorder(false);
  340.     this->SetResize( DView::fixed, DView::fixed);
  341.     this->SetTableFont(gTextFont);
  342. }
  343.  
  344. DAlnHIndex::DAlnHIndex( long id, DView* itsSuper, DSeqDoc* itsDocument, DSeqList* itsSeqList, long pixwidth, long pixheight) :
  345.     DPanel( id, itsSuper, pixwidth, pixheight, DPanel::simple),
  346.     fDoc(itsDocument), fLastCol(-1),
  347.     fSeqList(itsSeqList)
  348. { 
  349.     //this->SetResize( DView::matchsuper, DView::fixed);
  350.     this->SetResize( DView::relsuper, DView::fixed);
  351. }
  352.  
  353. DAlnView::~DAlnView()
  354. {
  355.     //fSeqList= NULL; // fSeqList is owned by Doc !
  356.     DeInstallEditSeq();
  357.     //if (fSlider) delete fSlider;
  358. #if FIX_LATER
  359.     itsEditSeq= fEditSeq;     
  360.     if (itsEditSeq && itsEditSeq->fSuperior)
  361.         itsEditSeq->fSuperior->RemoveSubView(itsEditSeq);
  362.     delete itsEditSeq;
  363. #endif
  364. }
  365.  
  366.                 
  367.  
  368. void DAlnHIndex::Resize(DView* superview, Nlm_PoinT sizechange)
  369. {
  370.     DPanel::Resize(superview, sizechange);
  371. }
  372.  
  373. void DAlnView::Resize(DView* superview, Nlm_PoinT sizechange)
  374. {
  375.     DTableView::Resize(superview, sizechange);
  376.     CheckViewCharWidth();
  377. }
  378.  
  379. void DAlnView::CheckViewCharWidth()
  380. {
  381.     if (fEditSeq) {
  382.         Nlm_RecT vr;
  383.         ViewRect( vr);
  384.         long cwidth= (vr.right - vr.left) / GetItemWidth(0);
  385.         fEditSeq->SetColumns( cwidth);
  386.         }
  387. }
  388.  
  389.  
  390. void DAlnView::GetReadyToShow()
  391. {
  392.     // assume port is set??
  393.     SelectFont();  
  394.     gAlnCharWidth = BaseCharWidth();   
  395.         // use Nlm_FontHeight for background color to adjoin among rows
  396.     gAlnCharHeight= Nlm_FontHeight(); //Nlm_LineHeight(); // + 2; 
  397.     SetItemWidth(0, GetMaxCols(), gAlnCharWidth);
  398.     
  399. #ifdef notnow_TESTVARHEIGHT
  400.     // testing
  401.     long i, nrow= GetMaxRows();
  402.     for (i= 0; i<nrow; i += 2) {
  403.         short ht= gAlnCharHeight;
  404.         if ( i % 4 == 2) ht *= 2;
  405.         SetItemHeight(i, 2, ht);
  406.         }    
  407. #else
  408.     SetItemHeight(0, GetMaxRows(), gAlnCharHeight);
  409. #endif
  410.     this->UpdateAllWidths(); 
  411.     this->UpdateSize();  
  412. }
  413.  
  414. void DAlnIndex::GetReadyToShow()
  415. {
  416.     //SelectFont();  
  417.     SetItemWidth(0, GetMaxCols(), fViewrect.right-fViewrect.left-1); //<< width of view
  418. #ifdef TESTVARHEIGHT
  419.     // testing
  420.     DAlnView* aview= fDoc->fAlnView;
  421.     long i, nrow= GetMaxRows();
  422.     for (i= 0; i<nrow; i++) {
  423.         long ht= aview->GetItemHeight(i);
  424.         SetItemHeight(i, 1, ht);
  425.         }
  426. #else
  427.     SetItemHeight(0, GetMaxRows(), gAlnCharHeight);
  428. #endif
  429. }
  430.  
  431. void DAlnITitle::GetReadyToShow()
  432. {
  433.     // assume port is set??
  434.     SelectFont();
  435.     short charheight=  Nlm_LineHeight(); // Nlm_FontHeight();
  436.     SetItemWidth(0, GetMaxCols(), fViewrect.right-fViewrect.left-1); //<< width of view
  437.     SetItemHeight(0, GetMaxRows(), charheight);
  438. }
  439.  
  440. void DAlnView::Show()
  441. {
  442.     GetReadyToShow();
  443.     DTableView::Show();
  444. }
  445.  
  446. void DAlnIndex::Show()
  447. {
  448.     GetReadyToShow();
  449.     DTableView::Show();
  450. }
  451.  
  452. void DAlnView::Drag(Nlm_PoinT mouse)
  453. {
  454. #if 0
  455.     short     row, col;
  456.     PointToCell( mouse, row, col);
  457.     SeqMeter(row,col);
  458. #endif
  459.     DTableView::Drag(mouse); // sets fMouseStillDown= true
  460. }
  461.  
  462. void DAlnIndex::Drag(Nlm_PoinT mouse)
  463. {
  464.     DTableView::Drag(mouse); // sets fMouseStillDown= true
  465. }
  466.  
  467. void DAlnHIndex::Drag(Nlm_PoinT mouse)
  468. {
  469.     DPanel::Drag(mouse);
  470.     ClickColumn(mouse);
  471. }
  472.  
  473. void DAlnView::Hold(Nlm_PoinT mouse)
  474. {
  475.     DTableView::Hold(mouse);
  476. }
  477.  
  478. void DAlnIndex::Hold(Nlm_PoinT mouse)
  479. {
  480.     DTableView::Hold(mouse);
  481. }
  482.  
  483. void DAlnHIndex::Hold(Nlm_PoinT mouse)
  484. {
  485.     DPanel::Hold(mouse);
  486. }
  487.  
  488. void DAlnView::Release(Nlm_PoinT mouse)
  489. {
  490.     DTableView::Release(mouse);
  491. }
  492.  
  493. void DAlnIndex::Release(Nlm_PoinT mouse)
  494. {
  495.     DTableView::Release(mouse);
  496. }
  497.  
  498. void DAlnHIndex::Release(Nlm_PoinT mouse)
  499. {
  500.     DPanel::Release(mouse);
  501. }
  502.  
  503.  
  504. void DAlnView::DoubleClickAt(long row, long col)
  505. {
  506. #if 0
  507.     //?? do this only on DAlnIndex dblclik??
  508.     DSequence* ag= fSeqList->SeqAt(row); 
  509.     if (ag) fDoc->OpenSeqedWindow(ag);
  510. #endif
  511. }
  512.  
  513.  
  514. void DAlnIndex::Click(Nlm_PoinT mouse)
  515. {
  516.     long      row, col;
  517.     //if (gLastCommand) { delete gLastCommand; gLastCommand= NULL; } //gLastCommand->Commit();    //??
  518.     
  519.     fDoc->fAlnView->DeInstallEditSeq();
  520.     fDoc->fAlnView->SetEmptySelection(true); 
  521.  
  522.     PointToCell( mouse, row, col);
  523.     
  524.     if (col == kAlnIndexShowORF) {
  525.         DSequence* aSeq= fDoc->fSeqList->SeqAt(row);
  526.         if (aSeq) {
  527.             if (aSeq->ShowORF()) aSeq->SetShowORF(0);  
  528.             else aSeq->SetShowORF(1+2+4+8);
  529.             fDoc->fAlnView->Invalidate();  
  530.             this->Invalidate();
  531.             fDoc->fAlnView->GetReadyToShow(); 
  532.             this->GetReadyToShow();
  533.             }
  534.         return;
  535.         }
  536.         
  537.     else if (Nlm_dblClick)
  538.         ;
  539.     else if (IsSelected(row, col)) {   //if (gKeys->shift()) 
  540.         // slide/shift selected lines...
  541.         DAlnShifter* shifter= new DAlnShifter();  
  542.         shifter->IAlnSlider( fDoc, this, fDoc->fAlnView, row);
  543.         fCurrentTracker= shifter;
  544.         }
  545.     else {
  546.         //if (fTabSelector) fTabSelector->suicide();  // is this delete causing bombs? YES, in motif
  547.         fTabSelector= new DTabSelector( this);
  548.         fCurrentTracker= fTabSelector;
  549.      }
  550.     DTableView::Click( mouse);
  551. }
  552.  
  553.  
  554. void DAlnITitle::Click(Nlm_PoinT mouse)
  555. {
  556.         // damn, need this or the like for each user of DTableView::Click ...
  557.     //if (gLastCommand) { delete gLastCommand; gLastCommand= NULL; } //gLastCommand->Commit();    //??
  558.  
  559.     //if (fTabSelector) fTabSelector->suicide();  // is this delete causing bombs? YES, in motif
  560.     fTabSelector= new DTabSelector( this);
  561.     fCurrentTracker= fTabSelector;
  562.  
  563.     DTableView::Click( mouse);
  564. }
  565.  
  566.  
  567.  
  568.  
  569. void DAlnView::Click(Nlm_PoinT mouse)
  570. {
  571.     long     row, col;
  572.  
  573.     //if (gLastCommand) { delete gLastCommand; gLastCommand= NULL; } //gLastCommand->Commit();    //??
  574.  
  575.     Nlm_CaptureSlateFocus((Nlm_SlatE) fPanel); //! need for CharHandler !
  576.  
  577.     PointToCell( mouse, row, col);
  578.     
  579.     SeqMeter(row,col);
  580.  
  581.     if (fMaskLevel<1 && IsSelected(row, col)) {
  582.         //if (fSlider) delete fSlider;  // is this delete causing bombs?
  583.         fSlider= new DAlnSlider();
  584.         fSlider->IAlnSlider( fDoc, this, this, 0);
  585.         fCurrentTracker= fSlider;
  586.         }
  587.     else {
  588.         //if (fTabSelector) fTabSelector->suicide();  // is this delete causing bombs? YES, in motif
  589. #if MASKS
  590.         if (fMaskLevel>0) 
  591.             fTabSelector= new DMaskSelector( this, fMaskLevel, fSeqList);
  592.         else
  593. #endif
  594.             fTabSelector= new DTabSelector( this);
  595.         fCurrentTracker= fTabSelector;
  596.         }
  597.  
  598.     DTableView::Click( mouse);
  599. }
  600.  
  601.  
  602. void DAlnView::TrackMouse( short aTrackPhase,
  603.                     Nlm_PoinT& anchorPoint, Nlm_PoinT& previousPoint,
  604.                     Nlm_PoinT& nextPoint,    Nlm_Boolean mouseDidMove)
  605. {
  606.     DTableView::TrackMouse( aTrackPhase, anchorPoint, previousPoint, nextPoint,mouseDidMove); 
  607. }
  608.  
  609.  
  610. void DAlnView::TrackFeedback( short aTrackPhase,
  611.                     const Nlm_PoinT& anchorPoint, const Nlm_PoinT& previousPoint,
  612.                     const Nlm_PoinT& nextPoint, Nlm_Boolean mouseDidMove, Nlm_Boolean turnItOn)
  613. {
  614. #if 1
  615.     long     row, col;
  616.     if (mouseDidMove && aTrackPhase == DTracker::trackContinue ) { // 2 == trackContinue
  617.         PointToCell( nextPoint, row, col);
  618.         SeqMeter(row,col);
  619.         }
  620. #endif
  621.     DTableView::TrackFeedback( aTrackPhase, anchorPoint, previousPoint, nextPoint,
  622.                     mouseDidMove, turnItOn);
  623. }
  624.  
  625.  
  626. void DAlnIndex::DoubleClickAt(long row, long col)
  627. {
  628.     DSequence* ag= fSeqList->SeqAt(row); 
  629.     if (ag) fDoc->OpenSeqedWindow(ag);
  630. }
  631.  
  632. void DAlnITitle::DoubleClickAt(long row, long col)
  633. {
  634. }
  635.  
  636.  
  637.  
  638. void DAlnView::SeqMeter(long row, long col)
  639. {
  640.     // display base# location of mouse
  641.     if (fDoc->fSeqMeter) {
  642.         char basen[80];
  643.         sprintf(basen,"%d",col+1);
  644.         fDoc->fSeqMeter->SetTitle( basen);
  645.         }
  646. }
  647.  
  648. void DAlnView::SingleClickAt(long row, long col)
  649. {
  650. #if ETEXT
  651.     if (!(fLocked || gKeys->shift() || gKeys->command() || gKeys->option() )) {  
  652.         SetEmptySelection( true); 
  653.         if (fDoc->fAlnIndex) fDoc->fAlnIndex->SetEmptySelection( true); 
  654.         InstallEditSeq(row,col,col,false);
  655.         }
  656.     else
  657. #endif
  658. #if MASKS
  659.     if (fMaskLevel>0) {
  660.         Nlm_RecT r;
  661.         DSequence* ag= fSeqList->SeqAt(row); 
  662.         if (ag) {
  663.             if (gKeys->shift()) ag->SetMaskAt(col,fMaskLevel);
  664.             else ag->FlipMaskAt(col,fMaskLevel);
  665.             }
  666.         GetCellRect( row, col, r);
  667.         InvalRect( r);
  668.         }
  669.     else
  670. #endif
  671.          DTableView::SingleClickAt(row,  col);
  672.      //fDoc->SetViewMenu();
  673. }
  674.  
  675. void DAlnIndex::SingleClickAt(long row, long col)
  676. {
  677.      DTableView::SingleClickAt(row,  col);
  678.      //fDoc->SetViewMenu();
  679. }
  680.  
  681. void DAlnITitle::SingleClickAt(long row, long col)
  682. {
  683. }
  684.  
  685. void DAlnHIndex::Click(Nlm_PoinT mouse)
  686. {
  687.     DPanel::Click(mouse);
  688.     fLastCol= -1;
  689.     ClickColumn(mouse);
  690. }
  691.     
  692. void DAlnHIndex::ClickColumn(Nlm_PoinT mouse)
  693. {
  694. #if MASKS
  695.     long row, col;
  696.     // if (fMouseStillDown && ...)
  697.     short masklevel= fDoc->fAlnView->fMaskLevel;
  698.     fDoc->fAlnView->PointToCell( mouse, row, col);
  699.     
  700.     if (col != fLastCol && col >= 0 && col < fDoc->fAlnView->GetMaxCols()) {
  701.         Nlm_RecT r;
  702.         long irow, nrow= fSeqList->GetSize();
  703.         if (masklevel == 0) {
  704.             r.left= col;
  705.             r.right= col+1;
  706.             r.top= 0;
  707.             r.bottom= fDoc->fAlnView->GetMaxRows(); 
  708.             long ext;
  709.             if (gKeys->shift()) ext=  DTabSelection::kExtendSingle;
  710.             else if (gKeys->command()) ext=  DTabSelection::kExtendMulti;
  711.             else ext=  DTabSelection::kDontExtend;
  712.             fDoc->fAlnView->InvalidateSelection();
  713.             fDoc->fAlnView->SelectCells( r, ext, 
  714.                             ! DTabSelection::kHighlight,  DTabSelection::kSelect);
  715.             fDoc->fAlnView->InvalidateSelection();
  716.             }
  717.         else for (irow=0; irow<nrow; irow++) {
  718.             DSequence* ag= fSeqList->SeqAt(irow); 
  719.             if (ag) {
  720.                 if (gKeys->shift()) ag->SetMaskAt(col,masklevel);
  721.                 else ag->FlipMaskAt(col,masklevel);
  722.                 }
  723.             fDoc->fAlnView->GetCellRect( irow, col, r);
  724.             fDoc->fAlnView->InvalRect(r); //InvalRect(r);
  725.             }
  726.         fLastCol= col;
  727.         }
  728.         
  729. #endif
  730. }
  731.     
  732.  
  733.  
  734. void DAlnView::Scroll(Boolean vertical, DView* scrollee, long newval, long oldval)
  735. {
  736.     long diff= newval - oldval;
  737.  
  738.     DTableView::Scroll(vertical, scrollee, newval, oldval);
  739.     
  740.     if (diff && fEditSeq && fEditSeq->fVisible) {
  741.         Nlm_RecT    r, oldr;
  742.         long delta;
  743.         if (vertical) {
  744.             delta= diff * fItemHeight; // bad for variable line height
  745.             fEditSeq->GetPosition( r);
  746.             oldr= r;
  747.             Nlm_OffsetRect( &r, 0, -delta);
  748.             if (r.top < fRect.top || r.top >= fRect.bottom) {
  749.                 //DeInstallEditSeq();
  750.                 fEditSeq->HideEdit();
  751.                 fDoc->SetEditText(NULL); //??
  752.                 InvalRect(r);
  753.                 }
  754.             else {
  755.                 fEditSeq->SetPosition( r);
  756.                     // !!! must re-install editseq if it gets back in view !!
  757.                 if (oldr.top < fRect.top || oldr.top >= fRect.bottom) {
  758.                     fEditSeq->ShowEdit(false);
  759.                     fDoc->SetEditText(fEditSeq); 
  760.                     InvalRect(r); //??
  761.                     }
  762.                 }
  763.             }
  764.         else {
  765. #if 1
  766.                 // messy, undo bitmap scroll by TableView for just editseq rect...
  767.             fEditSeq->GetPosition(r);
  768.             delta= diff * GetItemWidth(0); //fItemWidth; //gAlnCharWidth
  769.             Nlm_ScrollRect(&r, delta, 0);
  770.                     // then redo scroll using edit method !
  771.             fEditSeq->Scroll(vertical, scrollee, newval, oldval);
  772. #endif
  773.             }
  774.         }
  775.         
  776.     if (scrollee == this) {
  777.         if (vertical) {
  778.             fDoc->fAlnIndex->Scroll(vertical, scrollee, newval, oldval);
  779.             }
  780.         else {
  781.             fDoc->fAlnHIndex->Scroll(vertical, scrollee, newval, oldval);
  782.             }
  783.         }
  784. }
  785.  
  786. void DAlnIndex::Scroll(Boolean vertical, DView* scrollee, long newval, long oldval)
  787. {
  788.     DTableView::Scroll(vertical, scrollee, newval, oldval);
  789.     if (scrollee == this) {
  790.         if (vertical) {
  791.             fDoc->fAlnView->Scroll(vertical, scrollee, newval, oldval);
  792.             }
  793.         else   // horizontal
  794.             fDoc->fAlnITitle->Scroll(vertical, scrollee, newval, oldval);
  795.              
  796.         }
  797. }
  798.  
  799.  
  800. void DAlnHIndex::Scroll(Boolean vertical, DView* scrollee, long newval, long oldval)
  801. {
  802.     Nlm_RecT    r;
  803.     long delta;
  804.     long diff= newval-oldval;
  805.     ViewRect(r);
  806.     this->Select(); // need for motif !
  807.     if (vertical) {
  808. #if 0
  809.         delta= diff * cHeight;
  810.         Nlm_ScrollRect (&r, 0, -delta);
  811.         if (diff<0) r.bottom= r.top - delta + Min(5,-delta/2);
  812.         else r.top= r.bottom - delta - Min(5,delta/2);
  813. #endif
  814.         }
  815.     else {
  816. #if 1
  817.         short cWidth= gAlnCharWidth;
  818.         delta= diff * cWidth;
  819.         Nlm_ScrollRect (&r, -delta, 0);
  820.             // test fix for off-by-a-few-pixels in scroll...
  821.         if (diff<0) r.right= r.left - delta + Min(5,-delta/2);
  822.         else r.left= r.right - delta - Min(5,delta/2);
  823. #endif
  824.         }
  825.     this->InvalRect( r);
  826.  
  827.     if (scrollee == this) {
  828.         if (!vertical) fDoc->fAlnView->Scroll(vertical, scrollee, newval, oldval);
  829.         }
  830. }
  831.  
  832.  
  833.  
  834. DSequence* DAlnView::SelectedSequence(long& selectedRow)
  835. {
  836.     if (GetSelectedRow() !=  DTabSelection::kNoSelection) {
  837.         selectedRow= GetSelectedRow();
  838.         return fSeqList->SeqAt(selectedRow);
  839.         }
  840.     else if (fDoc && fDoc->fAlnIndex->GetSelectedRow() !=  DTabSelection::kNoSelection) {
  841.         selectedRow= fDoc->fAlnIndex->GetSelectedRow();
  842.         return fSeqList->SeqAt(selectedRow);    
  843.         }
  844. #if 1
  845.     else if (fEditSeq && fEditRow>=0) {
  846.         selectedRow= fEditRow;
  847.         return fSeqList->SeqAt(selectedRow);    
  848.         }
  849. #endif
  850.     else {
  851.         selectedRow=  DTabSelection::kNoSelection;
  852.         return NULL;
  853.         }
  854. }
  855.  
  856.  
  857. void DAlnView::UpdateSize()
  858. {    
  859.     long diff;   
  860.     if (fSeqList) diff= fSeqList->GetSize() - GetMaxRows();
  861.     else diff= -GetMaxRows();
  862.     ChangeRowSize( -1, diff);  // -1 prevents redraw..else use fMaxRows    
  863.     if (fDoc && fDoc->fAlnIndex) fDoc->fAlnIndex->ChangeRowSize(-1, diff);
  864.  
  865. #if MASKS
  866.     if (diff>0) { //fMaskLevel>0 && 
  867.         long i, nseq= fSeqList->GetSize();
  868.         for (i=nseq-diff; i<nseq; i++) {
  869.             DSequence* aseq= fSeqList->SeqAt(i);
  870.             if (fMaskLevel>0 || aseq->Masks()) aseq->FixMasks();
  871.             }
  872.         }
  873. #endif
  874. }
  875.  
  876.  
  877. void DAlnView::UpdateWidth(DSequence* aSeq)
  878. { 
  879.     long alnlen= aSeq->LengthF() + 30;
  880.     if (alnlen > GetMaxCols()) ChangeColSize( -1, alnlen-GetMaxCols());  
  881.     SetItemWidth( 0, GetMaxCols(), gAlnCharWidth); 
  882. #if MASKS
  883.     if (fMaskLevel>0 || aSeq->Masks()) aSeq->FixMasks();
  884. #endif
  885.     //if (fDoc && fDoc->fAlnHIndex) fDoc->fAlnHIndex->UpdateWidth(); //keep ruler in sync
  886. }
  887.  
  888. void DAlnView::UpdateAllWidths()
  889. {
  890.     long alnlen= 0;
  891.     long i, nseq= fSeqList->GetSize();
  892.     for (i=0; i<nseq; i++) {
  893.         DSequence* aSeq= fSeqList->SeqAt(i);
  894.         alnlen= Max(alnlen, aSeq->LengthF()); 
  895. #if MASKS
  896.         if (fMaskLevel>0 || aSeq->Masks()) aSeq->FixMasks();
  897. #endif
  898.         }
  899.     alnlen += 30; 
  900.     if (alnlen > GetMaxCols()) ChangeColSize( -1, alnlen-GetMaxCols());
  901.     SetItemWidth( 0, GetMaxCols(), gAlnCharWidth);  
  902.     //if (fDoc && fDoc->fAlnHIndex) fDoc->fAlnHIndex->UpdateWidth(); //keep ruler in sync
  903. }
  904.  
  905. void DAlnView::SetTextLock( Boolean turnon)
  906. {
  907.     fLocked= turnon;
  908.     if (fLocked) DeInstallEditSeq();
  909. }
  910.  
  911.  
  912. void DAlnView::SetViewMode(short viewmode) 
  913. {
  914.     switch (viewmode) {
  915.         case kModeSlide: 
  916.             this->SetTextLock( true);
  917.             if (this->fMaskLevel>0) this->Invalidate();
  918.             this->fMaskLevel= 0; 
  919.             break;
  920.             
  921.         case kModeEdit:  
  922.             this->SetTextLock( false);
  923.             if (this->fMaskLevel>0) this->Invalidate();
  924.             this->fMaskLevel= 0; 
  925.             break;
  926.             
  927.         case kModeMask1: 
  928.         case kModeMask2: 
  929.         case kModeMask3: 
  930.         case kModeMask4: {
  931.             this->SetTextLock( true);
  932.             this->fMaskLevel= viewmode - kModeMask1 + 1; 
  933.             this->Invalidate();
  934.             long i, nseq= fSeqList->GetSize();
  935.             for (i=0; i<nseq; i++) fSeqList->SeqAt(i)->FixMasks();
  936.             }
  937.             break;
  938.             
  939.         default :
  940.             break;
  941.         }
  942. }
  943.  
  944. void DAlnView::SetViewColor(short colorkind) 
  945. {
  946.     if (colorkind > kBaseVarLite) {
  947.         gSwapBackground= true; // temp set
  948.         colorkind -= 2; // hack !
  949.         }
  950.     else {
  951.         gSwapBackground= false;
  952.         }
  953.  
  954.     switch (colorkind) {
  955. #if 0
  956.         case kBaseBackColor: 
  957.             gSwapBackground= true; 
  958.             break;
  959. #endif
  960.         case kBaseBlack: 
  961.         case kBaseColor:  
  962.         case kBaseVarLite: 
  963.         default :
  964.             //gSwapBackground= false;
  965.             break;
  966.         }
  967.     
  968.     //if (fColorBases != colorkind) 
  969.     Invalidate();
  970.     fColorBases= colorkind;
  971. }
  972.  
  973.  
  974. void DAlnView::CharHandler(char c) 
  975. {
  976.     switch (c) {
  977.     
  978.         case 0x08:    // backspace
  979.         case 0x7f:     // Delete (but mapped to backspace here...)
  980.             // delete selected softindels... == degap
  981.             (void) fDoc->DoMenuTask( DSeqDoc::cDegap, NULL);
  982.             break;
  983.             
  984.         case 0x0D: // return // 0x03 == enter
  985.         case 0x09: // tab
  986.       case 0x1C: // <- arrow
  987.         case 0x1D: // -> arrow
  988.         case 0x1E: // ^ arrow
  989.         case 0x1F: // v arrow
  990.         default: 
  991.             break; 
  992.         }
  993. }
  994.  
  995.  
  996.  
  997.  
  998. // move this to DSeqCmds.h ...
  999. class DSetEditCmd : public DSeqChangeCmd {
  1000. public: 
  1001.     DSetEditCmd( DSeqDoc* itsAlnDoc, DView* itsView, DSequence* oldSeq, char*& newbases):
  1002.          DSeqChangeCmd("edit seq", itsAlnDoc, itsView, NULL) 
  1003.          {
  1004.             fOldSeqs= new DSeqList(); 
  1005.              fOldSeqs->InsertLast( oldSeq);
  1006.             DSequence* newSeq= (DSequence*)oldSeq->Clone();
  1007.             newSeq->SetBases(newbases, false);
  1008.             newSeq->SetChanged(true);
  1009.             fNewSeqs->InsertLast( newSeq);
  1010.          }
  1011. };
  1012.  
  1013.  
  1014. void DAlnView::DeInstallEditSeq()
  1015. {
  1016.     if (fEditRow >= 0) { 
  1017.         if (fEditSeq) {
  1018.             Nlm_RecT r;
  1019.             Boolean didedit= false;
  1020.             char* newbases = fEditSeq->GetText();
  1021.             if (StringCmp(newbases, fEditSeq->fSeq->Bases()) != 0) {
  1022.                 didedit= true;
  1023.                 DSetEditCmd* cmd= new DSetEditCmd( fDoc, this, fEditSeq->fSeq, newbases);
  1024.                 if (cmd) PostTask(cmd); 
  1025.                 }
  1026.             MemFree( newbases);
  1027.           
  1028.             fEditSeq->GetPosition(r);
  1029.             fEditSeq->HideEdit();
  1030.             fDoc->SetEditText(NULL); //??
  1031.             InvalRect(r);
  1032.             if (didedit && fDoc->fAlnIndex) {
  1033.                 fDoc->fAlnIndex->GetRowRect( fEditRow, r);
  1034.                 fDoc->fAlnIndex->InvalRect( r);
  1035.                 }
  1036.             }
  1037.         fEditRow= -1;
  1038.         }
  1039.  
  1040. }
  1041.  
  1042.  
  1043.  
  1044. void DAlnView::InstallEditSeq(long row, long selStart, long selEnd, Boolean doLight)
  1045. {
  1046.          
  1047.     DeInstallEditSeq();
  1048.     //if (gLastEditView && gLastEditView != this) gLastEditView->DeInstallEditSeq();
  1049.  
  1050.     fEditRow= row;
  1051.     if (row >= 0) {
  1052.         Nlm_RecT r;
  1053.         DSequence* aSeq= fSeqList->SeqAt( row);
  1054.         this->GetRowRect( row, r);
  1055.         
  1056.         if (r.left > 0) r.left--; // fix off-by-one!?
  1057.         long cwidth= (r.right - r.left) / GetItemWidth(0);
  1058.         long oldval= -1; // force scroll/setposition
  1059.         long leftoff= GetLeft();
  1060.         
  1061. #ifdef WIN_MOTIF
  1062.             // must install new editseq each time -- otherwiz trash-city...
  1063.         if (fEditSeq) delete fEditSeq;
  1064.         fEditSeq= new DAlnSequence( 0, this, cwidth); 
  1065. #endif
  1066.         fEditSeq->fSeq= aSeq;
  1067.         fEditSeq->SetPosition( r);
  1068.         fEditSeq->ShowEdit(true);
  1069.         fEditSeq->SetSelection( selStart, selEnd);
  1070. #ifdef WIN_MAC
  1071.             // mac - off-by-one if oldvalue=-1 !!
  1072.         if (leftoff>0) fEditSeq->Scroll(false, NULL,leftoff, 0);
  1073. #else
  1074.             // motif - off-by-one if oldvalue=0 !!
  1075.         fEditSeq->Scroll(false, NULL, leftoff, oldval);
  1076. #endif
  1077.         fDoc->SetEditText(fEditSeq); //done by SetSelection??
  1078.  
  1079.         if (gLastCommand) { delete gLastCommand; gLastCommand= NULL; } //gLastCommand->Commit();    //??
  1080.         //gLastEditView= this;
  1081.         }
  1082.  
  1083. }
  1084.  
  1085.  
  1086. void DAlnView::registerInsertLast( DSequence* aSeq)
  1087. {
  1088.     ChangeRowSize( GetMaxRows(), 1);
  1089.     if (fDoc && fDoc->fAlnIndex) 
  1090.         fDoc->fAlnIndex->ChangeRowSize( GetMaxRows(), 1);
  1091.     UpdateWidth(aSeq);    
  1092. }
  1093.  
  1094. void DAlnView::addToAlnList( DSequence* aSeq)
  1095. {
  1096.     fSeqList->InsertLast( aSeq);
  1097.     //aSeq->fIndex= fSeqList->GetSize(); //??
  1098.     registerInsertLast( aSeq); 
  1099.  
  1100. #if NOT_NOW_MASKS
  1101.         // done via registerInsertLast -> UpdateWidth
  1102.         if (fMaskLevel>0 || aSeq->fMasks) aSeq->FixMasks();
  1103. #endif
  1104. }
  1105.  
  1106.  
  1107. void DAlnView::MakeConsensus()
  1108. { 
  1109.     fSeqList->MakeConsensus();
  1110.     long arow= fSeqList->ConsensusRow();
  1111.     if (arow>0) {
  1112.         Nlm_RecT r;
  1113.         GetRowRect( arow, r);
  1114.         this->InvalRect( r);
  1115.         }
  1116. }
  1117.  
  1118.  
  1119. char* DAlnView::FindCommonBases( short minCommonPerCent)
  1120. {
  1121. // THIS_IS_OBSOLETE
  1122.     char *hCommon, *hFirst = NULL;
  1123.     //gMinCommonPercent= minCommonPerCent;
  1124.     hCommon= fSeqList->FindCommonBases(DSeqList::gMinCommonPercent, hFirst);
  1125.     if (hFirst) MemFree( hFirst);
  1126.     return hCommon;
  1127. }
  1128.  
  1129.  
  1130. void DAlnView::HiliteORFs()
  1131. {
  1132.     long    start, stop;
  1133.     long nseq= fSeqList->GetSize();
  1134.     if (fMaskLevel>0) 
  1135.     for (long iseq= 0; iseq<nseq; iseq++) {
  1136.         DSequence* aSeq= fSeqList->SeqAt(iseq);
  1137.         long alen= aSeq->LengthF();
  1138.         aSeq->ClearMask(fMaskLevel);
  1139.         aSeq->ClearSelection();
  1140.  
  1141.         aSeq->SearchORF( start, stop);
  1142.         while (start>=0) {
  1143.             if (stop<start) stop= alen;
  1144.             for (long ibase=start; ibase<=stop; ibase++) 
  1145.                 aSeq->SetMaskAt( ibase, fMaskLevel);
  1146.             if (stop >= alen) start= -1;
  1147.             else {
  1148.               aSeq->SetSelection( stop+1, alen);
  1149.                 aSeq->SearchORF( start, stop);
  1150.                 }
  1151.             }
  1152.         } 
  1153.     this->Invalidate();
  1154. }
  1155.  
  1156.  
  1157. Boolean DAlnView::IsMasked()
  1158. {  
  1159.     if (fMaskLevel>0) {
  1160.         long iseq, nseq= fSeqList->GetSize();
  1161.         for ( iseq= 0; iseq<nseq; iseq++) {
  1162.             DSequence* aseq= fSeqList->SeqAt(iseq);
  1163.             long jbase, nbases= aseq->LengthF();
  1164.             if (aseq->MasksOk())
  1165.              for (jbase= 0; jbase<nbases; jbase++) {
  1166.                 if ( aseq->MaskAt(jbase, fMaskLevel) > 0) 
  1167.                     return true;
  1168.                 }
  1169.             }
  1170.         }
  1171.     return false;
  1172. }
  1173.  
  1174.  
  1175. void DAlnView::ReplicateMask()
  1176. {  
  1177.     if (fMaskLevel > 0 && fDoc && fDoc->fAlnIndex) {
  1178.       long refRow= fDoc->fAlnIndex->GetSelectedRow();
  1179.         if (refRow !=  DTabSelection::kNoSelection) {
  1180.             DSequence* refSeq = fSeqList->SeqAt(refRow);
  1181.             long nseq= fSeqList->GetSize();
  1182.             if (refSeq) 
  1183.             for (long iseq= 0; iseq<nseq; iseq++)
  1184.              if (iseq != refRow) {
  1185.                 DSequence* aSeq= fSeqList->SeqAt(iseq);
  1186.                 long alen= aSeq->LengthF();
  1187.                 for (long ibase=0; ibase<alen; ibase++) {
  1188.                     long val= refSeq->MaskAt(ibase, fMaskLevel);
  1189.                     aSeq->SetMaskAt( ibase, fMaskLevel, val);
  1190.                     }
  1191.                 }
  1192.             this->Invalidate();
  1193.             }
  1194.         }
  1195. }
  1196.  
  1197. Boolean DAlnView::MaskCommand(short command)
  1198. {  
  1199.     //if (menuid == kSeqMaskMenu && fMaskLevel>0)   
  1200.     
  1201.         long iseq, nseq= fSeqList->GetSize();
  1202.         long jbase, nbases;
  1203.         short maskval, selval;
  1204.         
  1205.          switch (command) {
  1206.          
  1207.              case DSeqDoc::cMaskReplicate:
  1208.                  ReplicateMask();
  1209.                  return true;
  1210.                  
  1211.             case DSeqDoc::cMaskSelCommon:
  1212.                 HiliteCommonBases();
  1213.                 return true;
  1214.                 
  1215.             case DSeqDoc::cMaskSelORF:
  1216.                 HiliteORFs();
  1217.                 return true;
  1218.                 
  1219.             case DSeqDoc::cMaskSelAll:
  1220.                 for (iseq= 0; iseq<nseq; iseq++) 
  1221.                     fSeqList->SeqAt(iseq)->SetMask(fMaskLevel);
  1222.                 Invalidate();
  1223.                 return true;
  1224.                 
  1225.             case DSeqDoc::cMaskInvert:
  1226.                 for (iseq= 0; iseq<nseq; iseq++) 
  1227.                     fSeqList->SeqAt(iseq)->FlipMask(fMaskLevel);
  1228.                 Invalidate();
  1229.                 return true;
  1230.                 
  1231.             case DSeqDoc::cMaskClear:
  1232.                 for (iseq= 0; iseq<nseq; iseq++) 
  1233.                     fSeqList->SeqAt(iseq)->ClearMask(fMaskLevel);
  1234.                 Invalidate();
  1235.                 return true;
  1236.  
  1237.             case DSeqDoc::cSel2Mask:
  1238.                 for (iseq= 0; iseq<nseq; iseq++) {
  1239.                     DSequence* aseq= fSeqList->SeqAt(iseq);
  1240.                     nbases= aseq->LengthF();
  1241.                     for (jbase= 0; jbase<nbases; jbase++) {
  1242.                         selval= IsSelected(iseq,jbase);
  1243.                         aseq->SetMaskAt(jbase, fMaskLevel, selval);
  1244.                         }
  1245.                     }
  1246.                 Invalidate();
  1247.                 return true;
  1248.  
  1249.             case DSeqDoc::cMask2Sel:
  1250.             case DSeqDoc::cMaskOrSel:
  1251.             case DSeqDoc::cMaskAndSel:
  1252.                 for (iseq= 0; iseq<nseq; iseq++) {
  1253.                     DSequence* aseq= fSeqList->SeqAt(iseq);
  1254.                     nbases= aseq->LengthF();
  1255.                     for (jbase= 0; jbase<nbases; jbase++) {
  1256.                         maskval= aseq->MaskAt(jbase, fMaskLevel);
  1257.                         selval = IsSelected(iseq,jbase);
  1258.                         switch (command) {
  1259.                           case DSeqDoc::cMask2Sel    : selval= maskval; break;
  1260.                           case DSeqDoc::cMaskOrSel: selval= (selval | maskval); break;
  1261.                           case DSeqDoc::cMaskAndSel: selval= (selval & maskval); break;
  1262.                           }
  1263.                           
  1264. // !! This IS NO GOOD now -- must have disjoint selection ability in DTableView...
  1265.                         SelectCells(iseq,jbase, DTabSelection::kExtendMulti,false, selval);
  1266.                         }
  1267.                     }
  1268.                 Invalidate();
  1269.                 return true;
  1270.                 
  1271.             default: 
  1272.                 return true;
  1273.             }
  1274. }
  1275.  
  1276.  
  1277.  
  1278.  
  1279. void DAlnView::HiliteCommonBases()
  1280. {  
  1281. #if 1
  1282.     char * hFirst = NULL;
  1283.     char * hCommon= fSeqList->FindCommonBases(DSeqList::gMinCommonPercent, hFirst);
  1284.     
  1285.     long nseq= fSeqList->GetSize();
  1286.     if (fMaskLevel>0) 
  1287.     for (long iseq= 0; iseq<nseq; iseq++) {
  1288.         DSequence* aSeq= fSeqList->SeqAt(iseq);
  1289.         long alen= aSeq->LengthF();
  1290.         char * hf = hFirst;
  1291.         char * hc = hCommon;
  1292.         char * bc = aSeq->Bases();
  1293.         aSeq->ClearMask(fMaskLevel);
  1294.         for (long ibase=0; ibase<alen; ibase++, hf++, hc++, bc++) 
  1295.             if (iseq >= (unsigned char) *hf && toupper(*bc) == *hc)
  1296.                 aSeq->SetMaskAt( ibase, fMaskLevel);
  1297.         }
  1298.     this->Invalidate();
  1299.     MemFree(hCommon);
  1300.     MemFree(hFirst);
  1301. #endif
  1302. }
  1303.  
  1304.  
  1305. #define DRAWCLASS 1
  1306. #ifndef DRAWCLASS
  1307.  
  1308. void DAlnView::DrawAlnInStyle( baseColors colors, Boolean swapBackColor,
  1309.                                                             char*    pText, long indx, long len, long row)
  1310. {
  1311. #if MASKS
  1312.         // ?? do we want this? main use of styles is in PrettyPrint...
  1313.     Nlm_PoinT pt;
  1314.     long            endx, pend, skip;
  1315.     char            ch, lastch;
  1316.     Nlm_RecT    crec; // set this to rect about draw char...
  1317.     short         maskval;
  1318.         
  1319.     Boolean dostyles= (fCurSeq && fCurSeq->MasksOk());
  1320.     if (!dostyles) {
  1321.         DrawAlnColors( colors, swapBackColor, pText, indx, len,row);
  1322.         return;
  1323.         }
  1324.         
  1325.     long cw= GetItemWidth(0);
  1326.     Nlm_GetPen( &pt);
  1327.     if (pt.x < 0) {
  1328.         skip= (-pt.x) / cw;
  1329.       indx += skip;
  1330.         len -= skip;
  1331.         pt.x += skip*cw;
  1332.         Nlm_MoveTo( pt.x, pt.y);
  1333.         }
  1334.     pend= len * cw;
  1335.     
  1336.     if (pend > GetRect().right) {   
  1337.         skip= (pend - GetRect().right) / cw;  
  1338.         len -= skip;
  1339.         }
  1340.     endx= indx + len - 1;
  1341.     
  1342.     lastch= 0;
  1343.     long cht= GetItemHeight(0);
  1344.     for (long i= indx; i<=endx; i++) {
  1345.         ch= pText[i];
  1346.         if (ch >= ' ') {
  1347.             if (ch!=lastch) Nlm_SetColor( colors[ch-' ']);
  1348.             Nlm_PaintChar(ch);
  1349.             lastch= ch;
  1350.             if (fMaskLevel>0) {
  1351.                 maskval= fCurSeq->MaskAt(i, fMaskLevel);
  1352.                 if (maskval>0) {
  1353.                     Nlm_LoadRect( &crec, pt.x, pt.y-cht+2, pt.x+cw, pt.y+2); //??
  1354.                     //Nlm_FrameRect( &crec); //?? doesn't show on XMotif?
  1355.                     DTableView::InvertRect( crec); 
  1356.                     }
  1357.                 }
  1358.             pt.x += cw;
  1359.             // !? must reset some of drawing environ !? > Font !
  1360.             }
  1361.         }
  1362.     Nlm_Black();
  1363.     
  1364. #else
  1365.     DrawAlnColors( colors, swapBackColor, pText, indx, len, row);
  1366. #endif
  1367. }
  1368.  
  1369.  
  1370. void DAlnView::DrawAlnColors(baseColors colors, Boolean swapBackColor,
  1371.                                                             char*    pText, long indx, long len, long row)
  1372. {
  1373.     Nlm_PoinT pt;
  1374.     long            endx, pend, skip;
  1375.     char            ch, lastch;
  1376.     
  1377.     long cw= GetItemWidth(0); 
  1378.     Nlm_GetPen( &pt);
  1379.     if (pt.x < 0) {
  1380.         skip= (-pt.x) / cw;
  1381.       indx += skip;
  1382.         len -= skip;
  1383.         Nlm_MoveTo( pt.x + skip*cw, pt.y);
  1384.         }
  1385.     pend= len * cw;
  1386.     
  1387.     if (pend > GetRect().right) {   
  1388.         skip= (pend - GetRect().right) / cw;  
  1389.         len -= skip;
  1390.         }
  1391.     endx= indx + len - 1;
  1392.     
  1393.     //-- backcolor not showing -- need erase or something...
  1394.     //if (swapBackcolor) RGBForeColor( colors[' '-' ']); else RGBBackColor( colors[' '-' ']);
  1395.      
  1396.     //Nlm_CopyMode(); //?? assume?
  1397.     lastch= 0;
  1398.     for (long i= indx; i<=endx; i++) {
  1399.         ch= pText[i];
  1400.         if (ch >= ' ') {
  1401.             // if (swapBackcolor) RGBBackColor( colors[ch-' ']); else 
  1402.             if (ch!=lastch) Nlm_SetColor( colors[ch-' ']);
  1403.             Nlm_PaintChar(ch);
  1404.             lastch= ch;
  1405.             }
  1406.         }
  1407.     Nlm_Black();
  1408. } 
  1409.  
  1410. #else
  1411. ///////////////////////////
  1412.  
  1413.  
  1414. void DAlnView::DrawAlnColors(baseColors colors, Boolean swapBackColor,
  1415.                                                             char*    pText, long indx, long len, long row)
  1416. {
  1417. }
  1418.  
  1419. void DAlnView::DrawAlnInStyle( baseColors colors, Boolean swapBackColor,
  1420.                                                             char*    pText, long indx, long len, long row)
  1421. {
  1422. }
  1423.  
  1424. class DrawBases
  1425. {
  1426. public:
  1427.     Nlm_PoinT pt;
  1428.     long        endx, pend, indx, len, cw, cht;
  1429.     long        row, ytop, ybot;
  1430.     char        ch, lastch, *pText;
  1431.     DAlnView* tview;
  1432.     Boolean  swapBackcolor;
  1433.     //baseColors&    colors;
  1434.     
  1435.     DrawBases() {}
  1436.     virtual void doDraw(DAlnView* theView, baseColors theColors, Boolean backcolor,
  1437.                char*    theText, long theIndx, long theLen, long theRow);
  1438.     virtual void Calc();
  1439.     virtual void DrawSub(baseColors colors);
  1440.     virtual void InvertSel();
  1441. };
  1442.  
  1443. class DrawGreyBases : public DrawBases
  1444. {
  1445. public:    
  1446.     DrawGreyBases() {}
  1447.     virtual void DrawSub(baseColors colors);
  1448. };
  1449.  
  1450. class DrawBasesWithMask : public DrawBases
  1451. {
  1452. public:
  1453.     Boolean fIsGrey;
  1454.  
  1455.     DrawBasesWithMask() : fIsGrey(false) {}
  1456.     virtual void doDraw(DAlnView* theView, baseColors theColors, Boolean backcolor,
  1457.                char*    theText, long theIndx, long theLen, long theRow);
  1458.     virtual void DrawWithMasks(baseColors colors);
  1459.     virtual void DrawSub(baseColors colors);
  1460. };
  1461.  
  1462.  
  1463. class DrawGreyBasesWithMask : public DrawBasesWithMask
  1464. {
  1465. public:
  1466.     DrawGreyBasesWithMask() { fIsGrey = true; }
  1467. };
  1468.  
  1469.  
  1470.  
  1471. void DrawBases::doDraw(DAlnView* theView, baseColors theColors, Boolean backcolor,
  1472.            char*    theText, long theIndx, long theLen, long theRow)
  1473. {
  1474.     tview= theView;
  1475.     //colors= theColors;
  1476.     pText= theText;
  1477.     indx= theIndx;
  1478.     len= theLen;
  1479.     row= theRow;
  1480.     lastch= 0;
  1481.     swapBackcolor= backcolor;
  1482.     if (swapBackcolor) Nlm_CopyMode();
  1483.     
  1484.     Calc();
  1485.     DrawSub(theColors);
  1486.     InvertSel();
  1487.     if (swapBackcolor) Nlm_MergeMode();
  1488. }
  1489.  
  1490. void DrawBases::Calc() 
  1491. {
  1492.     long skip;
  1493.     cht= tview->GetItemHeight(0);
  1494.     cw = tview->GetItemWidth(0); 
  1495.     Nlm_GetPen( &pt);
  1496.     ytop= pt.y-cht+2;
  1497.     ybot= pt.y+2;  
  1498.     if (pt.x < 0) {
  1499.         skip= (-pt.x) / cw;
  1500.       indx+= skip;
  1501.         len -= skip;
  1502.         Nlm_MoveTo( pt.x + skip*cw, pt.y);
  1503.         }
  1504.     pend= len * cw;
  1505.     
  1506.     if (pend > tview->GetRect().right) {   
  1507.         skip= (pend - tview->GetRect().right) / cw;  
  1508.         len -= skip;
  1509.         }
  1510.     endx= indx + len - 1;
  1511. }
  1512.  
  1513.  
  1514. void DrawBases::InvertSel()
  1515. {         
  1516.     Nlm_RecT crec;
  1517.     long atx= pt.x;
  1518.     
  1519.     for (long i= indx; i<=endx; i++) {
  1520.       if (tview->fSelection->IsSelected(row, i)) {
  1521.             Nlm_LoadRect( &crec, atx, ytop, atx+cw, ybot); 
  1522.             tview->DTableView::InvertRect( crec);
  1523.             }
  1524.         atx += cw;
  1525.         }
  1526. }
  1527.  
  1528. void DrawBases::DrawSub(baseColors colors)
  1529. {
  1530.     for (long i= indx; i<=endx; i++) {
  1531.         ch= pText[i];
  1532.         if (ch >= ' ') {
  1533.             if (ch!=lastch)  {
  1534. #ifdef BACKCOLOR
  1535.                 if (swapBackcolor) Nlm_SetBackColor( colors[ch-' ']);  else 
  1536. #endif
  1537.                 Nlm_SetColor( colors[ch-' ']);
  1538.                 }
  1539.             Nlm_PaintChar(ch);
  1540.             lastch= ch;
  1541.             }
  1542.         }
  1543.     Nlm_Black();
  1544. }
  1545.  
  1546. void DrawBasesWithMask::DrawSub(baseColors colors)
  1547. {
  1548.     for (long i= indx; i<=endx; i++) {
  1549.         ch= pText[i];
  1550.         if (ch >= ' ') {
  1551.             if (fIsGrey) {
  1552. #ifdef BACKCOLOR
  1553.                 if (swapBackcolor) Nlm_SetBackColor( tview->fColcolors[i-indx]);  else 
  1554. #endif
  1555.                 Nlm_SetColor( tview->fColcolors[i-indx]);
  1556.                 }
  1557.             else if (ch!=lastch) {
  1558. #ifdef BACKCOLOR
  1559.                 if (swapBackcolor) Nlm_SetBackColor( colors[ch-' ']);  else 
  1560. #endif
  1561.                 Nlm_SetColor( colors[ch-' ']);
  1562.                 }
  1563.             Nlm_PaintChar(ch);
  1564.             lastch= ch;
  1565.             }
  1566.         }
  1567.     Nlm_Black();
  1568. }
  1569.  
  1570. void DrawGreyBases::DrawSub(baseColors colors)
  1571. {         
  1572.     for (long i= indx; i<=endx; i++) {
  1573.         ch= pText[i];
  1574.         if (ch >= ' ') {
  1575.                 // could draw by columns & setcolor once/col for speed !
  1576. #ifdef BACKCOLOR
  1577.             if (swapBackcolor) Nlm_SetBackColor( tview->fColcolors[i-indx]);  else 
  1578. #endif
  1579.             Nlm_SetColor( tview->fColcolors[i-indx]);
  1580.             Nlm_PaintChar(ch);
  1581.             }
  1582.         }
  1583.     Nlm_Black();
  1584. }
  1585.  
  1586.  
  1587.  
  1588. void DrawBasesWithMask::doDraw(DAlnView* theView, baseColors theColors, Boolean backcolor,
  1589.            char*    theText, long theIndx, long theLen, long theRow)
  1590. {
  1591.     tview= theView;
  1592.     //colors= &theColors;
  1593.     pText= theText;
  1594.     indx= theIndx;
  1595.     len= theLen;
  1596.     row= theRow;
  1597.     lastch= 0;
  1598.     swapBackcolor= backcolor;
  1599.     if (swapBackcolor) Nlm_CopyMode();
  1600.     
  1601.     Calc();
  1602.     Boolean dostyles= (tview->fCurSeq && tview->fCurSeq->MasksOk());
  1603.     if (!dostyles) {
  1604.         DrawSub(theColors);
  1605.         InvertSel();
  1606.         }
  1607.     else 
  1608.         DrawWithMasks(theColors);
  1609.     if (swapBackcolor) Nlm_MergeMode();
  1610. }
  1611.  
  1612. void DrawBasesWithMask::DrawWithMasks(baseColors colors)
  1613. {
  1614.     Nlm_RecT    crec;  
  1615.     
  1616.     for (long i= indx; i<=endx; i++) {
  1617.         Boolean notInverted= true;
  1618.         ch= pText[i];
  1619.         if (ch >= ' ') {
  1620.             if (fIsGrey) {
  1621. #ifdef BACKCOLOR
  1622.                 if (swapBackcolor) Nlm_SetBackColor( tview->fColcolors[i-indx]);  else 
  1623. #endif
  1624.                 Nlm_SetColor( tview->fColcolors[i-indx]);
  1625.                 }
  1626.             else if (ch!=lastch) {
  1627. #ifdef BACKCOLOR
  1628.                 if (swapBackcolor) Nlm_SetBackColor( colors[ch-' ']);  else 
  1629. #endif
  1630.                 Nlm_SetColor( colors[ch-' ']);
  1631.                 }
  1632.             Nlm_PaintChar(ch);
  1633.             lastch= ch;
  1634.             if (tview->fMaskLevel>0) {
  1635.                 notInverted= false;
  1636.                 short maskval= tview->fCurSeq->MaskAt(i, tview->fMaskLevel);
  1637.                 if (maskval>0) {
  1638.                     Nlm_LoadRect( &crec, pt.x, ytop, pt.x+cw, ybot); //??
  1639.                     //Nlm_FrameRect( &crec); //?? doesn't show on XMotif?
  1640.                     tview->DTableView::InvertRect( crec); 
  1641.                     }
  1642.                 }
  1643.             if (notInverted) {
  1644.               if (tview->fSelection->IsSelected(row, i)) {
  1645.                     Nlm_LoadRect( &crec, pt.x, ytop, pt.x+cw, ybot); //??
  1646.                     tview->DTableView::InvertRect( crec);
  1647.                     }
  1648.                 }
  1649.             pt.x += cw;
  1650.             // !? must reset some of drawing environ !? > Font !
  1651.             }
  1652.         }
  1653.     Nlm_Black();
  1654. }
  1655.  
  1656.     
  1657.     
  1658. DrawBases         gDrawBases;
  1659. DrawBasesWithMask gDrawBasesWithMask;
  1660. //DrawGreyBases            gDrawGreyBases;
  1661. DrawGreyBasesWithMask    gDrawGreyBases;
  1662. #endif
  1663.  
  1664.  
  1665. void DAlnView::DrawAllColors(Nlm_RecT r, long row)
  1666. { 
  1667. #ifdef DRAWCLASS
  1668. #define DRAWALN(a,b,c,d,e,f)    gDrawBasesWithMask.doDraw(this,a,b,c,d,e,f)
  1669. #else
  1670. #if MASKS
  1671. #define DRAWALN    DrawAlnInStyle
  1672. #else
  1673. #define DRAWALN    DrawAlnColors
  1674. #endif
  1675. #endif
  1676.  
  1677.     long stopcol, startcol = GetLeft(); 
  1678.     long newright= r.left;
  1679.  
  1680.     for (stopcol= startcol; stopcol<GetMaxCols() && newright<r.right; stopcol++) {
  1681.         //if (fWidths) newright += fWidths[startcol]; else 
  1682.         newright += GetItemWidth(0);
  1683.         // optimize later -- check update region by each char rect ...
  1684.         //if (Nlm_RectInRgn (&item_rect, Nlm_updateRgn)) done= true;
  1685.         }
  1686.  
  1687.     DSequence* aSeq= fSeqList->SeqAt(row);
  1688.     if (aSeq && aSeq->Bases()) {
  1689.         char* hSeq= aSeq->Bases();
  1690.         fCurSeq= aSeq;
  1691.         //Boolean dostyles= (fCurSeq && fCurSeq->MasksOk());
  1692.         
  1693.         long len= Min( aSeq->LengthF(), stopcol) - startcol;
  1694.         if (len>0) {
  1695.             Nlm_MoveTo( r.left, r.bottom-2); //bottom-5
  1696.             if (fColorBases == kBaseVarLite && fColcolors) 
  1697.                 gDrawGreyBases.doDraw(this,DBaseColors::gNAcolors, gSwapBackground, hSeq, startcol, len, row);
  1698.             else if (aSeq->Kind() == DSequence::kAmino)
  1699.                 DRAWALN(DBaseColors::gAAcolors, gSwapBackground, hSeq, startcol, len, row);
  1700.             else
  1701.                 DRAWALN(DBaseColors::gNAcolors, gSwapBackground, hSeq, startcol, len, row);
  1702.             }
  1703.         }
  1704.     fColsDrawn= stopcol - startcol;
  1705. }  
  1706.  
  1707.  
  1708. void DAlnView::DrawNoColors(Nlm_RecT r, long row)
  1709. { 
  1710.     Nlm_RecT crec;
  1711.     long atx, aty;
  1712.     long stopcol, startcol = GetLeft(); 
  1713.     long newright= r.left;
  1714.     short    cwidth= GetItemWidth(0); // BaseCharWidth(); //fItemWidth
  1715.     
  1716.     for (stopcol= startcol; stopcol<GetMaxCols() && newright<r.right; stopcol++) {
  1717.         //if (fWidths) newright += fWidths[startcol]; else 
  1718.         newright += cwidth;
  1719.         // optimize later -- check update region by each char rect ...
  1720.         //if (Nlm_RectInRgn (&item_rect, Nlm_updateRgn)) done= true;
  1721.         }
  1722.  
  1723.     DSequence* aSeq= fSeqList->SeqAt(row);
  1724.     if (aSeq && aSeq->Bases()) {
  1725.         char *s, se, *hSeq= aSeq->Bases();
  1726.         long len= Min( aSeq->LengthF(), stopcol) - startcol;
  1727.         if (len>0) {
  1728. #if MASKS
  1729.             if (fMaskLevel>0) {
  1730.                 atx= r.left;
  1731.                 aty= r.bottom-2;
  1732.                 stopcol= startcol + len;
  1733.                 for (long i= startcol; i<stopcol; i++) {
  1734.                     //Boolean notInverted= true;
  1735.                     Nlm_MoveTo(atx, aty);
  1736.                     Nlm_PaintChar(hSeq[i]);
  1737.                     short maskval= aSeq->MaskAt(i, fMaskLevel);
  1738.                     if (maskval>0) {
  1739.                         Nlm_LoadRect( &crec, atx, r.top, atx+cwidth, r.bottom); 
  1740.                         //Nlm_FrameRect( &crec); //<< ? bad for Motif, also messy looking
  1741.                         DTableView::InvertRect( crec); 
  1742.                         //notInverted= false;
  1743.                         }
  1744. #if 0
  1745.     // no -- if fMaskLevel>0, don't do any selection inversion !
  1746.             if (notInverted) {
  1747.               if (this->fSelection->IsSelected(row, i)) {
  1748.                     Nlm_LoadRect( &crec, atx, r.top, atx+cwidth, r.bottom); 
  1749.                     this->DTableView::InvertRect( crec);
  1750.                     }
  1751.                 }
  1752. #endif
  1753.                     atx += cwidth;
  1754.                     }
  1755.                 }
  1756.             else 
  1757. #endif
  1758.                 {
  1759.                 Nlm_MoveTo( r.left, r.bottom-2); //bottom-5
  1760.                 s= hSeq+startcol;
  1761.                 se= s[len];
  1762.                 s[len]= 0;
  1763.                 Nlm_PaintString( s); 
  1764.                 s[len]= se;
  1765.                 //Nlm_DrawText( &r, hSeq+startcol, len, 'l', false); // gray== false
  1766. #if 1
  1767.                 atx= r.left;
  1768.                 for (long i= startcol; i<stopcol; i++) {
  1769.                   if (this->fSelection->IsSelected(row, i)) {
  1770.                         Nlm_LoadRect( &crec, atx, r.top, atx+cwidth, r.bottom); 
  1771.                         this->DTableView::InvertRect( crec);
  1772.                         }
  1773.                     atx += cwidth;
  1774.                     }
  1775. #endif
  1776.                 }
  1777.         }
  1778.         }
  1779.     fColsDrawn= stopcol - startcol;
  1780. }  
  1781.  
  1782.         
  1783. void DAlnView::Draw()
  1784. {
  1785.  
  1786.     if (fColorBases == kBaseVarLite) {
  1787.         // find grey color mask for base columns in view 
  1788.         Nlm_RecT r = fRect;
  1789.         long    row = 0; 
  1790.         long     ncols, icol, stopcol, startcol = GetLeft(); 
  1791.         long     newright= r.left;
  1792.         long    basecount['~'];
  1793.         char    maxc, ac;
  1794.         
  1795.         for (stopcol= startcol; stopcol < GetMaxCols() && newright<r.right; stopcol++) {
  1796.             newright += GetItemWidth(0);
  1797.             }
  1798.         ncols= stopcol - startcol + 1;
  1799.         
  1800.         if (ncols != fNcolcolors || !fColcolors) {
  1801.             MemFree( fColcolors);
  1802.             fColcolors= (unsigned long*) MemNew(ncols * sizeof(unsigned long));
  1803.             }
  1804.         fNcolcolors= ncols;
  1805.         
  1806.         for (icol= startcol; icol<stopcol; icol++) {
  1807.             long maxcount, nbases= 0;
  1808.             for (ac=0; ac<'~'; ac++) basecount[ac]= 0;
  1809.             for (row= 0; row < GetMaxRows(); row++) {
  1810.                 DSequence* aSeq= fSeqList->SeqAt(row);
  1811.                 if (aSeq && aSeq->Bases() && aSeq->LengthF()>icol) {
  1812.                   char ch= aSeq->Bases()[icol];
  1813.                   if (ch == DSequence::indelHard
  1814.                    || ch == DSequence::indelSoft
  1815.                    || ch == DSequence::indelEdge)
  1816.                        ;
  1817.                     else { 
  1818.                         ch |= 32;    // use case-insensitive ?
  1819.                         // ?? or use DSequence::NucleicBits(ch) ??
  1820.                         basecount[ch]++;
  1821.                     nbases++;
  1822.                     }
  1823.                     }
  1824.                 }
  1825.             for (maxcount=0, ac=0; ac<'~'; ac++) 
  1826.              if (basecount[ac] > maxcount) {
  1827.                 maxcount= basecount[ac];
  1828.                 maxc= ac;
  1829.                 }
  1830.                      
  1831.             enum { kMaxGrey = 127 }; // 255 is max color level
  1832.             unsigned long greycolor = 0;
  1833.             unsigned short level;
  1834.             float flevel= float(maxcount) / float(nbases);
  1835.             level= kMaxGrey - (kMaxGrey * flevel);
  1836.             level= 0xff & (level << 1);
  1837.  
  1838. #ifdef WIN_MAC
  1839.             greycolor= (((ulong)level)<<16) | (level<<8) | level;
  1840. #endif
  1841. #ifdef WIN_MSWIN
  1842.           greycolor = (level | level << 8 | ((ulong)level) << 16); //== RGB (cr, cg, cb);
  1843. #endif
  1844. #ifdef WIN_MOTIF
  1845.             // X uses mapped values thru setcolor -- need to do the select/get dance
  1846.             Nlm_SelectColor( level, level, level);
  1847.             greycolor= Nlm_GetColor();
  1848. #endif
  1849.             fColcolors[icol-startcol]= greycolor;
  1850.          
  1851.             }
  1852.         
  1853.         }
  1854.  
  1855.     DTableView::Draw();
  1856. }
  1857.  
  1858.  
  1859. void DAlnView::DrawRow(Nlm_RecT r, long row)
  1860. {
  1861.      // DTableView::Draw() does SelectFont(fFont)
  1862.   if (fEditRow == row) {
  1863.          // do nothing? , fEditSeq handle's redraw ??
  1864.         fColsDrawn= 0;
  1865.          }
  1866.      else switch (fColorBases) {
  1867.          case kBaseVarLite:
  1868.          case kBaseColor: 
  1869.              DrawAllColors(r, row); 
  1870.              break;
  1871.          case kBaseBlack: 
  1872.          default: 
  1873.              DrawNoColors(r, row); 
  1874.              break;
  1875.          }
  1876. }
  1877.  
  1878.         
  1879. void DAlnIndex::DrawCell(Nlm_RecT r, long row, long col)
  1880. {
  1881.     // add cols for Kind(), Length(), Origin(), UpdateTime(), Info()(wide col..better in box)
  1882.     char *cp, buf[128];
  1883.     buf[0]= 0;
  1884.     r.right -= 2; // inset
  1885.     
  1886.     DSequence* aSeq= fSeqList->SeqAt(row);
  1887.     if (aSeq) {
  1888. #ifdef TESTVARHEIGHT
  1889.          if (aSeq->ShowORF()) r.bottom -= kORFxtraHeight;
  1890. #endif         
  1891.         // from 0 .. kAlnIndexCols-1
  1892.         switch (col) {
  1893.         case kAlnIndexName: 
  1894.             if (aSeq->Changed())  Nlm_SelectFont(gUlineTextFont); //gBoldTextFont  
  1895.             cp= aSeq->Name();
  1896.             Nlm_DrawString( &r, cp, 'r', false);
  1897.             if (aSeq->Changed()) {     Nlm_SelectFont(fFont); }
  1898.             break;
  1899.         case kAlnIndexSize:
  1900.             sprintf(buf,"%d", aSeq->LengthF()); 
  1901.             Nlm_DrawString( &r, buf, 'r', false);
  1902.             break;
  1903.         case kAlnIndexKind:
  1904.             cp= aSeq->KindStr();
  1905.             Nlm_DrawString( &r, cp, 'r', false);
  1906.             break;
  1907.         case kAlnIndexRow:
  1908.             sprintf(buf,"%d", row+1);
  1909.             Nlm_DrawString( &r, buf, 'r', false);
  1910.             break;
  1911.         case kAlnIndexShowORF:
  1912. #if 0
  1913.             Nlm_MoveTo( r.left+1, r.bottom);
  1914.             if (aSeq->ShowORF()) Nlm_Medium();
  1915.             Nlm_PaintString( "Show");  
  1916.             Nlm_Solid();
  1917.             Nlm_PaintString( "/");  
  1918.             if (!aSeq->ShowORF()) Nlm_Medium();
  1919.             Nlm_PaintString( "Hide");  
  1920.             Nlm_Solid();
  1921.             Nlm_PaintString( " ORF");  
  1922. #else
  1923.             if (aSeq->ShowORF()) cp= "Hide ORF";
  1924.             else cp= "Show ORF";
  1925.             Nlm_DrawString( &r, cp, 'c', false); //true == grey
  1926. #endif
  1927.             break;
  1928.         case kAlnIndexChecksum:
  1929.             sprintf(buf,"%8lx", aSeq->Checksum());
  1930.             Nlm_DrawString( &r, buf, 'r', false);
  1931.             break;
  1932.             
  1933.             }
  1934.             
  1935. #ifdef notnow_TESTVARHEIGHT
  1936.         if (aSeq->ShowORF()) {
  1937.             r.top += kORFxtraHeight;
  1938.             r.bottom += kORFxtraHeight;
  1939.             Nlm_DrawString( &r, "orf", 'r', false);
  1940.             }
  1941. #endif         
  1942.         }
  1943. }
  1944.  
  1945.  
  1946. void DAlnITitle::DrawCell(Nlm_RecT r, long row, long col)
  1947. {
  1948.     r.right -= 2; // inset
  1949.     switch (col) {
  1950.         case kAlnIndexName: 
  1951.             Nlm_DrawString( &r, "Name", 'r', false);
  1952.             break;
  1953.         case kAlnIndexSize:
  1954.             Nlm_DrawString( &r, "Bases", 'r', false);
  1955.             break;
  1956.         case kAlnIndexKind:
  1957.             Nlm_DrawString( &r, "Kind", 'r', false);
  1958.             break;
  1959.         case kAlnIndexRow:
  1960.             Nlm_DrawString( &r, "Row", 'r', false);
  1961.             break;
  1962.         case kAlnIndexShowORF:
  1963.             Nlm_DrawString( &r, "ORF view", 'r', false);
  1964.             break;
  1965.         case kAlnIndexChecksum:
  1966.             Nlm_DrawString( &r, "Checksum", 'r', false);
  1967.             break;
  1968.         }
  1969. }
  1970.  
  1971. void DAlnHIndex::Draw()
  1972. {
  1973.     Nlm_RecT r;
  1974.     long atx, aty;
  1975.     char nums[128];
  1976.  
  1977.     fDoc->fAlnView->SelectFont();  
  1978.     ViewRect( r);
  1979.     long stopcol, startcol = fDoc->fAlnView->GetLeft(); 
  1980.     long newright= r.left;
  1981.     short    cwidth= gAlnCharWidth; //BaseCharWidth(); // fDoc->fAlnView->GetItemWidth(0);
  1982.  
  1983. #if 0    
  1984.     Nlm_RecT vr;
  1985.     // is ViewRect bad !? (too short)  YES - isn't grown !?
  1986.   fDoc->fAlnView->ViewRect( vr);
  1987.   r.right= vr.right; //??
  1988.     Nlm_ClipRect( &r); // ?? why is hindex clipped to small !?
  1989. #endif
  1990.     
  1991.     for (stopcol= startcol; 
  1992.         stopcol < fDoc->fAlnView->GetMaxCols() && newright<r.right;
  1993.       stopcol++) {
  1994.         newright += cwidth;
  1995.         }
  1996.  
  1997.     long len= stopcol - startcol;
  1998.     atx= r.left-(cwidth/2);
  1999.     aty= r.bottom;
  2000.     for (long i= startcol; i<=stopcol; i++) {
  2001.         if (i == 0) ; //skip
  2002.         else if (i % 10 == 0) {
  2003.             Nlm_MoveTo(atx, aty);
  2004.             Nlm_LineTo(atx, aty-2);
  2005.             Nlm_MoveTo(atx+1, aty);
  2006.             Nlm_LineTo(atx+1, aty-2);
  2007.             sprintf( nums, "%d", i);
  2008.             long ws= Nlm_StringWidth(nums);
  2009.             Nlm_MoveTo( atx-(ws/ 2), aty-3);
  2010.             Nlm_PaintString(nums);
  2011.             //Nlm_DrawString( &r1, nums, 'c', false);
  2012.             }    
  2013.         else if (i % 5 == 0) {
  2014.             Nlm_MoveTo(atx, aty);
  2015.             Nlm_LineTo(atx, aty-6);
  2016.             }
  2017.         else {
  2018.             Nlm_MoveTo(atx, aty);
  2019.             Nlm_LineTo(atx, aty-2);
  2020.             }
  2021.         atx += cwidth;
  2022.         }
  2023. }
  2024.  
  2025.  
  2026.  
  2027.  
  2028.         
  2029.  
  2030. #if FIX_LATER
  2031. Boolean DAlnView::ContainsClipType(long aType) // override 
  2032. {
  2033.     return (aType == kAlnScrapType);
  2034.     //!? also (aType == 'TEXT') can be pasted as seq... w/ SeqReadScrap...
  2035. }
  2036. #endif
  2037.  
  2038. #if FIX_LATER
  2039. void DAlnView::WriteToDeskScrap() // override 
  2040. {
  2041.     short format = kGenBank;
  2042.     //if (fDoc->fFormatPop) format= fDoc->fFormatPop->GetValue(); 
  2043.     fSeqList->ClearSelections();
  2044.     char* textScrap= fSeqList->doWriteHandle( format);  
  2045.     short err = gClipboardMgr->PutDeskScrapData('TEXT', textScrap);
  2046.     MemFree( textScrap);
  2047. }
  2048. #endif
  2049.  
  2050.  
  2051.  
  2052.  
  2053.  
  2054. char* DAlnIndex::GetItemTitle(short item, char* title, size_t maxsize)   
  2055. {
  2056.   if (fSeqList && item <= fSeqList->GetSize()) {
  2057.         DSequence* aSeq= fSeqList->SeqAt(item);
  2058.         if (aSeq) {
  2059.             if (!title) title= (char*) MemNew( maxsize);
  2060.             StrNCpy( title, aSeq->Name(), maxsize);
  2061.             return title;
  2062.             }
  2063.         }
  2064.     return NULL;
  2065. }
  2066.  
  2067.  
  2068.  
  2069.