home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Source Code / Libraries / DCLAP 4j / DBio / DSeqDoc.cpp < prev    next >
Encoding:
Text File  |  1995-12-17  |  68.7 KB  |  2,813 lines  |  [TEXT/R*ch]
  1. // DSeqDoc.cp
  2.  
  3. #define MASKS 1
  4.  
  5. #include "DSeqDoc.h"
  6. #include <ncbi.h>
  7. #include <dgg.h>
  8. #include <Dvibrant.h>
  9. #include <DApplication.h>
  10. #include <DClipboard.h>
  11. #include <DControl.h>
  12. #include <DWindow.h>
  13. #include <DRichViewNu.h>
  14. #include <DTableView.h>
  15. #include <DViewCentral.h>
  16. #include <DTask.h>
  17. #include <DTracker.h>
  18. #include <DMenu.h>
  19. #include <DUtil.h>
  20. #include <DFindDlog.h>
  21. #include "DSeqFile.h"
  22. #include "DSeqEd.h"
  23. #include "DSeqMail.h"
  24. #include "DSeqCmds.h"
  25. #include "DSeqChildApp.h"
  26. #include "DSeqPrint.h"
  27. #include "DSeqPict.h"
  28.  
  29.  
  30.  
  31.  
  32.  
  33.  
  34. Global char* gDefSeqName = NULL;
  35. static char gDefSeqNameStore[128];
  36. Boolean  DSeqDoc::fgTestSeqFile = false; // turn on/off seq-test for OpenDocument()
  37. Boolean  DSeqDoc::fgStartDoc = true;
  38. Boolean  DSeqDoc::fgUseColor = false;  
  39. Boolean  DSeqDoc::fgLockText = false;  
  40. short         DSeqDoc::fgViewMode = DAlnView::kModeSlide;
  41. Nlm_RecT DSeqDoc::fgWinRect = { 0, 0, 0, 0 };
  42.  
  43. Local short gAlnCharWidth = 12;
  44. Local short gAlnCharHeight = 15;
  45. //Local short gMinCommonPercent = 0;
  46. Local Boolean gSwapBackground = false;
  47.  
  48.  
  49. #define ETEXT 1
  50.  
  51. #define DAlnTextClass  DTextLine
  52. //  Nlm_TextLine > DTextLine -- new variant of DHiddenText
  53. //  DEditText or DHiddenText ?? -- EditText has box around, HiddenText no box
  54. //    DDialogScrollText( id, itsSuperior, width, height, gSeqFont, false) // true==wrap
  55. //    DTextInScroller(long id, DView* itsSuperior, short width, short height, 
  56. //        Nlm_FonT font, Boolean wrap);
  57.  
  58. extern "C" void Nlm_HScrollText (Nlm_BaR sb, Nlm_GraphiC t,
  59.                                Nlm_Int2 newval, Nlm_Int2 oldval);
  60. extern "C" void Nlm_DoActivate(void* g, Nlm_Boolean saveport);
  61. //extern Nlm_Boolean   gDialogTextMultiline;
  62.  
  63.         //fEditSeq
  64. class DAlnSequence : public DAlnTextClass, public DKeyCallback
  65. {
  66. public:
  67.     DSequence* fSeq;
  68.     Boolean  fVisible;
  69.     
  70.     DAlnSequence(long id, DView* itsSuperior):
  71.         DAlnTextClass(id, itsSuperior, NULL, 1, gSeqFont), // DHiddenText
  72.         //DAlnTextClass(id, itsSuperior, 1, 1, gSeqFont, false), // DDialogScrollText
  73.         fSeq(NULL),fVisible(false)
  74.         {
  75.             SetMultilineText(false);
  76.         }
  77.   virtual void Scroll(Boolean vertical, DView* scrollee, short newval, short oldval);        
  78.     virtual void ShowEdit();
  79.     virtual void HideEdit();
  80.   virtual void ProcessKey( char c);
  81.     virtual void selectAction();
  82.     virtual void deselectAction();
  83. };
  84.  
  85. void DAlnSequence::Scroll(Boolean vertical, DView* scrollee, short newval, short oldval) 
  86. {
  87.     if (fVisible && !vertical) { 
  88.         Nlm_HScrollText( NULL, (Nlm_GraphiC)GetNlmObject(), newval, oldval);
  89.         }
  90. }
  91.  
  92. void DAlnSequence::ShowEdit()
  93. {
  94.     if (fSeq) SetText( fSeq->Bases());
  95.     if (!fVisible) {
  96.         fVisible= true;
  97.         Show(); 
  98.         Enable();
  99.         }
  100.         // may need this for MSWIN
  101.     //Nlm_DoActivate(GetNlmObject(),false); 
  102. }
  103.  
  104. void DAlnSequence::HideEdit()
  105. {
  106.     if (fVisible) {
  107.         fVisible= false;
  108.         Disable();
  109.         Hide();
  110.         }
  111. }
  112.  
  113. void DAlnSequence::selectAction()
  114. {
  115.     DAlnTextClass::selectAction();
  116.     //gCursor->ibeam();
  117.     SetKeyHandler(this); //?? also need this call in a window activate/deactivate method??
  118. }
  119.  
  120. void DAlnSequence::deselectAction()
  121. {
  122.     SetKeyHandler(NULL); //?? also need this call in a window activate/deactivate method??
  123.     //fDoc->SetEditText(NULL);
  124.     //gCursor->arrow();
  125.     DAlnTextClass::deselectAction();
  126. }
  127.  
  128. void DAlnSequence::ProcessKey( char c)
  129. {
  130.     enum moves {
  131.         down1 =  1,
  132.         up1        = -1,
  133.         downPage= 10,  // this is arbitrary...
  134.         upPage  = -10,
  135.         toBottom=  25000,
  136.         toTop        = -25000
  137.         };
  138.         
  139.     if ( IsEnabled()) { 
  140.         // dang vibrant doens't have means to change this key, and default handlers still get
  141.         // a crack at it...
  142.  
  143.         switch (c) {
  144.         
  145. #if 0
  146.             case chTab: 
  147.               //? do horizontal shift here ?
  148.                 break;
  149.  
  150.             case chRight:
  151.                 if (gKeys->shift()) ;
  152.                 else ;
  153.             case chLeft:
  154.                 if (gKeys->shift()) ;
  155.                 else ;
  156.                 
  157.             case chUp:
  158.                 if (gKeys->shift()) vertMove(toTop);
  159.                 else vertMove(up1);
  160.                 break;
  161.                 
  162.             case chDown:
  163.             case chEnter:
  164.             case chReturn:
  165.                 if (gKeys->shift())  vertMove(toBottom);
  166.                 else vertMove(down1);
  167.                 break;
  168.                 
  169.             case chPageDown    :    vertMove( downPage); break;
  170.             case chPageUp        :    vertMove( upPage); break;
  171.             case chHome            : vertMove( toTop); break;
  172.             case chEnd             : vertMove( toBottom); break;    
  173. #endif
  174.         
  175.             default: 
  176.                 if (!fSeq->GoodChar(c)) Nlm_Beep(); 
  177.                 break; 
  178.             }
  179.         }
  180. }
  181.  
  182.  
  183.  
  184.  
  185.  
  186. class DMaskSelector : public DTabSelector 
  187. {
  188. public:
  189.     enum { cMaskSelector = 20732 };
  190.     short fMaskLevel;
  191.     DSeqList* fSeqList;
  192.     
  193.     DMaskSelector( DTableView* itsTable, short masklevel, DSeqList* seqlist) : 
  194.         DTabSelector( itsTable),
  195.         fSeqList( seqlist),  fMaskLevel(masklevel) 
  196.         {
  197.         fNumber= cMaskSelector;
  198.         }
  199.     virtual void DoItWork(); 
  200. };
  201.  
  202.  
  203. void DMaskSelector::DoItWork()  
  204. {
  205.     if (fMovedOnce || fDoExtend) {
  206. #if MASKS
  207.             // select masks... instead of, or as well as, table sel rect??
  208.         if (fMaskLevel>0) {
  209.             short row, col, top, bot, left, right;
  210.             Nlm_RecT viewr;
  211.             top= fNewSelection.top;
  212.             bot= fNewSelection.bottom;
  213.             left= fNewSelection.left;
  214.             right= fNewSelection.right;
  215.             for (row= top; row<bot; row++) {
  216.                 DSequence* sq= fSeqList->SeqAt(row);
  217.                 if (sq) {
  218.                     for (col= left; col<right; col++) 
  219.                       if (fDoExtend) sq->SetMaskAt(col,fMaskLevel);
  220.                         else sq->FlipMaskAt(col, fMaskLevel);
  221.                     }                
  222.                 }
  223.             ((DTableView*)fView)->GetCellRect(fNewSelection,viewr);
  224.             ((DTableView*)fView)->InvalRect( viewr);
  225.             }
  226.         else
  227. #endif
  228.         ((DTableView*)fView)->SelectCells( fNewSelection, 
  229.                 fDoExtend, DTableView::kHighlight, DTableView::kSelect);
  230.         }
  231. }
  232.  
  233.  
  234.  
  235.  
  236. //class DAlnView : public DTableView  
  237.  
  238.     // test var for fEditSeq bomb...
  239. DAlnView* gLastEditView = NULL;
  240.  
  241.  
  242. DAlnView::DAlnView( long id, DView* itsSuper, DSeqDoc* itsDocument, DSeqList* itsSeqList, 
  243.                                 long pixwidth, long pixheight) :
  244.     DTableView( id, itsSuper, pixwidth, pixheight, 0, 0, Nlm_stdCharWidth, 2+Nlm_stdFontHeight,
  245.                         true, true),
  246.     fDoc(itsDocument), fSeqList(itsSeqList), fSlider(NULL),
  247.     fEditRow(-1), fMaskLevel(0), fCurSeq(NULL), fEditSeq(NULL),
  248.     fLocked(false), fOwnSeqlist(false)
  249. { 
  250.     fKind= kindAlnView;
  251.     gAlnCharWidth= Nlm_stdCharWidth; //Nlm_CharWidth('G');   
  252.     gAlnCharHeight= Nlm_stdLineHeight;
  253.     this->SetResize( DView::relsuper, DView::relsuper);
  254.     this->SetTableFont(gSeqFont);
  255.     //fSlider= new DAlnSlider( fDoc, this, 0);
  256. }
  257.  
  258.  
  259. DAlnIndex::DAlnIndex( long id, DView* itsSuper, DSeqDoc* itsDocument, DSeqList* itsSeqList,
  260.                  long pixwidth, long pixheight) :
  261.     DTableView( id, itsSuper, pixwidth, pixheight, 0, 4,
  262.             5*Nlm_stdCharWidth, 2+Nlm_stdFontHeight, false, true),
  263.     fNameWidth(15),
  264.     fSizeWidth(8),
  265.     fKindWidth(8),
  266.     fDoc(itsDocument),
  267.     fSeqList(itsSeqList)
  268. { 
  269.     //this->SetSlateBorder(false);
  270.     this->SetResize( DView::fixed, DView::relsuper);
  271.     this->SetTableFont(gTextFont);
  272. }
  273.  
  274. DAlnITitle::DAlnITitle( long id, DView* itsSuper, long pixwidth, long pixheight) :
  275.     DTableView( id, itsSuper, pixwidth, pixheight, 1, 4,
  276.             5*Nlm_stdCharWidth, 2+Nlm_stdFontHeight, false, false),
  277.     fNameWidth(15),
  278.     fSizeWidth(8),
  279.     fKindWidth(8)
  280. { 
  281.     //this->SetSlateBorder(false);
  282.     this->SetResize( DView::fixed, DView::fixed);
  283.     this->SetTableFont(gTextFont);
  284. }
  285.  
  286. DAlnHIndex::DAlnHIndex( long id, DView* itsSuper, DSeqDoc* itsDocument, DSeqList* itsSeqList, long pixwidth, long pixheight) :
  287.     DPanel( id, itsSuper, pixwidth, pixheight, DPanel::simple),
  288.     fDoc(itsDocument),
  289.     fSeqList(itsSeqList)
  290. { 
  291.     //this->SetResize( DView::matchsuper, DView::fixed);
  292.     this->SetResize( DView::relsuper, DView::fixed);
  293. }
  294.  
  295. DAlnView::~DAlnView()
  296. {
  297.     //fSeqList= NULL; // fSeqList is owned by Doc !
  298.     DeInstallEditSeq();
  299.     //if (fSlider) delete fSlider;
  300. #if FIX_LATER
  301.     itsEditSeq= fEditSeq;     
  302.     if (itsEditSeq && itsEditSeq->fSuperior)
  303.         itsEditSeq->fSuperior->RemoveSubView(itsEditSeq);
  304.     delete itsEditSeq;
  305. #endif
  306. }
  307.  
  308.  
  309. void DAlnHIndex::Resize(DView* superview, Nlm_PoinT sizechange)
  310. {
  311.     DPanel::Resize(superview, sizechange);
  312. }
  313.  
  314. void DAlnView::Resize(DView* superview, Nlm_PoinT sizechange)
  315. {
  316.     DTableView::Resize(superview, sizechange);
  317. }
  318.  
  319. void DAlnView::GetReadyToShow()
  320. {
  321.     // assume port is set??
  322.     SelectFont();  
  323.     gAlnCharWidth = Nlm_CharWidth('G');   
  324.     gAlnCharHeight= Nlm_LineHeight() + 2; // Nlm_FontHeight()
  325.     SetItemWidth(0, GetMaxCols(), gAlnCharWidth);
  326.     SetItemHeight(0, GetMaxRows(), gAlnCharHeight);
  327.     this->UpdateAllWidths(); 
  328.     this->UpdateSize();  
  329. }
  330.  
  331. void DAlnIndex::GetReadyToShow()
  332. {
  333.     //SelectFont(); //Nlm_SelectFont(fFont);  
  334.     SetItemWidth(0, GetMaxCols(), fViewrect.right-fViewrect.left-1); //<< width of view
  335.     SetItemHeight(0, GetMaxRows(), gAlnCharHeight);
  336. }
  337.  
  338. void DAlnITitle::GetReadyToShow()
  339. {
  340.     // assume port is set??
  341.     SelectFont();
  342.     short charheight=  Nlm_LineHeight(); // Nlm_FontHeight();
  343.     SetItemWidth(0, GetMaxCols(), fViewrect.right-fViewrect.left-1); //<< width of view
  344.     SetItemHeight(0, GetMaxRows(), charheight);
  345. }
  346.  
  347. void DAlnView::Show()
  348. {
  349.     GetReadyToShow();
  350.     DTableView::Show();
  351. }
  352.  
  353. void DAlnIndex::Show()
  354. {
  355.     GetReadyToShow();
  356.     DTableView::Show();
  357. }
  358.  
  359. void DAlnView::Drag(Nlm_PoinT mouse)
  360. {
  361.     DTableView::Drag(mouse); // sets fMouseStillDown= true
  362. }
  363.  
  364. void DAlnIndex::Drag(Nlm_PoinT mouse)
  365. {
  366.     DTableView::Drag(mouse); // sets fMouseStillDown= true
  367. }
  368.  
  369. void DAlnHIndex::Drag(Nlm_PoinT mouse)
  370. {
  371.     DPanel::Drag(mouse);
  372. }
  373.  
  374. void DAlnView::Hold(Nlm_PoinT mouse)
  375. {
  376.     DTableView::Hold(mouse);
  377. }
  378.  
  379. void DAlnIndex::Hold(Nlm_PoinT mouse)
  380. {
  381.     DTableView::Hold(mouse);
  382. }
  383.  
  384. void DAlnHIndex::Hold(Nlm_PoinT mouse)
  385. {
  386.     DPanel::Hold(mouse);
  387. }
  388.  
  389. void DAlnView::Release(Nlm_PoinT mouse)
  390. {
  391.     DTableView::Release(mouse);
  392. }
  393.  
  394. void DAlnIndex::Release(Nlm_PoinT mouse)
  395. {
  396.     DTableView::Release(mouse);
  397. }
  398.  
  399. void DAlnHIndex::Release(Nlm_PoinT mouse)
  400. {
  401.     DPanel::Release(mouse);
  402. }
  403.  
  404.  
  405. void DAlnView::DoubleClickAt(short row, short col)
  406. {
  407. #if 0
  408.     //?? do this only on DAlnIndex dblclik??
  409.     DSequence* ag= fSeqList->SeqAt(row); 
  410.     if (ag) fDoc->OpenSeqedWindow(ag);
  411. #endif
  412. }
  413.  
  414.  
  415. void DAlnIndex::Click(Nlm_PoinT mouse)
  416. {
  417.     short      row, col;
  418.     //if (gLastCommand) { delete gLastCommand; gLastCommand= NULL; } //gLastCommand->Commit();    //??
  419.     
  420.     fDoc->fAlnView->DeInstallEditSeq();
  421.     fDoc->fAlnView->SetEmptySelection(true); 
  422.  
  423.     PointToCell( mouse, row, col);
  424.     if (Nlm_dblClick)
  425.         ;
  426.     else if (IsSelected(row, col)) {   //if (gKeys->shift()) 
  427.         // slide/shift selected lines...
  428.         DAlnShifter* shifter= new DAlnShifter();  
  429.         shifter->IAlnSlider( fDoc, this, fDoc->fAlnView, row);
  430.         fCurrentTracker= shifter;
  431.         }
  432.     else {
  433.         //if (fTabSelector) fTabSelector->suicide();  // is this delete causing bombs? YES, in motif
  434.         fTabSelector= new DTabSelector( this);
  435.         fCurrentTracker= fTabSelector;
  436.      }
  437.     DTableView::Click( mouse);
  438. }
  439.  
  440.  
  441. void DAlnITitle::Click(Nlm_PoinT mouse)
  442. {
  443.         // damn, need this or the like for each user of DTableView::Click ...
  444.     //if (gLastCommand) { delete gLastCommand; gLastCommand= NULL; } //gLastCommand->Commit();    //??
  445.  
  446.     //if (fTabSelector) fTabSelector->suicide();  // is this delete causing bombs? YES, in motif
  447.     fTabSelector= new DTabSelector( this);
  448.     fCurrentTracker= fTabSelector;
  449.  
  450.     DTableView::Click( mouse);
  451. }
  452.  
  453.  
  454.  
  455.  
  456.  
  457. void DAlnView::Click(Nlm_PoinT mouse)
  458. {
  459.     short     row, col;
  460.  
  461.     //if (gLastCommand) { delete gLastCommand; gLastCommand= NULL; } //gLastCommand->Commit();    //??
  462.  
  463.     PointToCell( mouse, row, col);
  464.     if (IsSelected(row, col)) {
  465.         //if (fSlider) delete fSlider;  // is this delete causing bombs?
  466.         fSlider= new DAlnSlider();
  467.         fSlider->IAlnSlider( fDoc, this, this, 0);
  468.         fCurrentTracker= fSlider;
  469.         }
  470.     else {
  471.         //if (fTabSelector) fTabSelector->suicide();  // is this delete causing bombs? YES, in motif
  472. #if MASKS
  473.         if (fMaskLevel>0) 
  474.             fTabSelector= new DMaskSelector( this, fMaskLevel, fSeqList);
  475.         else
  476. #endif
  477.             fTabSelector= new DTabSelector( this);
  478.         fCurrentTracker= fTabSelector;
  479.         }
  480.  
  481.     DTableView::Click( mouse);
  482. }
  483.  
  484.  
  485. void DAlnView::TrackMouse( short aTrackPhase,
  486.                     Nlm_PoinT& anchorPoint, Nlm_PoinT& previousPoint,
  487.                     Nlm_PoinT& nextPoint,    Nlm_Boolean mouseDidMove)
  488. {
  489.     DTableView::TrackMouse( aTrackPhase, anchorPoint, previousPoint, nextPoint,mouseDidMove); 
  490. }
  491.  
  492.  
  493. void DAlnView::TrackFeedback( short aTrackPhase,
  494.                     const Nlm_PoinT& anchorPoint, const Nlm_PoinT& previousPoint,
  495.                     const Nlm_PoinT& nextPoint, Nlm_Boolean mouseDidMove, Nlm_Boolean turnItOn)
  496. {
  497.     DTableView::TrackFeedback( aTrackPhase, anchorPoint, previousPoint, nextPoint,
  498.                     mouseDidMove, turnItOn);
  499. }
  500.  
  501.  
  502. void DAlnIndex::DoubleClickAt(short row, short col)
  503. {
  504.     DSequence* ag= fSeqList->SeqAt(row); 
  505.     if (ag) fDoc->OpenSeqedWindow(ag);
  506. }
  507.  
  508. void DAlnITitle::DoubleClickAt(short row, short col)
  509. {
  510. }
  511.  
  512.  
  513.  
  514. void DAlnView::SingleClickAt(short row, short col)
  515. {
  516. #if ETEXT
  517.     if (!(fLocked || gKeys->shift() || gKeys->command() || gKeys->option() )) {  
  518.         SetEmptySelection( true); 
  519.         if (fDoc->fAlnIndex) fDoc->fAlnIndex->SetEmptySelection( true); 
  520.         InstallEditSeq(row,col,col,false);
  521.         }
  522.     else
  523. #endif
  524. #if MASKS
  525.     if (fMaskLevel>0) {
  526.         Nlm_RecT r;
  527.         DSequence* ag= fSeqList->SeqAt(row); 
  528.         if (ag) {
  529.             if (gKeys->shift()) ag->SetMaskAt(col,fMaskLevel);
  530.             else ag->FlipMaskAt(col,fMaskLevel);
  531.             }
  532.         GetCellRect( row, col, r);
  533.         InvalRect( r);
  534.         }
  535.     else
  536. #endif
  537.          DTableView::SingleClickAt(row,  col);
  538.      //fDoc->SetViewMenu();
  539. }
  540.  
  541. void DAlnIndex::SingleClickAt(short row, short col)
  542. {
  543.      DTableView::SingleClickAt(row,  col);
  544.      //fDoc->SetViewMenu();
  545. }
  546.  
  547. void DAlnITitle::SingleClickAt(short row, short col)
  548. {
  549. }
  550.  
  551. void DAlnHIndex::Click(Nlm_PoinT mouse)
  552. {
  553.     DPanel::Click(mouse);
  554. }
  555.  
  556.  
  557. void DAlnView::Scroll(Boolean vertical, DView* scrollee, short newval, short oldval)
  558. {
  559.     short diff= newval - oldval;
  560.     DTableView::Scroll(vertical, scrollee, newval, oldval);
  561.     
  562.     if (diff && fEditSeq && fEditSeq->fVisible) {
  563.         Nlm_RecT    r;
  564.         short delta;
  565.         if (vertical) {
  566.             delta= diff * fItemHeight; // bad for variable line height
  567.             fEditSeq->GetPosition( r);
  568.             Nlm_OffsetRect( &r, 0, -delta);
  569.             if (r.top < fRect.top || r.top >= fRect.bottom) DeInstallEditSeq();
  570.             else fEditSeq->SetPosition( r);
  571.             }
  572.         else {
  573.                 // messy, undo bitmap scroll by TableView for just editseq rect...
  574.             delta= diff * fItemWidth;
  575.             fEditSeq->GetPosition(r);
  576.             Nlm_ScrollRect(&r, delta, 0);
  577.                     // then redo scroll using edit method !
  578.             fEditSeq->Scroll(vertical, scrollee, newval, oldval);
  579.             }
  580.         }
  581.         
  582.     if (scrollee == this) {
  583.         if (vertical) {
  584.             fDoc->fAlnIndex->Scroll(vertical, scrollee, newval, oldval);
  585.             }
  586.         else {
  587.             fDoc->fAlnHIndex->Scroll(vertical, scrollee, newval, oldval);
  588.             }
  589.         }
  590. }
  591.  
  592. void DAlnIndex::Scroll(Boolean vertical, DView* scrollee, short newval, short oldval)
  593. {
  594.     DTableView::Scroll(vertical, scrollee, newval, oldval);
  595.     if (scrollee == this) {
  596.         if (vertical) {
  597.             fDoc->fAlnView->Scroll(vertical, scrollee, newval, oldval);
  598.             }
  599.         else   // horizontal
  600.             fDoc->fAlnITitle->Scroll(vertical, scrollee, newval, oldval);
  601.              
  602.         }
  603. }
  604.  
  605.  
  606. void DAlnHIndex::Scroll(Boolean vertical, DView* scrollee, short newval, short oldval)
  607. {
  608.     Nlm_RecT    r;
  609.     short delta;
  610.     short diff= newval-oldval;
  611.     ViewRect(r);
  612.     if (vertical) {
  613. #if 0
  614.         delta= diff * cHeight;
  615.         Nlm_ScrollRect (&r, 0, -delta);
  616.         if (diff<0) r.bottom= r.top - delta + Min(5,-delta/2);
  617.         else r.top= r.bottom - delta - Min(5,delta/2);
  618. #endif
  619.         }
  620.     else {
  621. #if 1
  622.         short cWidth= gAlnCharWidth;
  623.         delta= diff * cWidth;
  624.         Nlm_ScrollRect (&r, -delta, 0);
  625.             // test fix for off-by-a-few-pixels in scroll...
  626.         if (diff<0) r.right= r.left - delta + Min(5,-delta/2);
  627.         else r.left= r.right - delta - Min(5,delta/2);
  628. #endif
  629.         }
  630.     this->Select(); // need for motif !
  631.     this->InvalRect( r);
  632.  
  633.     if (scrollee == this) {
  634.         if (!vertical) fDoc->fAlnView->Scroll(vertical, scrollee, newval, oldval);
  635.         }
  636. }
  637.  
  638.  
  639.  
  640. DSequence* DAlnView::SelectedSequence(short& selectedRow)
  641. {
  642.     if (GetSelectedRow() != kNoSelection) {
  643.         selectedRow= GetSelectedRow();
  644.         return fSeqList->SeqAt(selectedRow);
  645.         }
  646.     else if (fDoc && fDoc->fAlnIndex->GetSelectedRow() != kNoSelection) {
  647.         selectedRow= fDoc->fAlnIndex->GetSelectedRow();
  648.         return fSeqList->SeqAt(selectedRow);    
  649.         }
  650.     else {
  651.         selectedRow= kNoSelection;
  652.         return NULL;
  653.         }
  654. }
  655.  
  656.  
  657. void DAlnView::UpdateSize()
  658. {    
  659.     long diff;   
  660.     if (fSeqList) diff= fSeqList->GetSize() - GetMaxRows();
  661.     else diff= -GetMaxRows();
  662.     ChangeRowSize( -1, diff);  // -1 prevents redraw..else use fMaxRows    
  663.     if (fDoc && fDoc->fAlnIndex) fDoc->fAlnIndex->ChangeRowSize(-1, diff);
  664.  
  665. #if MASKS
  666.     if (diff>0) { //fMaskLevel>0 && 
  667.         short i, nseq= fSeqList->GetSize();
  668.         for (i=nseq-diff; i<nseq; i++) {
  669.             DSequence* aseq= fSeqList->SeqAt(i);
  670.             if (fMaskLevel>0 || aseq->Masks()) aseq->FixMasks();
  671.             }
  672.         }
  673. #endif
  674. }
  675.  
  676.  
  677. void DAlnView::UpdateWidth(DSequence* aSeq)
  678. { 
  679.     long alnlen= aSeq->LengthF() + 30;
  680.     if (alnlen > GetMaxCols()) ChangeColSize( -1, alnlen-GetMaxCols());  
  681.     SetItemWidth( 0, GetMaxCols(), gAlnCharWidth);  
  682. #if MASKS
  683.     if (fMaskLevel>0 || aSeq->Masks()) aSeq->FixMasks();
  684. #endif
  685.     //if (fDoc && fDoc->fAlnHIndex) fDoc->fAlnHIndex->UpdateWidth(); //keep ruler in sync
  686. }
  687.  
  688. void DAlnView::UpdateAllWidths()
  689. {
  690.     long alnlen= 0;
  691.     short i, nseq= fSeqList->GetSize();
  692.     for (i=0; i<nseq; i++) {
  693.         DSequence* aSeq= fSeqList->SeqAt(i);
  694.         alnlen= Max(alnlen, aSeq->LengthF()); 
  695. #if MASKS
  696.         if (fMaskLevel>0 || aSeq->Masks()) aSeq->FixMasks();
  697. #endif
  698.         }
  699.     alnlen += 30; 
  700.     if (alnlen > GetMaxCols()) ChangeColSize( -1, alnlen-GetMaxCols());
  701.     SetItemWidth( 0, GetMaxCols(), gAlnCharWidth);  
  702.     //if (fDoc && fDoc->fAlnHIndex) fDoc->fAlnHIndex->UpdateWidth(); //keep ruler in sync
  703. }
  704.  
  705. void DAlnView::SetTextLock( Boolean turnon)
  706. {
  707.     fLocked= turnon;
  708.     if (fLocked) DeInstallEditSeq();
  709. }
  710.  
  711.  
  712. void DAlnView::SetViewMode(short viewmode) 
  713. {
  714.     switch (viewmode) {
  715.         case kModeSlide: 
  716.             this->SetTextLock( true);
  717.             if (this->fMaskLevel>0) this->Invalidate();
  718.             this->fMaskLevel= 0; 
  719.             break;
  720.             
  721.         case kModeEdit:  
  722.             this->SetTextLock( false);
  723.             if (this->fMaskLevel>0) this->Invalidate();
  724.             this->fMaskLevel= 0; 
  725.             break;
  726.             
  727.         case kModeMask1: 
  728.         case kModeMask2: 
  729.         case kModeMask3: 
  730.         case kModeMask4: {
  731.             this->SetTextLock( true);
  732.             this->fMaskLevel= viewmode - kModeMask1 + 1; 
  733.             this->Invalidate();
  734.             short i, nseq= fSeqList->GetSize();
  735.             for (i=0; i<nseq; i++) fSeqList->SeqAt(i)->FixMasks();
  736.             }
  737.             break;
  738.             
  739.         default :
  740.             break;
  741.         }
  742. }
  743.  
  744.  
  745. // move this to DSeqCmds.h ...
  746. class DSetEditCmd : public DSeqChangeCmd {
  747. public: 
  748.     DSetEditCmd( DSeqDoc* itsAlnDoc, DView* itsView, DSequence* oldSeq, char* newbases):
  749.          DSeqChangeCmd("edit seq", itsAlnDoc, itsView, NULL) 
  750.          {
  751.             fOldSeqs= new DSeqList(); 
  752.              fOldSeqs->InsertLast( oldSeq);
  753.             DSequence* newSeq= MakeSequence( oldSeq->Name(), newbases, oldSeq->Info(), 0);
  754.             fNewSeqs->InsertLast( newSeq);
  755.          }
  756. };
  757.  
  758.  
  759. void DAlnView::DeInstallEditSeq()
  760. {
  761.     if (fEditRow >= 0) { 
  762.         if (fEditSeq) {
  763.             Nlm_RecT r;
  764.             char* newbases = fEditSeq->GetText();
  765.             if (StringCmp(newbases, fEditSeq->fSeq->Bases()) != 0) {
  766. #if 0
  767.                 // test if DSetEditCmd is cause of bombs when fEditSeq is used...
  768.                 // no -- this isn't it...
  769.                 fEditSeq->fSeq->SetBases(newbases);                    
  770. #else
  771.                 DSetEditCmd* cmd= new DSetEditCmd( fDoc, this, fEditSeq->fSeq, newbases);
  772.                 if (cmd) PostTask(cmd); 
  773. #endif
  774.                 }
  775.             MemFree( newbases);
  776.           
  777.             fEditSeq->GetPosition(r);
  778.             fEditSeq->HideEdit();
  779.             fDoc->SetEditText(NULL); //??
  780.             InvalRect(r);
  781.             }
  782.         fEditRow= -1;
  783.         }
  784.  
  785. }
  786.  
  787.  
  788.  
  789. void DAlnView::InstallEditSeq(short row, short selStart, short selEnd, Boolean doLight)
  790. {
  791.          
  792.     DeInstallEditSeq();
  793.     //if (gLastEditView && gLastEditView != this) gLastEditView->DeInstallEditSeq();
  794.  
  795.     fEditRow= row;
  796.     if (row >= 0) {
  797.         Nlm_RecT r;
  798.         DSequence* aSeq= fSeqList->SeqAt( row);
  799.         this->GetRowRect( row, r);
  800.         fEditSeq->fSeq= aSeq;
  801.  
  802.         r.left--; // fix off-by-one
  803.         fEditSeq->SetPosition( r);
  804.         fEditSeq->ShowEdit();
  805.         fEditSeq->SetSelection( selStart, selEnd);
  806.         if (fLeft>0) fEditSeq->Scroll(false, NULL, fLeft, 0);
  807.         fDoc->SetEditText(fEditSeq); //??
  808.  
  809.         if (gLastCommand) { delete gLastCommand; gLastCommand= NULL; } //gLastCommand->Commit();    //??
  810.         //gLastEditView= this;
  811.         }
  812.  
  813. }
  814.  
  815.  
  816. void DAlnView::registerInsertLast( DSequence* aSeq)
  817. {
  818.     ChangeRowSize( GetMaxRows(), 1);
  819.     if (fDoc && fDoc->fAlnIndex) 
  820.         fDoc->fAlnIndex->ChangeRowSize( GetMaxRows(), 1);
  821.     UpdateWidth(aSeq);    
  822. }
  823.  
  824. void DAlnView::addToAlnList( DSequence* aSeq)
  825. {
  826.     fSeqList->InsertLast( aSeq);
  827.     //aSeq->fIndex= fSeqList->GetSize(); //??
  828.     registerInsertLast( aSeq); 
  829.  
  830. #if NOT_NOW_MASKS
  831.         // done via registerInsertLast -> UpdateWidth
  832.         if (fMaskLevel>0 || aSeq->fMasks) aSeq->FixMasks();
  833. #endif
  834. }
  835.  
  836.  
  837. void DAlnView::MakeConsensus()
  838. { 
  839.     fSeqList->MakeConsensus();
  840.     short arow= fSeqList->ConsensusRow();
  841.     if (arow>0) {
  842.         Nlm_RecT r;
  843.         GetRowRect( arow, r);
  844.         this->InvalRect( r);
  845.         }
  846. }
  847.  
  848.  
  849. char* DAlnView::FindCommonBases( short minCommonPerCent)
  850. {
  851. // THIS_IS_OBSOLETE
  852.     char *hCommon, *hFirst = NULL;
  853.     //gMinCommonPercent= minCommonPerCent;
  854.     hCommon= fSeqList->FindCommonBases(DSeqList::gMinCommonPercent, hFirst);
  855.     if (hFirst) MemFree( hFirst);
  856.     return hCommon;
  857. }
  858.  
  859.  
  860. void DAlnView::HiliteORFs()
  861. {
  862.     long    start, stop;
  863.     long nseq= fSeqList->GetSize();
  864.     if (fMaskLevel>0) 
  865.     for (long iseq= 0; iseq<nseq; iseq++) {
  866.         DSequence* aSeq= fSeqList->SeqAt(iseq);
  867.         long alen= aSeq->LengthF();
  868.         aSeq->ClearMask(fMaskLevel);
  869.         aSeq->ClearSelection();
  870.  
  871.         aSeq->SearchORF( start, stop);
  872.         while (start>=0) {
  873.             if (stop<start) stop= alen;
  874.             for (long ibase=start; ibase<=stop; ibase++) 
  875.                 aSeq->SetMaskAt( ibase, fMaskLevel);
  876.             if (stop >= alen) start= -1;
  877.             else {
  878.               aSeq->SetSelection( stop+1, alen);
  879.                 aSeq->SearchORF( start, stop);
  880.                 }
  881.             }
  882.         } 
  883.     this->Invalidate();
  884. }
  885.  
  886.  
  887. void DAlnView::HiliteCommonBases()
  888. {  
  889. #if 1
  890.     char * hFirst = NULL;
  891.     char * hCommon= fSeqList->FindCommonBases(DSeqList::gMinCommonPercent, hFirst);
  892.     
  893.     long nseq= fSeqList->GetSize();
  894.     if (fMaskLevel>0) 
  895.     for (long iseq= 0; iseq<nseq; iseq++) {
  896.         DSequence* aSeq= fSeqList->SeqAt(iseq);
  897.         long alen= aSeq->LengthF();
  898.         char * hf = hFirst;
  899.         char * hc = hCommon;
  900.         char * bc = aSeq->Bases();
  901.         aSeq->ClearMask(fMaskLevel);
  902.         for (long ibase=0; ibase<alen; ibase++, hf++, hc++, bc++) 
  903.             if (iseq >= (unsigned char) *hf && toupper(*bc) == *hc)
  904.                 aSeq->SetMaskAt( ibase, fMaskLevel);
  905.         }
  906.     this->Invalidate();
  907.     MemFree(hCommon);
  908.     MemFree(hFirst);
  909. #endif
  910.  
  911. #if THIS_IS_OBSOLETE
  912.     char        *hCon, *hSeq, *hFirst, *hMaxbase;
  913.     long        maxlen;
  914.     short     arow;
  915.      
  916.     DSequence* cons= fSeqList->Consensus();
  917.     if (!cons) cons= (DSequence*) fSeqList->First();
  918.  
  919.     if (cons) {
  920.         arow= fSeqList->GetIdentityItemNo( cons);
  921.         hCon= cons->Bases();   
  922.         hMaxbase= fSeqList->FindCommonBases(DSeqList::gMinCommonPercent, hFirst); 
  923.         
  924.         maxlen= StrLen(hMaxbase);
  925.         this->SetEmptySelection( true);        
  926.         long iseq, nseq= fSeqList->GetSize();
  927.         for (iseq= 0; iseq<nseq; iseq++) {
  928.             DSequence* aSeq= fSeqList->SeqAt(iseq);
  929.             if (!aSeq->IsConsensus() && aSeq->Kind() != DSequence::kOtherSeq) {
  930.                 hSeq= aSeq->Bases();
  931.                 for (short ibase=0; ibase<maxlen; ibase++) {
  932.                     if ( toupper(hSeq[ibase]) == hMaxbase[ibase] )  
  933.                       this->SelectCells( iseq, ibase, false, false);  
  934.                     }
  935.                 }
  936.             }
  937.         this->InvalidateSelection();
  938.         MemFree(hMaxbase); 
  939.         MemFree(hFirst); 
  940.         }
  941. #endif
  942. }
  943.  
  944.  
  945.  
  946.  
  947.  
  948.  
  949. void DAlnView::DrawAlnInStyle( baseColors colors, Boolean swapBackColor,
  950.                                                             char*    pText, long indx, long len, short row)
  951. {
  952. #if MASKS
  953.         
  954.         // ?? do we want this? main use of styles is in PrettyPrint...
  955.         
  956.     Nlm_PoinT pt;
  957.     long            endx, i, pend, skip;
  958.     char            ch, lastch;
  959.     Nlm_RecT    crec; // set this to rect about draw char...
  960.     short         maskval;
  961.         
  962.     Boolean dostyles= (fCurSeq && fCurSeq->MasksOk());
  963.     if (!dostyles) {
  964.         DrawAlnColors( colors, swapBackColor, pText, indx, len,row);
  965.         return;
  966.         }
  967.         
  968.     long cw= GetItemWidth(); //gAlnCharWidth; //Nlm_CharWidth('G');
  969.     long cht= GetItemHeight();
  970.     Nlm_GetPen( &pt);
  971.     if (pt.x < 0) {
  972.         skip= (-pt.x) / cw;
  973.       indx += skip;
  974.         len -= skip;
  975.         pt.x += skip*cw;
  976.         Nlm_MoveTo( pt.x, pt.y);
  977.         }
  978.     pend= len * cw;
  979.     
  980.     if (pend > GetRect().right) {   
  981.         skip= (pend - GetRect().right) / cw;  
  982.         len -= skip;
  983.         }
  984.     endx= indx + len - 1;
  985.     lastch= 0;
  986.     
  987.     for (i= indx; i<=endx; i++) {
  988.         ch= pText[i];
  989.         if (ch >= ' ') {
  990.             if (ch!=lastch) Nlm_SetColor( colors[ch-' ']);
  991.             Nlm_PaintChar(ch);
  992.             lastch= ch;
  993.             if (fMaskLevel>0) {
  994.                 maskval= fCurSeq->MaskAt(i, fMaskLevel);
  995.                 if (maskval>0) {
  996.                     Nlm_LoadRect( &crec, pt.x, pt.y-cht+2, pt.x+cw, pt.y+2); //??
  997.                     //Nlm_FrameRect( &crec); //?? doesn't show on XMotif?
  998.                     DTableView::InvertRect( crec); 
  999.                     }
  1000.                 }
  1001.             pt.x += cw;
  1002.             // !? must reset some of drawing environ !? > Font !
  1003.             }
  1004.         }
  1005.     Nlm_Black();
  1006.     
  1007. #else
  1008.     DrawAlnColors( colors, swapBackColor, pText, indx, len, row);
  1009. #endif
  1010. }
  1011.  
  1012.  
  1013. void DAlnView::DrawAlnColors(baseColors colors, Boolean swapBackColor,
  1014.                                                             char*    pText, long indx, long len, short row)
  1015. {
  1016.     Nlm_PoinT pt;
  1017.     long            endx, i, pend, skip;
  1018.     char            ch, lastch;
  1019.     
  1020.     long cw= GetItemWidth(); //gAlnCharWidth; //Nlm_CharWidth('G');
  1021.     Nlm_GetPen( &pt);
  1022.     if (pt.x < 0) {
  1023.         skip= (-pt.x) / cw;
  1024.       indx += skip;
  1025.         len -= skip;
  1026.         Nlm_MoveTo( pt.x + skip*cw, pt.y);
  1027.         }
  1028.     pend= len * cw;
  1029.     
  1030.     if (pend > GetRect().right) {   
  1031.         skip= (pend - GetRect().right) / cw;  
  1032.         len -= skip;
  1033.         }
  1034.     endx= indx + len - 1;
  1035.     
  1036.     //-- backcolor not showing -- need erase or something...
  1037.     //if (swapBackcolor) RGBForeColor( colors[' '-' ']); else RGBBackColor( colors[' '-' ']);
  1038.      
  1039.     //Nlm_CopyMode(); //?? assume?
  1040.     lastch= 0;
  1041.     for (i= indx; i<=endx; i++) {
  1042.         ch= pText[i];
  1043.         if (ch >= ' ') {
  1044.             // if (swapBackcolor) RGBBackColor( colors[ch-' ']); else 
  1045.             if (ch!=lastch) Nlm_SetColor( colors[ch-' ']);
  1046.             Nlm_PaintChar(ch);
  1047.             lastch= ch;
  1048.             }
  1049.         }
  1050.     Nlm_Black();
  1051. } 
  1052.  
  1053.  
  1054.  
  1055.  
  1056. void DAlnView::DrawAllColors(Nlm_RecT r, short row)
  1057. { 
  1058. #if MASKS
  1059. #define DRAWALN    DrawAlnInStyle
  1060. #else
  1061. #define DRAWALN    DrawAlnColors
  1062. #endif
  1063.  
  1064.     long stopcol, startcol = GetLeft(); 
  1065.     long newright= r.left;
  1066.  
  1067.     for (stopcol= startcol; stopcol<GetMaxCols() && newright<r.right; stopcol++) {
  1068.         //if (fWidths) newright += fWidths[startcol]; else 
  1069.         newright += GetItemWidth();
  1070.         // optimize later -- check update region by each char rect ...
  1071.         //if (Nlm_RectInRgn (&item_rect, Nlm_updateRgn)) done= true;
  1072.         }
  1073.  
  1074.     DSequence* aSeq= fSeqList->SeqAt(row);
  1075.     if (aSeq && aSeq->Bases()) {
  1076.         char* hSeq= aSeq->Bases();
  1077.         fCurSeq= aSeq;
  1078.         long len= Min( aSeq->LengthF(), stopcol) - startcol;
  1079.         if (len>0 && hSeq) {
  1080.             Nlm_MoveTo( r.left, r.bottom-2); //bottom-5
  1081.             if (aSeq->Kind() == DSequence::kAmino)
  1082.                 DRAWALN(DBaseColors::gAAcolors, gSwapBackground, hSeq, startcol, len, row);
  1083.             else
  1084.                 DRAWALN(DBaseColors::gNAcolors, gSwapBackground, hSeq, startcol, len, row);
  1085.             }
  1086.         }
  1087.     fColsDrawn= stopcol - startcol;
  1088. }  
  1089.  
  1090. void DAlnView::DrawNoColors(Nlm_RecT r, short row)
  1091. { 
  1092.     long stopcol, startcol = GetLeft(); 
  1093.     long newright= r.left;
  1094.     short    cwidth= GetItemWidth(); // Nlm_CharWidth('G'); //fItemWidth
  1095.     
  1096.     for (stopcol= startcol; stopcol<GetMaxCols() && newright<r.right; stopcol++) {
  1097.         //if (fWidths) newright += fWidths[startcol]; else 
  1098.         newright += cwidth;
  1099.         // optimize later -- check update region by each char rect ...
  1100.         //if (Nlm_RectInRgn (&item_rect, Nlm_updateRgn)) done= true;
  1101.         }
  1102.  
  1103.     DSequence* aSeq= fSeqList->SeqAt(row);
  1104.     if (aSeq && aSeq->Bases()) {
  1105.         char *s, se, *hSeq= aSeq->Bases();
  1106.         long len= Min( aSeq->LengthF(), stopcol) - startcol;
  1107.         if (len>0 && hSeq) {
  1108. #if MASKS
  1109.             if (fMaskLevel>0) {
  1110.                 short atx= r.left;
  1111.                 short aty= r.bottom-2;
  1112.                 stopcol= startcol + len;
  1113.                 for (long i= startcol; i<stopcol; i++) {
  1114.                     Nlm_MoveTo(atx, aty);
  1115.                     Nlm_PaintChar(hSeq[i]);
  1116.                     short maskval= aSeq->MaskAt(i, fMaskLevel);
  1117.                     if (maskval>0) {
  1118.                         Nlm_RecT crec;
  1119.                         Nlm_LoadRect( &crec, atx, r.top, atx+cwidth, r.bottom); 
  1120.                         //Nlm_FrameRect( &crec); //<< ? bad for Motif, also messy looking
  1121.                         DTableView::InvertRect( crec); 
  1122.                         }
  1123.                     atx += cwidth;
  1124.                     }
  1125.                 }
  1126.             else 
  1127. #endif
  1128.                 {
  1129.                 Nlm_MoveTo( r.left, r.bottom-2); //bottom-5
  1130.                 s= hSeq+startcol;
  1131.                 se= s[len];
  1132.                 s[len]= 0;
  1133.                 Nlm_PaintString( s); 
  1134.                 s[len]= se;
  1135.                 //Nlm_DrawText( &r, hSeq+startcol, len, 'l', false); // gray== false
  1136.                 }
  1137.         }
  1138.         }
  1139.     fColsDrawn= stopcol - startcol;
  1140. }  
  1141.  
  1142.         
  1143. void DAlnView::Draw()
  1144. {
  1145.     DTableView::Draw();
  1146. }
  1147.  
  1148.  
  1149. void DAlnView::DrawRow(Nlm_RecT r, short row)
  1150. {
  1151.      // DTableView::Draw() does SelectFont(fFont)
  1152.   if (fEditRow == row) {
  1153.          // do nothing? , fEditSeq handle's redraw ??
  1154.         fColsDrawn= 0;
  1155.          }
  1156.     else if (fDoc && fDoc->fUseColor) 
  1157.         DrawAllColors(r, row); 
  1158.     else
  1159.         DrawNoColors(r, row);
  1160. }
  1161.  
  1162.         
  1163. void DAlnIndex::DrawCell(Nlm_RecT r, short row, short col)
  1164. {
  1165. #if 0
  1166.     long stopcol, startcol = fLeft; 
  1167.     long newright= r.left;
  1168.     short    cwidth= Nlm_CharWidth('G'); //fItemWidth
  1169.     
  1170.     for (stopcol= startcol; stopcol<fMaxCols && newright<r.right; stopcol++) {
  1171.         //if (fWidths) newright += fWidths[startcol]; else 
  1172.         newright += cwidth;
  1173.         // optimize later -- check update region by each char rect ...
  1174.         //if (Nlm_RectInRgn (&item_rect, Nlm_updateRgn)) done= true;
  1175.         }
  1176. #endif
  1177.  
  1178.     // add cols for Kind(), Length(), Origin(), UpdateTime(), Info()(wide col..better in box)
  1179.         
  1180.     DSequence* aSeq= fSeqList->SeqAt(row);
  1181.     if (aSeq) switch (col) {
  1182.         case 0: 
  1183.             {
  1184.             char* hSeq= aSeq->Name();
  1185.             Nlm_DrawString( &r, hSeq, 'l', false);
  1186.             return;
  1187.             }
  1188.         case 1:
  1189.             {
  1190.             char buf[128];
  1191.             sprintf(buf,"%d ", aSeq->LengthF()); // switch to ostrstream !?
  1192.             Nlm_DrawString( &r, buf, 'r', false);
  1193.             return;
  1194.             }
  1195.         case 2:
  1196.             {
  1197.             char* hSeq= aSeq->KindStr();
  1198.             Nlm_DrawString( &r, hSeq, 'l', false);
  1199.             return;
  1200.             }
  1201.         case 3:
  1202.             {
  1203.             char buf[128];
  1204.             sprintf(buf,"%8lx ", aSeq->Checksum()); // switch to ostrstream !?
  1205.             Nlm_DrawString( &r, buf, 'l', false);
  1206.             return;
  1207.             }
  1208.         }
  1209. }
  1210.  
  1211.  
  1212. void DAlnITitle::DrawCell(Nlm_RecT r, short row, short col)
  1213. {
  1214.     switch (col) {
  1215.         case 0: 
  1216.             {
  1217.             Nlm_DrawString( &r, "Name", 'l', false);
  1218.             return;
  1219.             }
  1220.         case 1:
  1221.             {
  1222.             Nlm_DrawString( &r, "Bases", 'l', false);
  1223.             return;
  1224.             }
  1225.         case 2:
  1226.             {
  1227.             Nlm_DrawString( &r, "Kind", 'l', false);
  1228.             return;
  1229.             }
  1230.         case 3:
  1231.             {
  1232.             Nlm_DrawString( &r, "Checksum", 'l', false);
  1233.             return;
  1234.             }
  1235.         }
  1236. }
  1237.  
  1238. void DAlnHIndex::Draw()
  1239. {
  1240.     Nlm_RecT r;
  1241.     short atx, aty;
  1242.     char nums[128];
  1243.  
  1244.     fDoc->fAlnView->SelectFont();  
  1245.     ViewRect( r);
  1246.     long stopcol, startcol = fDoc->fAlnView->GetLeft(); 
  1247.     long newright= r.left;
  1248.     short    cwidth= Nlm_CharWidth('G');  
  1249.  
  1250. #if 0    
  1251.     Nlm_RecT vr;
  1252.     // is ViewRect bad !? (too short)  YES - isn't grown !?
  1253.   fDoc->fAlnView->ViewRect( vr);
  1254.   r.right= vr.right; //??
  1255.     Nlm_ClipRect( &r); // ?? why is hindex clipped to small !?
  1256. #endif
  1257.     
  1258.     for (stopcol= startcol; 
  1259.         stopcol < fDoc->fAlnView->GetMaxCols() && newright<r.right;
  1260.       stopcol++) {
  1261.         newright += cwidth;
  1262.         }
  1263.  
  1264.     long len= stopcol - startcol;
  1265.     atx= r.left;
  1266.     aty= r.bottom;
  1267.     for (short i= startcol; i<=stopcol; i++) {
  1268.         if (i == 0) ; //skip
  1269.         else if (i % 10 == 0) {
  1270.             Nlm_MoveTo(atx, aty);
  1271.             Nlm_LineTo(atx, aty-2);
  1272.             sprintf( nums, "%d", i);
  1273.             short ws= Nlm_StringWidth(nums);
  1274.             Nlm_MoveTo( atx-(ws/ 2), aty-3);
  1275.             Nlm_PaintString(nums);
  1276.             //Nlm_DrawString( &r1, nums, 'c', false);
  1277.             }    
  1278.         else if (i % 5 == 0) {
  1279.             Nlm_MoveTo( atx, aty);
  1280.             Nlm_LineTo(atx, aty-6);
  1281.             }
  1282.         atx += cwidth;
  1283.         }
  1284. }
  1285.  
  1286.  
  1287.  
  1288.  
  1289.         
  1290.  
  1291. #if FIX_LATER
  1292. Boolean DAlnView::ContainsClipType(long aType) // override 
  1293. {
  1294.     return (aType == kAlnScrapType);
  1295.     //!? also (aType == 'TEXT') can be pasted as seq... w/ SeqReadScrap...
  1296. }
  1297. #endif
  1298.  
  1299. #if FIX_LATER
  1300. void DAlnView::WriteToDeskScrap() // override 
  1301. {
  1302.     short format = kGenBank;
  1303.     //if (fDoc->fFormatPop) format= fDoc->fFormatPop->GetValue(); 
  1304.     fSeqList->ClearSelections();
  1305.     char* textScrap= fSeqList->doWriteHandle( format);  
  1306.     short err = gClipboardMgr->PutDeskScrapData('TEXT', textScrap);
  1307.     MemFree( textScrap);
  1308. }
  1309. #endif
  1310.  
  1311.  
  1312.  
  1313.  
  1314.         
  1315.         
  1316.         
  1317. // DAlnIndex     ------------------
  1318.  
  1319.  
  1320. char* DAlnIndex::GetItemTitle(short item, char* title, size_t maxsize)   
  1321. {
  1322.   if (fSeqList && item <= fSeqList->GetSize()) {
  1323.         DSequence* aSeq= fSeqList->SeqAt(item);
  1324.         if (aSeq) {
  1325.             if (!title) title= (char*) MemNew( maxsize);
  1326.             StrNCpy( title, aSeq->Name(), maxsize);
  1327.             return title;
  1328.             }
  1329.         }
  1330.     return NULL;
  1331. }
  1332.  
  1333.  
  1334. #if FIX_LATER
  1335.  
  1336. void TAlnIndex::UpdateSize(void)
  1337. VAR    diff: integer;
  1338. {
  1339.     if ((fAlnView!=NULL)) {
  1340.         diff= fAlnView->fNumOfRows - fNumOfRows;
  1341.         if ((diff>0)) InsRowLast( 1, fAlnView->fRowheight)     
  1342.         else if ((diff<0)) DelItemLast( -diff);
  1343.         }    else
  1344.         DelItemLast(fNumOfRows);
  1345. }
  1346.  
  1347. void TAlnIndex::ReSelect(RgnHandle indexRegion)
  1348. VAR  aCell: GridCell;
  1349. {
  1350.     /*-----
  1351.     aCell = (*indexRegion)->rgnBBox.topLeft;
  1352.     if (!IsCellVisible(aCell)) PositionAtCell(aCell);                 
  1353.     ----*/
  1354.     
  1355.     if (!EqualRect((*indexRegion)->rgnBBox, (*fSelections)->rgnBBox)) {
  1356.         /*---- ??
  1357.         WITH fDoc){
  1358.             fAlnView->SetEmptySelection(kHighlight);  
  1359.             }
  1360.         -----*/
  1361.         SetSelection(indexRegion, kDontExtend, kHighlight, kSelect);
  1362.         }
  1363. }
  1364.  
  1365.  
  1366.  
  1367. TAlnIndex::HandleMouseDown( VPoint theMouse, TToolboxEvent event, 
  1368.                              hysteresis: Point):Boolean; // override 
  1369. {        
  1370.     fAlnView->DeInstallEditSeq();
  1371.     fAlnView->SetEmptySelection(kHighlight); 
  1372.     
  1373.   HandleMouseDown= inherited::HandleMouseDown(theMouse,event,hysteresis);
  1374. }
  1375.  
  1376. void TAlnIndex::DoMouseCommand(VPoint VAR theMouse, TToolboxEvent event,
  1377.                                                Point hysteresis) // override 
  1378. VAR
  1379.     aRow, aCol    : short;
  1380.     aCell    : GridCell;
  1381.     aAlnShifter        : TAlnShifter;
  1382.     boolean        aDoubleClick;
  1383.     aName    : Str255;
  1384.     vpt        : VPoint;
  1385.     GridViewPart        gridPart;
  1386.     aSeq    : DSequence;
  1387.     
  1388. {
  1389.     aDoubleClick= event->fClickCount > 1;
  1390.     gridPart= IdentifyPoint(theMouse, aCell);
  1391.     aRow= aCell.y;
  1392.     
  1393.     if (aDoubleClick) {
  1394.         aSeq= DSequence(fSeqList->At(aRow));
  1395.         if (aSeq!=NULL)) TAlnDoc(fDocument)->OpenSeqedWindow(aSeq);
  1396.         }        
  1397.     else if ((event.IsShiftKeyPressed |event->IsCommandKeyPressed())) { 
  1398.         inherited::DoMouseCommand(theMouse,event,hysteresis) 
  1399.         }        
  1400.     else if (gridPart != badChoice) {
  1401.         aCell    = VPointToLastCell(theMouse);
  1402.         //if TRUE then begin
  1403.         if (isCellSelected(aCell)) {
  1404.             GetItemText(aRow, aName);
  1405.             New(aAlnShifter);
  1406.             FailNIL(aAlnShifter);
  1407.             aAlnShifter->IAlnShifter(this, fAlnView, aRow, aName);
  1408.             PostCommand( aAlnShifter);
  1409.             }        else
  1410.             inherited::DoMouseCommand(theMouse,event,hysteresis); 
  1411.         }
  1412. }
  1413.  
  1414. #endif // FIX_LATER
  1415.  
  1416.  
  1417.  
  1418.  
  1419.  
  1420.  
  1421.  
  1422.  
  1423.  
  1424.  
  1425. class DSeqFormatPopup : public DPopupList
  1426. {
  1427. public:
  1428.     DSeqFormatPopup(long id, DView* superior, short defaultFormat);
  1429.     virtual short GetValue() { return DSeqFile::kMinFormat + DPopupList::GetValue() - 1; }
  1430. };
  1431.  
  1432. DSeqFormatPopup::DSeqFormatPopup(long id, DView* superior, short defaultFormat) :
  1433.             DPopupList(id,superior,true)
  1434. {
  1435.     for (short i= DSeqFile::kMinFormat; i<=DSeqFile::kMaxFormat; i++) 
  1436.         this->AddItem( (char*)DSeqFile::FormatName(i));
  1437.     this->SetValue(defaultFormat);
  1438. }
  1439.  
  1440.  
  1441.  
  1442. class DAlnModePopup : public DPopupList
  1443. {
  1444. public:
  1445.     DAlnModePopup(long id, DView* superior, short defaultvalue);
  1446.     virtual short GetValue() { return DAlnView::kModeSlide + DPopupList::GetValue() - 1; }
  1447. };
  1448.  
  1449. DAlnModePopup::DAlnModePopup(long id, DView* superior, short defaultvalue) :
  1450.             DPopupList(id,superior,true)
  1451. {
  1452.     AddItem( "Slide bases");
  1453.     AddItem( "Edit bases");
  1454.     AddItem( "Select mask 1");
  1455.     AddItem( "Select mask 2");
  1456.     AddItem( "Select mask 3");
  1457.     AddItem( "Select mask 4");
  1458.     this->SetValue(defaultvalue+1);
  1459. }
  1460.  
  1461.  
  1462.  
  1463. // class DAlnFindDialog
  1464.  
  1465. class DAlnFindDialog : public DFindDialog {
  1466. public:
  1467.     DSequence* fSequence;
  1468.     DAlnView* fAlnView;
  1469.     short     fRow;
  1470.     char    * fLastTarget;
  1471.     long        fLastMatch;
  1472.     DAlnFindDialog( DSequence* itsSeq, DAlnView* itsView);
  1473.     virtual void DoFind();
  1474.     virtual void BuildDlog();
  1475. };
  1476.  
  1477. DAlnFindDialog::DAlnFindDialog( DSequence* itsSeq, DAlnView* itsView) :
  1478.         fSequence(itsSeq), fAlnView( itsView), 
  1479.         fLastTarget(NULL), fRow(-1), fLastMatch(-1)
  1480. {
  1481. }
  1482.  
  1483. void DAlnFindDialog::BuildDlog()
  1484. {
  1485.     DFindDialog::BuildDlog();
  1486.  
  1487.     DView* av;
  1488.     av= FindSubview(replaceId); if (av) { av->Disable(); } //av->Hide();
  1489.     av= FindSubview(replaceFindId); if (av) { av->Disable();  }
  1490.     av= FindSubview(replaceAllId); if (av) { av->Disable(); }
  1491.     av= FindSubview(cBackwards);     if (av) { av->Disable(); }
  1492.     av= FindSubview(cFullWord); if (av) { av->Disable(); }
  1493.     av= FindSubview(cCaseSense); if (av) { av->Disable(); }
  1494.     if (fReplaceText) fReplaceText->Disable();
  1495. }
  1496.  
  1497. void DAlnFindDialog::DoFind() 
  1498. {
  1499.     long    firstBase, nBases, match;
  1500.     const char    *target;
  1501.     Boolean back;
  1502.     Nlm_RecT selr;
  1503.     short        selrow;
  1504.     
  1505.     fSequence= fAlnView->SelectedSequence(selrow);
  1506.     fRow= selrow;
  1507.     if (fSequence) {
  1508.         fSequence->UpdateFlds();  
  1509.         selr= fAlnView->GetSelRect();
  1510.         selr.top= fRow;
  1511.         selr.bottom= fRow+1; //??
  1512.         firstBase= selr.left;
  1513.         nBases= 0; //selr.right - firstBase;
  1514.         fSequence->SetSelection( firstBase, nBases);
  1515.         target= this->GetFind();
  1516.         back    = this->Backwards();
  1517.         if (target && *target) {
  1518.             if (fLastTarget && (StringCmp(target, fLastTarget)==0) && firstBase == fLastMatch)
  1519.                 match= fSequence->SearchAgain();
  1520.             else {
  1521.                 if (fLastTarget) MemFree(fLastTarget);
  1522.                 fLastTarget= StrDup(target);
  1523.                 match= fSequence->Search( (char*)target, back);
  1524.                 }
  1525.             fLastMatch= match;
  1526.             if (match>=0) {
  1527.                 nBases= StrLen(target);
  1528.                 fSequence->SetSelection( match, nBases);
  1529.                 selr.left= match;
  1530.                 selr.right= match + nBases;
  1531.                 fAlnView->SelectCells( selr); // !? this is bad
  1532.                 //fAlnView->InvalidateSelection();
  1533.                 }
  1534.             }
  1535.         }
  1536. }                
  1537.  
  1538.  
  1539.  
  1540. //class DSeqDoc
  1541.  
  1542.  
  1543. DSeqDoc::DSeqDoc( long id, DSeqList* itsSeqList, char* name) :
  1544.         DWindow( id, gApplication),
  1545.         fAlnView(NULL), fAlnIndex(NULL), fAlnITitle(NULL),
  1546.         fSeqList(itsSeqList), fPrintDoc(NULL),
  1547.         fHeadline(NULL), fFormatPop(NULL),
  1548.         fUpdateTime(0), fDocTitle(NULL),
  1549.         fInFormat(DSeqFile::kGenBank), // kNoFormat
  1550.         fSaveSelection(false),
  1551.         //fLockButton(NULL), fColorButton(NULL), fMonoButton(NULL),
  1552.         fColorCheck(NULL), fLockCheck(NULL),
  1553.         fUseColor(false)
  1554. { 
  1555.     short width= -1, height= -1, left= -10, top= -20; // default window loc
  1556.     if (gTextFont == NULL) gTextFont= Nlm_programFont;
  1557.     if (gSeqFont == NULL) gSeqFont= Nlm_programFont;
  1558.  
  1559.     if (!Nlm_EmptyRect(&fgWinRect))  {
  1560.             // these two are causing resize to fail >> width & height setting !!
  1561.         //width= MAX( 40, fgWinRect.right - fgWinRect.left);
  1562.         //height= MAX( 50, fgWinRect.bottom - fgWinRect.top);
  1563.         left= MAX(20,fgWinRect.left);
  1564.         top = MAX(40,fgWinRect.top);
  1565.         }
  1566.  
  1567.     this->InitWindow( document, width, height, left, top, name); 
  1568.     gDefSeqName= name; 
  1569.     
  1570.     if (!fSeqList) fSeqList= new DSeqList();  
  1571.     //fSeqList->AddNewSeq();    // install 1 blank seq for new doc
  1572. }
  1573.  
  1574.  
  1575. DSeqDoc::~DSeqDoc()
  1576. {
  1577. #if 0
  1578.         // done now as part of ~DTaskMaster !
  1579.     if (gLastCommand) { 
  1580.     
  1581.         // !! MUST delete any tasks/commands owned by window in task queue !!
  1582.         // at least any 'edit seq' tasks...
  1583.  
  1584.       if (((DView*)gLastCommand->fSource)->GetWindow() == this) {
  1585.             delete gLastCommand; gLastCommand= NULL; 
  1586.             }  
  1587.         }
  1588. #endif
  1589.     if (fSeqList) { fSeqList->FreeAllObjects(); fSeqList->suicide(); }
  1590. }
  1591.  
  1592. void DSeqDoc::FreeData()
  1593. {
  1594.     if (fSeqList) { fSeqList->FreeAllObjects(); }
  1595. }
  1596.  
  1597.  
  1598. Boolean DSeqDoc::IsSeqFile(DFile* aFile)
  1599. {
  1600.     // this is a static function, usable w/o a DGopherListDoc object
  1601.     if (fgTestSeqFile && aFile && aFile->Exists()) {
  1602.         aFile->OpenFile();
  1603.         short format= DSeqFile::SeqFileFormatWrapper( aFile);
  1604.         return (format != DSeqFile::kUnknown);
  1605.         }
  1606.     else
  1607.         return false;
  1608. }
  1609.  
  1610. void DSeqDoc::MakeGlobalsCurrent()
  1611. {
  1612.     ViewRect( fViewrect); // get current rect...
  1613.     if (!Nlm_EmptyRect(&fViewrect)) fgWinRect= fViewrect;  
  1614.     if (fLockCheck) fgLockText= fLockCheck->GetStatus();
  1615.     if (fColorCheck) fgUseColor= fColorCheck->GetStatus();
  1616.     if (fModePop) fgViewMode= fModePop->GetValue();
  1617. }
  1618.  
  1619. void DSeqDoc::Close()
  1620. {
  1621. #if 1
  1622.     DList* winlist= gWindowManager->GetWindowList();
  1623.     short  i, nwin= winlist->GetSize();
  1624.     for (i=0; i<nwin; i++) {
  1625.         DWindow* awin= (DWindow*) winlist->At(i);
  1626.         if (awin->Id() == DSeqedWindow::kId 
  1627.             && ((DSeqedWindow*) awin)->fMainDoc == this) { 
  1628.                 delete awin; // ?? or awin->Close();
  1629.                  }
  1630.         }
  1631. #endif
  1632.     
  1633.     MakeGlobalsCurrent();
  1634.     DWindow::Close();
  1635. }
  1636.  
  1637. void DSeqDoc::ResizeWin()
  1638. {
  1639.     DWindow::ResizeWin();
  1640.     MakeGlobalsCurrent();
  1641. }
  1642.  
  1643. void DSeqDoc::Open(DFile* aFile)
  1644. {
  1645.     Boolean isempty= (fSeqList->GetSize() < 1);
  1646.     if ( ReadFrom( aFile, true) ) {
  1647.         if (isempty) this->SetTitle((char*)aFile->GetShortname());
  1648.         this->Open();
  1649.         }
  1650.     else 
  1651.         if (isempty) this->suicide();
  1652. }
  1653.  
  1654.  
  1655. // static
  1656. void DSeqDoc::NewSeqDoc()
  1657. {
  1658.     DSeqDoc* newdoc= new DSeqDoc( DSeqDoc::kSeqdoc, NULL, (char*)DFileManager::kUntitled);
  1659.     newdoc->Open();
  1660.     newdoc->EditSeqs(); //?? make it real obvious to beginners?
  1661. }
  1662.  
  1663. // static
  1664. void DSeqDoc::GetGlobals()
  1665. {
  1666.     char* onoffs;
  1667.  
  1668.     SeqDocPrefs(kSeqDocPrefInit);
  1669.     DSeqPrintDoc::GetGlobals();
  1670.     SeqPrintPrefs(kSeqPrintPrefInit);
  1671.  
  1672.     onoffs= (fgLockText) ? "1" : "0";
  1673.     fgLockText= gApplication->GetPrefVal( "fgLockText", "windows", onoffs);
  1674.     onoffs= (fgUseColor) ? "1" : "0";
  1675.     fgUseColor= gApplication->GetPrefVal( "fgUseColor", "windows", onoffs);
  1676.     fgViewMode= gApplication->GetPrefVal( "fgViewMode", "seqdoc", "0");
  1677.  
  1678.     {
  1679.     //350, 200
  1680.     char* srect = gApplication->GetPref( "fgWinRect", "windows", "30 40 450 220");
  1681. #if 1
  1682.         // sscanf is failing on Mac/codewar !! used to work
  1683.     if (srect) {
  1684.         char* cp= srect;
  1685.         while (*cp && isspace(*cp)) cp++;
  1686.         fgWinRect.left= atoi( cp);
  1687.         
  1688.         while (*cp && !isspace(*cp)) cp++;
  1689.         while (*cp && isspace(*cp)) cp++;
  1690.         fgWinRect.top= atoi( cp);
  1691.         
  1692.         while (*cp && !isspace(*cp)) cp++;
  1693.         while (*cp && isspace(*cp)) cp++;
  1694.         fgWinRect.right= atoi( cp);
  1695.         
  1696.         while (*cp && !isspace(*cp)) cp++;
  1697.         while (*cp && isspace(*cp)) cp++;
  1698.         fgWinRect.bottom= atoi( cp);
  1699.         }
  1700. #else
  1701.         if (srect) sscanf( srect, "%d%d%d%d", &fgWinRect.left, &fgWinRect.top, 
  1702.                                                 &fgWinRect.right, &fgWinRect.bottom);
  1703. #endif
  1704.         MemFree(srect);
  1705.     }
  1706. }
  1707.  
  1708. // static
  1709. void DSeqDoc::SaveGlobals()
  1710. {
  1711.     gApplication->SetPref( (int) fgLockText,"fgLockText","windows");
  1712.     gApplication->SetPref( (int) fgUseColor, "fgUseColor","windows");
  1713.     gApplication->SetPref( (int) fgViewMode, "fgViewMode","seqdoc");
  1714.  
  1715.     if (!Nlm_EmptyRect(&fgWinRect)) {
  1716.         char  srect[128];
  1717.         sprintf( srect, "%d %d %d %d", fgWinRect.left, fgWinRect.top, 
  1718.                                                         fgWinRect.right, fgWinRect.bottom);
  1719.         gApplication->SetPref( srect, "fgWinRect", "windows");
  1720.         }
  1721. }
  1722.  
  1723.  
  1724. void DSeqDoc::Open()
  1725. {
  1726.     DView* super;
  1727.     short width, height;
  1728.     Nlm_PoinT        nps;
  1729.     DPrompt* pr;
  1730.     Boolean selectone= false;
  1731.     
  1732.     if (!fSeqList) fSeqList= new DSeqList();
  1733.     if (fSeqList->GetSize() == 0) {
  1734.         fSeqList->AddNewSeq();    // install 1 blank seq for new doc
  1735.         selectone= true;
  1736.         }
  1737.     if (!fAlnView || !fAlnIndex || !fAlnHIndex || !fAlnITitle) {
  1738.         super= this;
  1739.         fColorCheck= new DCheckBox(kColorButHit,super,"Color bases");
  1740.         fColorCheck->SetStatus(fgUseColor);
  1741.         fUseColor= fgUseColor;
  1742.         super->NextSubviewToRight();
  1743. #if MASKS
  1744.         pr= new DPrompt(0,super," Mode:",0, 0, Nlm_programFont);
  1745.         super->NextSubviewToRight();
  1746.         fModePop= new DAlnModePopup(kModePopup,super,fgViewMode);
  1747.         fLockCheck= NULL;
  1748. #else
  1749.         fLockCheck= new DCheckBox(kLockButHit,super,"Lock text");
  1750.         fLockCheck->SetStatus(fgLockText);
  1751. #endif
  1752.         super->NextSubviewToRight();
  1753.         pr= new DPrompt(0,super,"  File format:",0, 0, Nlm_programFont);
  1754.         super->NextSubviewToRight();
  1755.         fFormatPop= new DSeqFormatPopup(0,super,fInFormat);
  1756.         super->NextSubviewBelowLeft();
  1757.         
  1758.             // left group : titleline over name table
  1759.         DCluster* grouper= new DCluster( 0, this, 0, 0, true);   // was 0,0 for w,h
  1760.         grouper->SetResize( DView::fixed, DView::relsuper);
  1761.         super= grouper;
  1762.  
  1763.         fAlnITitle= new DAlnITitle(0, super, 80, Nlm_stdLineHeight);
  1764.         super->NextSubviewBelowLeft();
  1765.  
  1766.         //width= 350; height= 200;
  1767.         super->GetNextPosition( &nps);
  1768.         width = MAX( 40, fgWinRect.right - fgWinRect.left) - Nlm_vScrollBarWidth  - nps.x; 
  1769.         height= MAX( 60, fgWinRect.bottom - fgWinRect.top) - Nlm_hScrollBarHeight - nps.y;   
  1770.         fAlnIndex= new DAlnIndex(0, super, this, fSeqList, 80, height); // pixwidth,height
  1771.                                                                                                       //  ^^ needs to be user changable ??
  1772.         super= this;
  1773.         super->NextSubviewToRight();        
  1774.         
  1775.             // right group : index topline over bases table
  1776.         grouper= new DCluster( 0, this, 0, 0, true); // was 0,0 wid,hgt
  1777.         grouper->SetResize( DView::relsuper, DView::relsuper);
  1778.         super= grouper;
  1779.         super->GetNextPosition( &nps);
  1780.         width = MAX( 40, fgWinRect.right - fgWinRect.left) - Nlm_vScrollBarWidth  - nps.x; 
  1781.         height= MAX( 60, fgWinRect.bottom - fgWinRect.top) - Nlm_hScrollBarHeight - nps.y; 
  1782.         fAlnHIndex= new DAlnHIndex(0, super, this, fSeqList, width, Nlm_stdLineHeight);
  1783.         super->NextSubviewBelowLeft();
  1784.         
  1785.         //width= 350; height= 200;
  1786.         super->GetNextPosition( &nps);
  1787.         width = MAX( 40, fgWinRect.right - fgWinRect.left) - Nlm_vScrollBarWidth  - nps.x; 
  1788.         height= MAX( 60, fgWinRect.bottom - fgWinRect.top) - Nlm_hScrollBarHeight - nps.y; 
  1789.         fAlnView= new DAlnView(0, super, this, fSeqList, width, height); // pixwidth,height
  1790.         fAlnView->SetTextLock( fgLockText);
  1791.         super= this;
  1792.  
  1793. #if ETEXT
  1794.         //if (gLastEditView) gLastEditView->DeInstallEditSeq();
  1795.         {
  1796.         Nlm_PoinT  nps, saveps;
  1797.         GetNextPosition( &saveps);
  1798.         nps.x= 1; nps.y= 1; // locate dialog item 
  1799.         SetNextPosition( nps);
  1800.         //gDialogTextMultiline= false;
  1801.         DAlnSequence* eseq= new DAlnSequence( 0, this);  
  1802.         fAlnView->fEditSeq= eseq;
  1803.         //this->SetEditText(eseq);
  1804.         eseq->fVisible= true;
  1805.         eseq->HideEdit(); // eseq->Disable(); eseq->Hide();
  1806.         this->SetEditText(NULL);  
  1807.         SetNextPosition( saveps);
  1808.         }
  1809. #endif
  1810.  
  1811.         }
  1812.     fSaveHandler= this;  
  1813.     fPrintHandler= this; 
  1814.     
  1815.     if (!fFindDlog) fFindDlog= new DAlnFindDialog( NULL, fAlnView);
  1816.  
  1817.     this->Select(); // for motif
  1818.     this->CalcWindowSize();
  1819.     fAlnView->GetReadyToShow(); // do before others ...
  1820.     if (fAlnIndex) fAlnIndex->GetReadyToShow();
  1821.     fAlnITitle->GetReadyToShow();
  1822.     //fAlnHIndex->GetReadyToShow();
  1823.     fAlnView->SetViewMode(fgViewMode);
  1824.     if (selectone && fAlnIndex) fAlnIndex->SelectCells(0,0);
  1825.     
  1826.     DWindow::Open();
  1827. }
  1828.  
  1829.  
  1830. void DSeqDoc::Activate()
  1831. {
  1832.     if (fAlnView && fAlnView->fEditSeq && fAlnView->fEditSeq->fVisible) 
  1833.         fAlnView->fEditSeq->selectAction();
  1834.     gCursor->arrow();
  1835.     DWindow::Activate();
  1836. }
  1837.  
  1838. void DSeqDoc::Deactivate()
  1839. {
  1840.     if (fAlnView && fAlnView->fEditSeq) fAlnView->fEditSeq->deselectAction();
  1841.     DWindow::Deactivate();
  1842. }
  1843.  
  1844. void DSeqDoc::Print()
  1845. {
  1846.     // fix this to print more of window !
  1847.     //fAlnView->Print();
  1848.     
  1849.     // or do prettyprint...
  1850.     MakeSeqPrint( false);
  1851.     fPrintDoc->PrintDoc();
  1852. }
  1853.  
  1854. Boolean DSeqDoc::IsMyTask(DTask* theTask) 
  1855. {
  1856. #if 0
  1857.     if (theTask->fKind == kSeqDoc) {
  1858.         ProcessTask( theTask);
  1859.         return true;
  1860.         }
  1861.     else 
  1862. #endif
  1863.         return DWindow::IsMyTask(theTask);
  1864. }
  1865.  
  1866. void DSeqDoc::ProcessTask(DTask* theTask) 
  1867. {
  1868.     if (theTask->fNumber == -987654) {
  1869.  
  1870.         }
  1871.     else {
  1872.         DWindow::ProcessTask(theTask);
  1873.         }
  1874. }
  1875.  
  1876.  
  1877. void DSeqDoc::SortView(DSeqList::Sorts sortorder)
  1878. {
  1879.     fSeqList->SortList(sortorder);
  1880.     fAlnView->Invalidate();
  1881.     if (fAlnIndex) fAlnIndex->Invalidate();
  1882. }
  1883.  
  1884.  
  1885. void DSeqDoc::AddSeqToList(DSequence* item)
  1886. {
  1887.     fAlnView->addToAlnList( item);
  1888.     //fAlnView->SelectCells( fAlnView->GetMaxRows()-1, fAlnView->GetMaxCols());
  1889.     if (fAlnIndex) fAlnIndex->SelectCells( fAlnView->GetMaxRows()-1, 0); 
  1890. #if 0
  1891.     this->Changed( 1, this);
  1892. #endif
  1893. }    
  1894.  
  1895.  
  1896.  
  1897. void DSeqDoc::AddNewSeqToList()
  1898. {
  1899.     DSequence* aSeq = new DSequence(); 
  1900.     AddSeqToList( aSeq);
  1901. }
  1902.  
  1903.  
  1904. void DSeqDoc::FirstSelection( DSequence*& aSeq, long& start, long& nbases)
  1905. {    
  1906.     short            left, right, top, bottom, atRow;
  1907.  
  1908.     start= nbases= atRow= 0;
  1909.     fAlnView->DeInstallEditSeq(); //?? reinstall after ?
  1910.     fAlnView->GetFirstSelectedCell(top,left);
  1911.     fAlnView->GetLastSelectedCell(bottom,right);
  1912.     
  1913.     if (left != DTableView::kNoSelection && top != DTableView::kNoSelection 
  1914.      && (left != right || top != bottom)) {
  1915.       atRow = top;
  1916.         start = left; // - 1;
  1917.         nbases= right - start;  
  1918.         }    
  1919.     else if (fAlnIndex && fAlnIndex->IsSelected()) {
  1920.         fAlnIndex->GetFirstSelectedCell(top,left);
  1921.         fAlnIndex->GetLastSelectedCell(bottom,right);
  1922.         atRow= top;
  1923.         start= 0; 
  1924.         nbases= 0; //key for all of seq
  1925.         }    
  1926.  
  1927.     aSeq= fAlnView->SeqAt( atRow);
  1928.     if (aSeq) {
  1929.         aSeq->SetIndex(atRow);
  1930.         aSeq->SetSelection( start, nbases);
  1931.         }
  1932. }
  1933.  
  1934. void DSeqDoc::AddSeqAtToList( short aRow, long start1, long nbases1, 
  1935.                                                         DSeqList*& aSeqList, long& start, long& nbases)
  1936. {
  1937.     DSequence* aSeq= fAlnView->SeqAt( aRow); 
  1938.     if (aSeq) {
  1939.         /*--- ?? default is use all when nbases==0 !?
  1940.         if (wantAll) {
  1941.             start1= 0;
  1942.             nbases1= GethandleSize(aSeq->fBases);
  1943.             }
  1944.         ---*/
  1945.         aSeq->SetIndex( aRow);
  1946.         aSeq->SetSelection( start1, nbases1);
  1947.         aSeqList->InsertLast( aSeq);
  1948.         start= Max(start,start1);
  1949.         if (nbases==0) nbases= nbases1;
  1950.         else nbases= Min(nbases,nbases1);
  1951.         }
  1952. }
  1953.  
  1954. void DSeqDoc::GetSelection(Boolean equalCount, Boolean allAtNoSelection,
  1955.                                                         DSeqList*& aSeqList, long& start, long& nbases)
  1956. {
  1957.     short            left, right, top, bottom, arow, acol;
  1958.     long            start1, nbases1;
  1959.     Boolean        wantAll;
  1960.  
  1961.     fAlnView->DeInstallEditSeq(); //?? reinstall after ?
  1962.     start= 0; start1= 0;
  1963.     nbases= 0; nbases1= 0;
  1964.     aSeqList= new DSeqList();
  1965.     fAlnView->GetFirstSelectedCell(top,left);
  1966.     fAlnView->GetLastSelectedCell(bottom,right);
  1967.     
  1968.     if (left != DTableView::kNoSelection && top != DTableView::kNoSelection 
  1969.     && (left != right || top != bottom)) {
  1970.         wantAll= false;
  1971.         for (arow= top; arow<bottom; arow++) {
  1972.             if (equalCount) acol= left; else acol= 0; 
  1973.             while (acol<right && !fAlnView->IsSelected(arow,acol)) acol++;
  1974.             start1= acol; // - 1;
  1975.             if (equalCount)
  1976.                 while (acol<right && fAlnView->IsSelected(arow,acol)) acol++;
  1977.             else 
  1978.                 while (fAlnView->IsSelected(arow,acol)) acol++;
  1979.             nbases1= acol - start1;
  1980.             AddSeqAtToList( arow, start1, nbases1, aSeqList, start, nbases);
  1981.             }
  1982.         start = left; // - 1;
  1983.         nbases= right - start;  
  1984.         }    
  1985.         
  1986.     else if (fAlnIndex && fAlnIndex->IsSelected()) {
  1987.         fAlnIndex->GetFirstSelectedCell(top,left);
  1988.         fAlnIndex->GetLastSelectedCell(bottom,right);
  1989.         wantAll= true;
  1990.         for (arow= top; arow<bottom; arow++) 
  1991.             AddSeqAtToList( arow, start1, nbases1, aSeqList, start, nbases);
  1992.         }    
  1993.     else {
  1994.         wantAll= true;
  1995.         if (allAtNoSelection) 
  1996.          for (arow= 0; arow<fAlnView->GetMaxRows(); arow++) 
  1997.             AddSeqAtToList( arow, start1, nbases1, aSeqList, start, nbases);
  1998.         }
  1999. }
  2000.             
  2001.  
  2002. short DSeqDoc::SelectionToFile(Boolean AllatNoSelection, char* aFileName, short seqFormat)  
  2003. {
  2004.     long        start, nbases;
  2005.     short        nseqs;
  2006.     DSeqList *aSeqList;
  2007.  
  2008.     GetSelection( FALSE, AllatNoSelection, aSeqList, start, nbases);
  2009.     nseqs= aSeqList->GetSize();
  2010.     aSeqList->DoWrite( aFileName, seqFormat); 
  2011.     delete aSeqList;
  2012.     return nseqs;
  2013. }
  2014.  
  2015.  
  2016.  
  2017.  
  2018. void DSeqDoc::WriteTo(DFile* aFile)  
  2019. {
  2020.     short outformat= DSeqFile::kGenBank;
  2021.     if (fFormatPop) outformat= fFormatPop->GetValue(); 
  2022.     fAlnView->DeInstallEditSeq(); //?? reinstall after ?
  2023.     if (fSaveSelection) {
  2024.         long        start, nbases;
  2025.         DSeqList* aSeqList= NULL;
  2026.         fSaveSelection= false;
  2027.         GetSelection( FALSE, true, aSeqList, start, nbases);
  2028.         aSeqList->DoWrite( aFile, outformat);
  2029.         delete aSeqList;
  2030.         }    
  2031.     else {
  2032.         fSeqList->ClearSelections(); //! make sure we write all of seq from this call !?
  2033.         fSeqList->DoWrite( aFile, outformat);
  2034.         this->NotDirty();  
  2035.         }
  2036. }
  2037.  
  2038.  
  2039.  
  2040.  
  2041.  
  2042. #ifdef FIX_LATER
  2043. /***********
  2044. void DSeqDoc::AboutToSaveFile(TFile theSaveFile, CommandNumber itsCmd, 
  2045.                                                             Boolean VAR makingCopy) // override 
  2046. VAR
  2047.         Boolean        needSameSize, sizesDiffer, isInterleaved;
  2048.         integer        nseqs, err, format ;
  2049.         longint        minbases;
  2050.         Handle        aHand;
  2051.         
  2052.     void checkEqualSize( DSequence aSeq)
  2053.     longint        var  start, nbases;
  2054.     {
  2055.         //aSeq->GetSelection( start, nbases); << can still be set from fSelection or other old selecting command 
  2056.         nBases= aSeq->fLength; 
  2057.         if (minbases<0) then minbases= nbases
  2058.         else begin
  2059.             if (nbases!=minbases) then sizesDiffer= true;
  2060.             //- minbases= min( nbases, minbases); 
  2061.             end();
  2062.     }
  2063.  
  2064. {
  2065.     inherited::AboutToSaveFile(theSaveFile, itsCmd, makingCopy);
  2066.     
  2067.     if ((!fSaveSelection)) { 
  2068.                     //^^^^ !???? TAlnDoc will set this, always equal #bases????
  2069.         if (fFormatPop == NULL) format= kGenBank
  2070.         else format= fFormatPop->GetCurrentItem(); 
  2071.         needSameSize= false;
  2072.         isInterleaved= false;
  2073.         sizesDiffer= false;
  2074.         minbases= -1; 
  2075.         nseqs= fSeqList->GetSize();
  2076.         
  2077.         if (nseqs>1)) // deal w/ one-per-file formats 
  2078.             switch (format) {
  2079.                 kGCG        : format= kMSF;
  2080.                 kStrider: format= kIG;
  2081.                 kNoformat, kPlain, kUnknown: format= kGenbank;
  2082.                 }
  2083.             
  2084.         fSeqList->ClearSelections(); //! make sure we write all of seq from this call !?
  2085.         fSeqList->Each( checkEqualSize);    
  2086.     
  2087.         aHand= NewHandle(0);
  2088.         WriteSeqHeader( longint(aHand), TRUE, format, nseqs, minbases, gOutputName, 
  2089.                     needSameSize, isInterleaved); //<< need write for last two results 
  2090.         aHand= DisposeIfHandle(aHand);
  2091.         
  2092.         if (((needSameSize || isInterleaved) && sizesDiffer)) {
  2093.             ParamText('all sequences must have same # bases for this format',
  2094.                     ' Pick another format like Genbank or change selection.',
  2095.                     'WriteSeq','');    
  2096.             Failure( -1, msgMyError);  
  2097.             }
  2098.         }
  2099. }
  2100. **********/
  2101. #endif
  2102.  
  2103.  
  2104. Boolean DSeqDoc::ReadFrom(DFile* aFile, Boolean append)    // revise for iostreams
  2105. {
  2106.     if (!append) FreeData();   //?? or leave here for append...
  2107.     gDefSeqName= this->GetTitle(gDefSeqNameStore,sizeof(gDefSeqNameStore));
  2108.     fInFormat= DSeqFile::ReadSeqFile(aFile, fSeqList);  
  2109.     return true; //?? (fInFormat != DSeqFile::kUnknown)
  2110. }
  2111.  
  2112.  
  2113.  
  2114. #if 0
  2115. void DSeqDoc::Close() // override 
  2116. //must make sure all windows owned by ListDoc are closed 1st
  2117.  
  2118.     procedure closeSubwindows(TWindow aWind)
  2119.     begin
  2120.       // this is a subwindow !may not be owned by this  doc
  2121.         if (!aWind->fClosesDocument) aWind->CloseAndFree();
  2122.     end();
  2123.     
  2124. {
  2125.     ForAllWindowsDo(closeSubwindows);
  2126.     inherited::Close();
  2127. }
  2128.  
  2129. #endif
  2130.  
  2131.  
  2132.  
  2133. void DSeqDoc::OpenSeqedWindow(DSequence* aSeq)
  2134. {
  2135.     char* title= StrDup( aSeq->Name());
  2136.     StrExtendCat( &title, " Edit");
  2137.     DSeqedWindow* edwin = new DSeqedWindow( DSeqedWindow::kId, gApplication, 
  2138.                                                 this, aSeq, -5, -5, -50, -20, title);
  2139.     MemFree( title);
  2140.     edwin->Open(); 
  2141.     edwin->Select();     
  2142. }
  2143.  
  2144.  
  2145.  
  2146. void DSeqDoc::EditSeqs() 
  2147. {
  2148.     DSequence* aSeq= fAlnView->SelectedSequence();  
  2149.     if (aSeq) this->OpenSeqedWindow(aSeq);
  2150.                 
  2151. #if 0
  2152.     aCell    : GridCell;
  2153.     count    : integer;
  2154.     
  2155.     pascal void newEditWindow( integer anItem)
  2156.     TSequence        VAR aSeq;
  2157.     {
  2158.         aSeq= TSequence(this->fSeqList->At(anItem));
  2159.         if ((aSeq!=NULL) && (count<kMaxOpenSeqed)) {
  2160.             this->OpenSeqedWindow(aSeq);
  2161.             count= count+1;
  2162.             }
  2163.   }
  2164.     
  2165.  
  2166.     if ((fAlnIndex=NULL) || (fAlnIndex.firstSelectedItem == 0)) 
  2167.             //nada
  2168.             
  2169.     else if (editOnly 
  2170.         || (fAlnIndex.FirstSelectedItem == fAlnIndex->LastSelectedItem())) {
  2171.         count= 0;
  2172.         fAlnIndex->EachSelectedItemDo( newEditWindow);
  2173.         }
  2174. #endif        
  2175. }
  2176.  
  2177.  
  2178.  
  2179.  
  2180. void DSeqDoc::ToTextDoc()
  2181. {
  2182. #if 1
  2183.     DTempFile* tmpFile= new DTempFile();
  2184.     this->WriteTo(tmpFile);
  2185.     DRichTextDoc* doc= new DRichTextDoc(0,  true, gTextFont);
  2186.     doc->Open(tmpFile);
  2187.     delete tmpFile;
  2188. #else
  2189.     Nlm_ParData paratabs = {false, false, false, false, true, 0, 0}; // tabs==tabs        
  2190.     char    *txt     = NULL;
  2191.     Nlm_ColData*    cols= NULL;
  2192.     Nlm_ParData*    para= ¶tabs;
  2193.  
  2194.     ulong txtsize = 0;
  2195.     DTempFile* tmpFile= new DTempFile();
  2196.     this->WriteTo(tmpFile);
  2197.     txt= tmpFile->ReadIntoMemory(txtsize);
  2198.     delete tmpFile;
  2199.     
  2200.     if (txt) {
  2201.         char name[256];
  2202.         StrCpy(name,"Text of ");
  2203.         long len= StrLen(name);
  2204.         //char *namep= name + len;
  2205.         (void) this->GetTitle( name + len, 256 - len);
  2206.         DWindow* aWin= new DWindow( 0, gApplication, document, -1, -1, -10, -10, name);
  2207.         DTextDocPanel* aDoc= new DTextDocPanel( 0, aWin, 500, 300);
  2208.         aDoc->SetResize( DView::matchsuper, DView::relsuper);
  2209.         aDoc->SetSlateBorder( false);
  2210.         aDoc->SetTabs( gTextTabStops);
  2211.         aDoc->Append( txt, para, cols, gTextFont);
  2212.         aWin->Open();  
  2213.         aDoc->SizeToSuperview( aWin, true, false);
  2214.         }
  2215. #endif
  2216. }
  2217.  
  2218.  
  2219. void DSeqDoc::MakeSeqPrint(Boolean doREMap)
  2220. {
  2221.     long        firstbase, nbases;
  2222.     DSeqList* aSeqList= NULL;
  2223.     fSaveSelection= false;
  2224.     DWindow    * aDoc;
  2225.     
  2226.     GetSelection( true, true, aSeqList, firstbase, nbases);
  2227.     if (!aSeqList)
  2228.         return;
  2229.     else if (doREMap) {
  2230.         aDoc = new DREMapPrintDoc( DSeqPrintDoc::kSeqPrintDoc, this, aSeqList, firstbase, nbases);
  2231.         aDoc->Open();  
  2232.         }
  2233.     else if (aSeqList->GetSize() > 1) {
  2234.         aDoc = new DAlnPrintDoc( DSeqPrintDoc::kSeqPrintDoc, this, aSeqList, firstbase, nbases);
  2235.         aDoc->Open();  
  2236.         }        
  2237.     else {
  2238.         aDoc = new DSeqPrintDoc( DSeqPrintDoc::kSeqPrintDoc, this, aSeqList, firstbase, nbases);
  2239.         aDoc->Open();  
  2240.         }
  2241.     fPrintDoc= aDoc;
  2242. }
  2243.  
  2244. void DSeqDoc::MakeAlnPrint()
  2245. {
  2246.     MakeSeqPrint(false);
  2247. }
  2248.  
  2249.  
  2250.  
  2251. void DSeqDoc::SetUpMenu(short menuId, DMenu*& aMenu) 
  2252. {
  2253.     //DWindow::SetUpMenu(menuId, aMenu);
  2254.  
  2255.     if (menuId == kSeqMenu) {
  2256.         if (!aMenu) aMenu = gApplication->NewMenu( menuId, "Sequence");
  2257.         //aMenu->AddItem( cSeqPrefs, "Seq Prefs...");    
  2258.     
  2259.         aMenu->AddItem( cNewSeq, "New sequence");
  2260.         aMenu->AddItem( cEditSeq, "Edit seq...");
  2261.      
  2262.         DMenu* vMenu= new DSubMenu( kViewKindMenu, aMenu, "View seqs");
  2263.         vMenu->AddItem( kViewByDefault, "default");
  2264.         vMenu->AddItem( kViewByDate, "by Date");
  2265.         vMenu->AddItem( kViewBySize, "by Size");
  2266.         vMenu->AddItem( kViewByName, "by Name");
  2267.         vMenu->AddItem( kViewByKind, "by Kind");
  2268.         vMenu->AddItem( kViewAsText, "as Text");
  2269.  
  2270.         DMenu* mMenu= new DSubMenu( kSeqMaskMenu, aMenu, "Seq masks");
  2271.         mMenu->AddItem(cMaskSelAll,"Select all",false, true);
  2272.         mMenu->AddItem(cMaskInvert,"Invert selection",false, true);
  2273.         mMenu->AddItem(cMaskClear,"Clear selection",false, true);
  2274.         mMenu->AddSeparator();
  2275.         mMenu->AddItem(cMaskSelCommon,"Select consensus",false, true);
  2276.         //gViewCentral->DisableView(cMaskSelCommon);
  2277.         mMenu->AddItem(cMaskSelORF,"Select ORFs",false, true);
  2278.         //gViewCentral->DisableView(cMaskSelORF);
  2279.  
  2280.         aMenu->AddSeparator();
  2281.         aMenu->AddItem( cRevSeq, "Reverse");
  2282.         aMenu->AddItem( cCompSeq, "Complement");
  2283.         aMenu->AddItem( cRevCompSeq, "Rev-Compl");
  2284.         aMenu->AddItem( cDna2Rna, "Dna->Rna");
  2285.         aMenu->AddItem( cRna2Dna, "Rna->Dna");
  2286.         aMenu->AddItem( cToUpper, "UPPER Case");
  2287.         aMenu->AddItem( cToLower, "lower Case");
  2288.  
  2289.         aMenu->AddItem( cDegap, "Degap");
  2290.         aMenu->AddItem( cLockIndels, "Lock indels");
  2291.         aMenu->AddItem( cUnlockIndels, "Unlock indels");
  2292.         aMenu->AddItem( cConsensus, "Consensus");
  2293.         aMenu->AddItem( cTranslate, "Translate");
  2294.  
  2295.         aMenu->AddSeparator();
  2296.         aMenu->AddItem( cPrettyPrint, "Pretty Print...");
  2297.         aMenu->AddItem( cREMap, "Restriction map...");
  2298.         aMenu->AddItem( cDotPlot, "Dot plot...");
  2299.         gViewCentral->DisableView(cDotPlot);
  2300.  
  2301.         aMenu->AddSeparator();        
  2302.         aMenu->AddItem( cNAcodes, "Nucleic codes...");
  2303.         aMenu->AddItem( cAAcodes, "Amino codes...");
  2304.          }
  2305.      
  2306.     else if (menuId == DApplication::cEditMenu) {
  2307.         aMenu->AddSeparator();
  2308.         aMenu->AddItem(DApplication::kFind,"Find.../F",false, true);
  2309.         aMenu->AddItem(DApplication::kFindAgain,"Find again/G",false, true);
  2310.         aMenu->AddItem(cFindORF,"Find ORF/R",false, true);
  2311.  
  2312.         }
  2313.         
  2314.      else if (menuId == kInternetMenu) {
  2315.         if (!aMenu) aMenu = gApplication->NewMenu( menuId, "Internet");
  2316.         aMenu->AddItem( cNCBIfetch, "NCBI fetch...");
  2317.         aMenu->AddItem( cNCBIblast, "NCBI BLAST search...");
  2318.         aMenu->AddItem( cEMBLfetch, "EMBL fetch...");
  2319.         aMenu->AddItem( cEMBLquicks, "EMBL Quicksearch...");
  2320.         aMenu->AddItem( cEMBLfasta, "EMBL FastA search...");
  2321.         aMenu->AddItem( cEMBLblitz, "EMBL Blitz search...");
  2322.         aMenu->AddItem( cFHCRCfetch, "FHCRC fetch...");
  2323.         aMenu->AddItem( cFHCRCblocks, "FHCRC Blocks search...");
  2324.         aMenu->AddItem( cGeneidSearch, "Geneid search...");
  2325.         aMenu->AddItem( cGrailSearch, "Grail search...");
  2326.         //aMenu->AddItem( cGenmarkSearch, "Genmark search...");
  2327.         //aMenu->AddItem( cPythiaSearch, "Pythia search...");
  2328.          aMenu->AddSeparator();    
  2329.          }                            
  2330.  
  2331. }
  2332.  
  2333.  
  2334.  
  2335. #if 0
  2336. char* DSeqDoc::GetTitle(char* title, ulong maxsize) 
  2337. { 
  2338.     if (title==NULL) title= (char*) MemNew(maxsize);  
  2339. kUntitled
  2340.     Nlm_GetTitle( fNlmObject, title, maxsize);
  2341.     return title;
  2342. }
  2343. #endif
  2344.  
  2345.  
  2346. char* DSeqDoc::GetTitle(char* title, ulong maxsize) 
  2347. { 
  2348.     if (fSaveSelection) {
  2349.         if (title==NULL) title= (char*) MemNew(maxsize); 
  2350.         DWindow::GetTitle( title, maxsize); 
  2351. #ifdef OS_DOS
  2352.         DFileManager::ReplaceSuffix( title, maxsize, ".sel");
  2353. #else
  2354.         StrNCat( title,".part", maxsize); 
  2355. #endif
  2356.         return title;
  2357.         }
  2358.     else if (fDocTitle && *fDocTitle) {
  2359.         if (title==NULL) {
  2360.             maxsize= Min(maxsize,StrLen(fDocTitle)+1);
  2361.             title= (char*) MemNew(maxsize); 
  2362.             }
  2363.         StrNCpy(title,fDocTitle,maxsize);
  2364.         return title;
  2365.         }
  2366.     else {
  2367.         DWindow::GetTitle( title, maxsize);
  2368.         //if (StringCmp(title,kUntitled)==0) *title= 0; // set to null so saveas is called
  2369.         return title;
  2370.         }
  2371. }
  2372.  
  2373. void DSeqDoc::FindORF()
  2374. {
  2375.     long    start, stop;
  2376.     DSequence* aSeq;
  2377.     short            selrow;
  2378.     Nlm_RecT    selr;
  2379.     
  2380.     aSeq= fAlnView->SelectedSequence(selrow);
  2381.     if (aSeq) {
  2382.         selr= fAlnView->GetSelRect();
  2383.         if (selr.right > selr.left+1) selr.left++; // !? offset sel start so we can repeat call
  2384.         selr.top= selrow;
  2385.         selr.bottom= selrow+1; 
  2386.         aSeq->SetSelection( selr.left, 0);
  2387.         aSeq->SearchORF( start, stop);
  2388.         if (start>=0) {
  2389.             if (stop<start) stop= aSeq->LengthF(); //??
  2390.             aSeq->SetSelection( start, stop - start);
  2391.             selr.left= start;
  2392.             selr.right= stop;
  2393.             fAlnView->SelectCells( selr);
  2394.             }
  2395.         } 
  2396. }
  2397.  
  2398.  
  2399. void DSeqDoc::MakeConsensus()
  2400. {
  2401.     long    firstBase = 0, nBases = 0;
  2402.     DSeqList * aSeqList= NULL;
  2403.     DSequence* cons;
  2404.     
  2405.     GetSelection( true, true, aSeqList, firstBase, nBases);
  2406.     if (aSeqList) {
  2407.         cons= fSeqList->Consensus();
  2408.         if (cons) {
  2409.             short aRow, totalRows;
  2410.             Nlm_RecT    r;
  2411.             aRow= fSeqList->GetIdentityItemNo( cons);
  2412.             totalRows= fSeqList->GetSize();
  2413.             fSeqList->Delete(cons);
  2414.             delete cons;
  2415.             fAlnView->GetRowRect( aRow, r, totalRows-aRow+1);
  2416.             fAlnView->InvalRect( r);
  2417.             if (fAlnIndex) {
  2418.                 fAlnIndex->GetRowRect( aRow, r, totalRows-aRow+1);
  2419.                 fAlnIndex->InvalRect( r);
  2420.                 }
  2421.             fAlnView->UpdateSize();   
  2422.             }
  2423.             
  2424.         aSeqList->MakeConsensus();
  2425.         cons= aSeqList->Consensus();
  2426.         if (cons) {
  2427.             AddSeqToList( cons);
  2428.             //if (fAlnIndex) fAlnIndex->SelectCells( fSeqList->ConsensusRow(), 0); 
  2429.             //fAlnIndex->ScrollSelectionIntoView(TRUE);
  2430.             }
  2431.         delete aSeqList;
  2432.         }
  2433. }
  2434.  
  2435.  
  2436. #if NETBLAST
  2437. extern "C" short CallNCBIBlastService( char* blastProgram, char* blastDatabase, char* blastOptions, 
  2438.                                                      char* fastaInputFile, char* outputFile );
  2439.  
  2440. void DSeqDoc::BLASTdialog()
  2441. {
  2442.     char* blastProgram = "blastn";
  2443.     char* blastDatabase = "nr";
  2444.     char* blastOptions = NULL;
  2445.     char* fastaInputFile = "spup-blast-input.fasta";
  2446.     char* outputFile = "spup-blast-result.text";
  2447.     char    instore[128];
  2448.     char  outstore[128];
  2449.     DFile aFile;
  2450.             
  2451.     fastaInputFile= DFileManager::TempFilename( instore);
  2452.     outputFile= DFileManager::TempFilename( outstore);
  2453.  
  2454.     short nseq= SelectionToFile( false, fastaInputFile, DSeqFile::kPearson);
  2455.     if (nseq) {
  2456.         short err= CallNCBIBlastService(blastProgram, blastDatabase, blastOptions, 
  2457.                                                 fastaInputFile, outputFile);
  2458.  
  2459.         if (err) {
  2460.             Message(MSG_OK,"DSeqDoc::CallNCBIBlastService error %d", err);
  2461.             }
  2462.         else {
  2463.             DRichTextDoc* doc= new DRichTextDoc(0,  true, gTextFont);
  2464.             doc->Open(outputFile);
  2465.             aFile.Initialize(outputFile);
  2466.             aFile.Delete();
  2467.             }
  2468.          }
  2469.     aFile.Initialize(fastaInputFile);
  2470.     aFile.Delete();
  2471. }
  2472. #endif
  2473.  
  2474.  
  2475. Boolean DSeqDoc::DoMenuTask(long tasknum, DTask* theTask)
  2476. {
  2477.     DWindow* win = NULL;
  2478.     
  2479.     switch (tasknum) {
  2480.     
  2481.         case cNewSeq        : 
  2482.             AddNewSeqToList(); 
  2483.             //fall into EditSeqs
  2484.         case cEditSeq: 
  2485.             EditSeqs(); 
  2486.             return true;
  2487.  
  2488.         case cSaveSel:
  2489.             fSaveSelection= true;
  2490.             gApplication->DoMenuTask( DApplication::kSaveAs, NULL);
  2491.             fSaveSelection= false;
  2492.             return true;
  2493.  
  2494.         case cFindORF: 
  2495.             FindORF();
  2496.             return true;
  2497.             
  2498.         case cConsensus:
  2499.             MakeConsensus();
  2500.             return true;
  2501.                     
  2502.         case cRevSeq:
  2503.         case cCompSeq:
  2504.         case cRevCompSeq:
  2505.         case cDna2Rna: 
  2506.         case cRna2Dna:
  2507.         case cToUpper: 
  2508.         case cToLower:
  2509.         case cDegap:
  2510.         case cLockIndels:
  2511.         case cUnlockIndels:
  2512.         case cTranslate:
  2513.             {
  2514.             long    firstBase = 0, nBases = 0;
  2515.             DSeqList * aSeqList= NULL;
  2516.             DSeqChangeCmd *    cmd = NULL;  
  2517.             
  2518.             //fAlnView->DeInstallEditSeq(); //?? reinstall after ?
  2519.             GetSelection( TRUE, TRUE, aSeqList, firstBase, nBases);
  2520.             switch (tasknum) {
  2521.               case cRevSeq        : cmd= new DSeqReverseCmd( this, fAlnView, aSeqList);  break;
  2522.                 case cCompSeq        : cmd= new DSeqComplementCmd( this, fAlnView,aSeqList); break;
  2523.                 case cRevCompSeq: cmd= new DSeqRevComplCmd( this, fAlnView,aSeqList); break;
  2524.                 case cDna2Rna        : cmd= new DSeqDna2RnaCmd( this, fAlnView,aSeqList); break;
  2525.                 case cRna2Dna        :    cmd= new DSeqRna2DnaCmd( this, fAlnView,aSeqList); break;
  2526.                 case cToUpper        :    cmd= new DSeqUppercaseCmd( this, fAlnView,aSeqList); break;
  2527.                 case cToLower        :    cmd= new DSeqLowercaseCmd( this,fAlnView, aSeqList); break;
  2528.                 case cDegap            :    cmd= new DSeqCompressCmd( this, fAlnView,aSeqList); break;
  2529.                 case cLockIndels:    cmd= new DSeqLockIndelsCmd( this, fAlnView,aSeqList); break;
  2530.                 case cUnlockIndels: cmd= new DSeqUnlockIndelsCmd( this, fAlnView,aSeqList); break;
  2531.                 case cTranslate    :    cmd= new DSeqTranslateCmd( this, fAlnView,aSeqList); break;
  2532.  
  2533.                 default:
  2534.                     delete aSeqList;
  2535.                     Message(MSG_OK,"DSeqDoc::method not ready.");
  2536.                     return true;
  2537.                 
  2538.               }
  2539.           if (cmd) {
  2540.               if (cmd->Initialize()) PostTask( cmd);
  2541.               else {
  2542.                   delete cmd;
  2543.                   Message(MSG_OK,"DSeqDoc::method failed.");
  2544.                     }
  2545.               }
  2546.             return true;    
  2547.             }
  2548.  
  2549.         case cPrettyPrint:  MakeSeqPrint( false); return true; //MakeAlnPrint();
  2550.         case cREMap:                MakeSeqPrint( true); return true;
  2551.         case cNAcodes:            NucCodesPicture(); return true;
  2552.         case cAAcodes:            AminoCodesPicture(); return true;
  2553.         case cDotPlot:            //MakeDottyPlot(); return true;
  2554.             Message(MSG_OK,"DSeqDoc::method not ready.");
  2555.             return true;
  2556.  
  2557. #if NETBLAST
  2558.         case cNCBIblast:
  2559.             {
  2560.             char* blastProgram = "blastn";
  2561.             char* blastDatabase = "nr";
  2562.             char* blastOptions = NULL;
  2563.             char* fastaInputFile = "spup-blast-input.fasta";
  2564.             char* outputFile = "spup-blast-result.text";
  2565.             char    instore[128];
  2566.             char  outstore[128];
  2567.             DFile aFile;
  2568.             
  2569.             fastaInputFile= DFileManager::TempFilename( instore);
  2570.             outputFile= DFileManager::TempFilename( outstore);
  2571.  
  2572.             short nseq= SelectionToFile( false, fastaInputFile, DSeqFile::kPearson);
  2573.             if (nseq) {
  2574.                 short err= CallNCBIBlastService(blastProgram, blastDatabase, blastOptions, 
  2575.                                                         fastaInputFile, outputFile);
  2576.  
  2577.                 if (err) {
  2578.                     Message(MSG_OK,"DSeqDoc::CallNCBIBlastService error %d", err);
  2579.                     }
  2580.                 else {
  2581.                     DRichTextDoc* doc= new DRichTextDoc(0,  true, gTextFont);
  2582.                     doc->Open(outputFile);
  2583.                     aFile.Initialize(outputFile);
  2584.                     aFile.Delete();
  2585.                     }
  2586.                  }
  2587.             aFile.Initialize(fastaInputFile);
  2588.             aFile.Delete();
  2589.             }
  2590.             return true;
  2591.             
  2592. #else        
  2593.         case cNCBIblast:
  2594. #endif
  2595.     
  2596.         case cGrailSearch:
  2597.         case cGeneidSearch:
  2598.       case cFHCRCblocks:
  2599.       case cEMBLfasta:
  2600.       case cEMBLblitz:
  2601.       case cEMBLquicks:
  2602.             {
  2603.             DSequence* aSeq= fAlnView->SelectedSequence();
  2604.             if (aSeq) {
  2605.                 switch (tasknum) {
  2606.                     case cNCBIblast: win= new DNCBIBlast(0, this, aSeq); break;
  2607.                      case cEMBLblitz: win= new DEMBLBlitz(0, this, aSeq); break;
  2608.                      case cEMBLfasta: win= new DEMBLFasta(0, this, aSeq); break;
  2609.                      case cEMBLquicks: win= new DEMBLQuicks(0, this, aSeq); break;
  2610.                      case cFHCRCblocks: win= new DFHCRCblocks(0, this, aSeq); break;
  2611.                      case cGeneidSearch: win= new DUWFGeneID(0, this, aSeq); break;
  2612.                      case cGrailSearch: win= new DORNLGrail(0, this, aSeq); break;
  2613.                     }
  2614.                 if (win) win->Open();
  2615.                 }
  2616.             return true;
  2617.             }
  2618.  
  2619.       case cFHCRCfetch:
  2620.         case cEMBLfetch:
  2621.         case cNCBIfetch:
  2622.             switch (tasknum) {
  2623.                 case cNCBIfetch: win= new DNCBIFetch(0, this); break;
  2624.                  case cEMBLfetch: win= new DEMBLFetch(0, this); break;
  2625.                  case cFHCRCfetch: win= new DFHCRCfetch(0, this); break;
  2626.                 }
  2627.             if (win) win->Open();
  2628.             return true;
  2629.                         
  2630.         case cGenmarkSearch:
  2631.         case cPythiaSearch:
  2632.             Message(MSG_OK,"DSeqDoc::method not ready.");
  2633.             return true;
  2634.  
  2635.  
  2636.         default: 
  2637.             return DTaskMaster::DoMenuTask(tasknum, theTask);
  2638.         }
  2639.  
  2640. }
  2641.  
  2642.  
  2643. Boolean DSeqDoc::IsMyAction(DTaskMaster* action) 
  2644. {
  2645.     long  menuid= 0, menuitem = action->Id();
  2646.     if (action->fSuperior) menuid = action->fSuperior->Id();
  2647.     
  2648.     //if (menuid == DApplication::cEditMenu)  
  2649.     switch (menuitem) {
  2650.     
  2651.         case DApplication::kCut:
  2652.         case DApplication::kCopy:
  2653.         case DApplication::kClear:
  2654.           {
  2655.             DAlnEditCommand* cmd= new DAlnEditCommand(this, menuitem);
  2656.             PostTask( cmd);
  2657.             return true;            
  2658.             }
  2659.         
  2660.         case DApplication::kPaste:
  2661.             {
  2662.           DView* clipview= (DView*) gClipboardMgr->fClipView; // GetClipView();
  2663.             if (clipview && clipview->fKind == DAlnView::kindAlnView) {
  2664.                 DAlnPasteCommand* cmd= new DAlnPasteCommand(this);
  2665.                 PostTask( cmd);
  2666.                 return true;            
  2667.                 }
  2668.             else if (HasEditText()) {  /* && clipview->fKind == OStype("TEXT") */
  2669.                 if (fEditText->IsMyAction(action)) return true;
  2670.                 }
  2671.             return true; //?? always handle this message?
  2672.             }
  2673.             
  2674.         case DApplication::kSelectAll:
  2675.             if (fAlnIndex) {
  2676.             Nlm_RecT r;
  2677.             Nlm_LoadRect(& r, 0, 0, 1/*fAlnIndex->GetMaxCols()*/, fAlnIndex->GetMaxRows());
  2678.             fAlnIndex->SelectCells( r);
  2679.             return true;            
  2680.             }
  2681.  
  2682.         }
  2683.  
  2684.         
  2685.     if (menuid == kViewKindMenu)  
  2686.      switch (menuitem) {
  2687.             case kViewByDefault:
  2688.                     this->SortView(DSeqList::kSortByItem); return true;
  2689.             case kViewByDate:
  2690.                     this->SortView(DSeqList::kSortByDate); return true;
  2691.             case kViewBySize:
  2692.                     this->SortView(DSeqList::kSortBySize); return true;
  2693.             case kViewByName:
  2694.                     this->SortView(DSeqList::kSortByName); return true;
  2695.             case kViewByKind:
  2696.                     this->SortView(DSeqList::kSortByKind); return true;
  2697.             case kViewAsText:
  2698.                     this->ToTextDoc(); return true;
  2699.             default: return true;
  2700.             }
  2701.  
  2702. #if MASKS         
  2703.     else if (menuid == kSeqMaskMenu && fAlnView->fMaskLevel>0)  {
  2704.         long iseq, nseq= fSeqList->GetSize();
  2705.          switch (menuitem) {
  2706.          
  2707.             case cMaskSelCommon:
  2708.                 fAlnView->HiliteCommonBases();
  2709.                 return true;
  2710.                 
  2711.             case cMaskSelORF:
  2712.                 fAlnView->HiliteORFs();
  2713.                 return true;
  2714.                 
  2715.             case cMaskSelAll:
  2716.                 for (iseq= 0; iseq<nseq; iseq++) 
  2717.                     fSeqList->SeqAt(iseq)->SetMask(fAlnView->fMaskLevel);
  2718.                 fAlnView->Invalidate();
  2719.                 return true;
  2720.                 
  2721.             case cMaskInvert:
  2722.                 for (iseq= 0; iseq<nseq; iseq++) 
  2723.                     fSeqList->SeqAt(iseq)->FlipMask(fAlnView->fMaskLevel);
  2724.                 fAlnView->Invalidate();
  2725.                 return true;
  2726.                 
  2727.             case cMaskClear:
  2728.                 for (iseq= 0; iseq<nseq; iseq++) 
  2729.                     fSeqList->SeqAt(iseq)->ClearMask(fAlnView->fMaskLevel);
  2730.                 fAlnView->Invalidate();
  2731.                 return true;
  2732.                 
  2733.             default: 
  2734.                 return true;
  2735.             }
  2736.         }
  2737. #endif
  2738.  
  2739.  
  2740.     else if (menuid == DSeqApps::kChildMenu) 
  2741.         switch (menuitem) {
  2742. #if 0
  2743.             case cAddChildCmd:
  2744.             case cRemoveChildCmd:  
  2745.                 DoMenuTask(menuitem);
  2746.                 break;
  2747. #endif    
  2748.             default:
  2749.                 {
  2750.                 long    firstBase = 0, nBases = 0;
  2751.                 DSeqList * aSeqList= NULL;
  2752.                 //fAlnView->DeInstallEditSeq(); //?? reinstall after ?
  2753.                 GetSelection( TRUE, TRUE, aSeqList, firstBase, nBases);
  2754.                 DSeqApps::CallChildApp( menuitem, aSeqList);
  2755.                 if (aSeqList) delete aSeqList;
  2756.                 }
  2757.                 break;
  2758.             }
  2759.                 
  2760.     else if (menuitem == kColorButHit) {
  2761.         fUseColor= ((DView*)action)->GetStatus();
  2762.         fAlnView->Invalidate();
  2763.       return true;
  2764.       }
  2765.     else if (menuitem == kLockButHit) {
  2766.         fAlnView->SetTextLock( ((DView*)action)->GetStatus());
  2767.       return true;
  2768.       }
  2769.  
  2770. #if MASKS
  2771.     else if (menuitem == kModePopup) {
  2772.         short mode= fModePop->GetValue();  
  2773. #if 1
  2774.         fAlnView->SetViewMode( mode);
  2775. #else
  2776.         switch (mode) {
  2777.             case DAlnView::kModeSlide: 
  2778.                 fAlnView->SetTextLock( true);
  2779.                 if (fAlnView->fMaskLevel>0) fAlnView->Invalidate();
  2780.                 fAlnView->fMaskLevel= 0; 
  2781.                 break;
  2782.             case DAlnView::kModeEdit:  
  2783.                 fAlnView->SetTextLock( false);
  2784.                 if (fAlnView->fMaskLevel>0) fAlnView->Invalidate();
  2785.                 fAlnView->fMaskLevel= 0; 
  2786.                 break;
  2787.             case DAlnView::kModeMask1: 
  2788.             case DAlnView::kModeMask2: 
  2789.             case DAlnView::kModeMask3: 
  2790.             case DAlnView::kModeMask4: {
  2791.                 fAlnView->SetTextLock( true);
  2792.                 fAlnView->fMaskLevel= mode - DAlnView::kModeMask1 + 1; 
  2793.                 fAlnView->Invalidate();
  2794.                 short i, nseq= fSeqList->GetSize();
  2795.                 for (i=0; i<nseq; i++) fSeqList->SeqAt(i)->FixMasks();
  2796.                 }
  2797.                 break;
  2798.             }
  2799. #endif
  2800.       return true;
  2801.       }
  2802. #endif
  2803.     
  2804.     else 
  2805.         return DoMenuTask(menuitem, NULL);
  2806.         
  2807.     return false;
  2808. }
  2809.             
  2810.  
  2811.  
  2812.  
  2813.