开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 生物技术 > 查看源码
sequence_display.cpp
资源名称：ncbi_cxx_win--Jul_08_2004.zip　[点击查看]
上传用户：yhdzpy8989
上传日期：2007-06-13
资源大小：13604k
文件大小：55k
源码类别：

生物技术

开发平台：

C/C++

sequence_display.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: sequence_display.cpp,v $
  4.  * PRODUCTION Revision 1000.3  2004/06/01 18:29:04  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.73
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: sequence_display.cpp,v 1000.3 2004/06/01 18:29:04 gouriano Exp $
  11. * ===========================================================================
  12. *
  13. *                            PUBLIC DOMAIN NOTICE
  14. *               National Center for Biotechnology Information
  15. *
  16. *  This software/database is a "United States Government Work" under the
  17. *  terms of the United States Copyright Act.  It was written as part of
  18. *  the author's official duties as a United States Government employee and
  19. *  thus cannot be copyrighted.  This software/database is freely available
  20. *  to the public for use. The National Library of Medicine and the U.S.
  21. *  Government have not placed any restriction on its use or reproduction.
  22. *
  23. *  Although all reasonable efforts have been taken to ensure the accuracy
  24. *  and reliability of the software and data, the NLM and the U.S.
  25. *  Government do not and cannot warrant the performance or results that
  26. *  may be obtained by using this software or data. The NLM and the U.S.
  27. *  Government disclaim all warranties, express or implied, including
  28. *  warranties of performance, merchantability or fitness for any particular
  29. *  purpose.
  30. *
  31. *  Please cite the author in any work or product based on this material.
  32. *
  33. * ===========================================================================
  34. *
  35. * Authors:  Paul Thiessen
  36. *
  37. * File Description:
  38. *      Classes to hold rows in a sequence/alignment display
  39. *
  40. * ===========================================================================
  41. */
  43. #ifdef _MSC_VER
  44. #pragma warning(disable:4018)   // disable signed/unsigned mismatch warning in MSVC
  45. #endif
  47. #include <ncbi_pch.hpp>
  48. #include <corelib/ncbistd.hpp>
  49. #include <corelib/ncbistl.hpp>
  50. #include <corelib/ncbistre.hpp>
  51. #include <corelib/ncbi_limits.h>
  53. #include <algorithm>
  55. #include "sequence_display.hpp"
  56. #include "viewer_window_base.hpp"
  57. #include "viewer_base.hpp"
  58. #include "molecule.hpp"
  59. #include "messenger.hpp"
  60. #include "structure_set.hpp"
  61. #include "style_manager.hpp"
  62. #include "sequence_viewer_window.hpp"
  63. #include "sequence_viewer.hpp"
  64. #include "alignment_manager.hpp"
  65. #include "cn3d_colors.hpp"
  66. #include "update_viewer.hpp"
  67. #include "update_viewer_window.hpp"
  68. #include "cn3d_tools.hpp"
  69. #include "cn3d_threader.hpp"
  70. #include "conservation_colorer.hpp"
  71. #include "molecule_identifier.hpp"
  72. #include "cn3d_blast.hpp"
  74. USING_NCBI_SCOPE;
  77. BEGIN_SCOPE(Cn3D)
  79. // block marker string stuff
  80. static const char
  81.     blockLeftEdgeChar = '<',
  82.     blockRightEdgeChar = '>',
  83.     blockOneColumnChar = '^',
  84.     blockInsideChar = '-';
  85. static const string blockBoundaryStringTitle("(blocks)");
  87. // color converter
  88. static inline void Vector2wxColor(const Vector& colorVec, wxColor *colorWX)
  89. {
  90.     colorWX->Set(
  91.         static_cast<unsigned char>((colorVec[0] + 0.000001) * 255),
  92.         static_cast<unsigned char>((colorVec[1] + 0.000001) * 255),
  93.         static_cast<unsigned char>((colorVec[2] + 0.000001) * 255)
  94.     );
  95. }
  98. ////////////////////////////////////////////////////////////////////////////////
  99. // The sequence view is composed of rows which can be from sequence, alignment,
  100. // or any string - anything derived from DisplayRow, implemented below.
  101. ////////////////////////////////////////////////////////////////////////////////
  103. bool DisplayRowFromAlignment::GetCharacterTraitsAt(
  104.     int column, BlockMultipleAlignment::eUnalignedJustification justification,
  105.     char *character, Vector *color,
  106.     bool *drawBackground, Vector *cellBackgroundColor) const
  107. {
  108.     bool isHighlighted,
  109.         result = alignment->GetCharacterTraitsAt(
  110.             column, row, justification, character, color,
  111.             &isHighlighted, drawBackground, cellBackgroundColor);
  113.     // always apply highlight color, even if alignment has set its own background color
  114.     if (isHighlighted) {
  115.         *drawBackground = true;
  116.         *cellBackgroundColor = GlobalColors()->Get(Colors::eHighlight);
  117.     }
  119.     return result;
  120. }
  122. DisplayRowFromSequence::DisplayRowFromSequence(const Sequence *s, int from, int to) :
  123.     sequence(s), fromIndex(from), toIndex(to)
  124. {
  125.     if (from < 0 || from >= sequence->Length() || from > to || to < 0 || to >= sequence->Length())
  126.         ERRORMSG("DisplayRowFromSequence::DisplayRowFromSequence() - from/to indexes out of range");
  127. }
  129. bool DisplayRowFromSequence::GetCharacterTraitsAt(
  130. int column, BlockMultipleAlignment::eUnalignedJustification justification,
  131.     char *character, Vector *color, bool *drawBackground, Vector *cellBackgroundColor) const
  132. {
  133.     int index = column + fromIndex;
  134.     if (index > toIndex)
  135.         return false;
  137.     *character = tolower(sequence->sequenceString[index]);
  138.     if (sequence->molecule)
  139.         *color = sequence->molecule->GetResidueColor(index);
  140.     else
  141.         color->Set(0,0,0);
  142.     if (GlobalMessenger()->IsHighlighted(sequence, index)) {
  143.         *drawBackground = true;
  144.         *cellBackgroundColor = GlobalColors()->Get(Colors::eHighlight);
  145.     } else {
  146.         *drawBackground = false;
  147.     }
  149.     return true;
  150. }
  152. bool DisplayRowFromSequence::GetSequenceAndIndexAt(
  153.     int column, BlockMultipleAlignment::eUnalignedJustification justification,
  154.     const Sequence **sequenceHandle, int *seqIndex) const
  155. {
  156.     int index = column + fromIndex;
  157.     if (index > toIndex)
  158.         return false;
  160.     *sequenceHandle = sequence;
  161.     *seqIndex = index;
  162.     return true;
  163. }
  165. void DisplayRowFromSequence::SelectedRange(int from, int to,
  166.     BlockMultipleAlignment::eUnalignedJustification justification, bool toggle) const
  167. {
  168.     from += fromIndex;
  169.     to += fromIndex;
  171.     // skip if selected outside range
  172.     if (from < fromIndex && to < fromIndex) return;
  173.     if (from > toIndex && to > toIndex) return;
  175.     // trim to within range
  176.     if (from < fromIndex) from = fromIndex;
  177.     else if (from > toIndex) from = toIndex;
  178.     if (to < fromIndex) to = fromIndex;
  179.     else if (to > toIndex) to = toIndex;
  181.     if (toggle)
  182.         GlobalMessenger()->ToggleHighlights(sequence, from, to);
  183.     else
  184.         GlobalMessenger()->AddHighlights(sequence, from, to);
  185. }
  187. bool DisplayRowFromString::GetCharacterTraitsAt(int column,
  188. BlockMultipleAlignment::eUnalignedJustification justification,
  189.     char *character, Vector *color, bool *drawBackground, Vector *cellBackgroundColor) const
  190. {
  191.     if (column >= theString.size()) return false;
  193.     *character = theString[column];
  194.     *color = stringColor;
  196.     if (hasBackgroundColor) {
  197.         *drawBackground = true;
  198.         *cellBackgroundColor = backgroundColor;
  199.     } else {
  200.         *drawBackground = false;
  201.     }
  202.     return true;
  203. }
  206. ////////////////////////////////////////////////////////////////////////////////
  207. // The SequenceDisplay is the structure that holds the DisplayRows of the view.
  208. // It's also derived from ViewableAlignment, in order to be plugged into a
  209. // SequenceDisplayWidget.
  210. ////////////////////////////////////////////////////////////////////////////////
  212. SequenceDisplay::SequenceDisplay(bool editable, ViewerWindowBase* const *parentViewerWindow) :
  213.     isEditable(editable), maxRowWidth(0), viewerWindow(parentViewerWindow), startingColumn(0)
  214. {
  215. }
  217. SequenceDisplay::~SequenceDisplay(void)
  218. {
  219.     for (int i=0; i<rows.size(); ++i) delete rows[i];
  220. }
  222. void SequenceDisplay::Empty(void)
  223. {
  224.     for (int i=0; i<rows.size(); ++i) delete rows[i];
  225.     rows.clear();
  226.     startingColumn = maxRowWidth = 0;
  227. }
  230. SequenceDisplay * SequenceDisplay::Clone(const Old2NewAlignmentMap& newAlignments) const
  231. {
  232.     SequenceDisplay *copy = new SequenceDisplay(isEditable, viewerWindow);
  233.     for (int row=0; row<rows.size(); ++row)
  234.         copy->rows.push_back(rows[row]->Clone(newAlignments));
  235.     copy->startingColumn = startingColumn;
  236.     copy->maxRowWidth = maxRowWidth;
  237.     return copy;
  238. }
  240. void SequenceDisplay::AddRow(DisplayRow *row)
  241. {
  242.     rows.push_back(row);
  243.     if (row->Width() > maxRowWidth) maxRowWidth = row->Width();
  244. }
  246. BlockMultipleAlignment * SequenceDisplay::GetAlignmentForRow(int row) const
  247. {
  248.     if (row < 0 || row >= rows.size()) return NULL;
  249.     const DisplayRowFromAlignment *displayRow = dynamic_cast<const DisplayRowFromAlignment*>(rows[row]);
  250.     if (displayRow) return displayRow->alignment;
  251.     const DisplayRowFromString *stringRow = dynamic_cast<const DisplayRowFromString*>(rows[row]);
  252.     if (stringRow) return stringRow->alignment;
  253.     return NULL;
  254. }
  256. void SequenceDisplay::UpdateMaxRowWidth(void)
  257. {
  258.     RowVector::iterator r, re = rows.end();
  259.     maxRowWidth = 0;
  260.     for (r=rows.begin(); r!=re; ++r)
  261.         if ((*r)->Width() > maxRowWidth) maxRowWidth = (*r)->Width();
  262. }
  264. void SequenceDisplay::AddRowFromAlignment(int row, BlockMultipleAlignment *fromAlignment)
  265. {
  266.     if (!fromAlignment || row < 0 || row >= fromAlignment->NRows()) {
  267.         ERRORMSG("SequenceDisplay::AddRowFromAlignment() failed");
  268.         return;
  269.     }
  271.     AddRow(new DisplayRowFromAlignment(row, fromAlignment));
  272. }
  274. void SequenceDisplay::AddRowFromSequence(const Sequence *sequence, int from, int to)
  275. {
  276.     if (!sequence) {
  277.         ERRORMSG("SequenceDisplay::AddRowFromSequence() failed");
  278.         return;
  279.     }
  281.     AddRow(new DisplayRowFromSequence(sequence, from, to));
  282. }
  284. void SequenceDisplay::AddRowFromString(const string& anyString)
  285. {
  286.     AddRow(new DisplayRowFromString(anyString));
  287. }
  289. bool SequenceDisplay::GetRowTitle(int row, wxString *title, wxColour *color) const
  290. {
  291.     const DisplayRow *displayRow = rows[row];
  293.     const DisplayRowFromString *strRow = dynamic_cast<const DisplayRowFromString*>(displayRow);
  294.     if (strRow && !strRow->title.empty()) {
  295.         *title = strRow->title.c_str();
  296.         color->Set(0,0,0);      // black
  297.         return true;
  298.     }
  300.     const Sequence *sequence = displayRow->GetSequence();
  301.     if (!sequence) return false;
  303.     // set title
  304.     *title = sequence->identifier->ToString().c_str();
  306.     // set color - by object if there's an associated molecule
  307.     const DisplayRowFromAlignment *alnRow = dynamic_cast<const DisplayRowFromAlignment*>(displayRow);
  308.     const Molecule *molecule;
  309.     if (alnRow && (molecule=alnRow->alignment->GetSequenceOfRow(alnRow->row)->molecule) != NULL)
  310.         Vector2wxColor(molecule->parentSet->styleManager->GetObjectColor(molecule), color);
  311.     else
  312.         color->Set(0,0,0);      // ... black otherwise
  314.     return true;
  315. }
  317. bool SequenceDisplay::GetCharacterTraitsAt(int column, int row,
  318.         char *character, wxColour *color, bool *drawBackground,
  319.         wxColour *cellBackgroundColor) const
  320. {
  321.     if (row < 0 || row > rows.size()) {
  322.         WARNINGMSG("SequenceDisplay::GetCharacterTraitsAt() - row out of range");
  323.         return false;
  324.     }
  326.     const DisplayRow *displayRow = rows[row];
  328.     if (column >= displayRow->Width())
  329.         return false;
  331.     Vector colorVec, bgColorVec;
  332.     if (!displayRow->GetCharacterTraitsAt(column,
  333.             (*viewerWindow) ? (*viewerWindow)->GetCurrentJustification() : BlockMultipleAlignment::eLeft,
  334.             character, &colorVec, drawBackground, &bgColorVec))
  335.         return false;
  337.     Vector2wxColor(colorVec, color);
  338.     if (*drawBackground) Vector2wxColor(bgColorVec, cellBackgroundColor);
  339.     return true;
  340. }
  342. void SequenceDisplay::MouseOver(int column, int row) const
  343. {
  344.     if (*viewerWindow) {
  345.         wxString idLoc, status;
  347.         if (row >= 0 && row < rows.size()) {
  348.             const DisplayRow *displayRow = rows[row];
  349.             const Sequence *sequence = NULL;
  351.             // show id if we're in sequence area
  352.             if (column >= 0 && column < displayRow->Width()) {
  354.                 // show title and seqloc
  355.                 int index = -1;
  356.                 if (displayRow->GetSequenceAndIndexAt(column,
  357.                         (*viewerWindow)->GetCurrentJustification(), &sequence, &index)) {
  358.                     if (index >= 0) {
  359.                         wxString title;
  360.                         wxColour color;
  361.                         if (GetRowTitle(row, &title, &color))
  362.                             idLoc.Printf("%s, loc %i", title.c_str(), index + 1); // show one-based numbering
  363.                     }
  364.                 }
  366.                 // show PDB residue number if available (assume resID = index+1)
  367.                 if (sequence && index >= 0 && sequence->molecule) {
  368.                     const Residue *residue = sequence->molecule->residues.find(index + 1)->second;
  369.                     if (residue && residue->namePDB.size() > 0) {
  370.                         wxString n = residue->namePDB.c_str();
  371.                         n = n.Strip(wxString::both);
  372.                         if (n.size() > 0)
  373.                             idLoc = idLoc + " (PDB " + n + ")";
  374.                     }
  375.                 }
  377.                 // show alignment block number and row-wise string
  378.                 const DisplayRowFromAlignment *alnRow =
  379.                     dynamic_cast<const DisplayRowFromAlignment *>(displayRow);
  380.                 if (alnRow) {
  381.                     int blockNum = alnRow->alignment->GetAlignedBlockNumber(column);
  382.                     int rowNum = 0;
  383.                     // get apparent row number (crude!)
  384.                     for (int r=0; r<=row; ++r) {
  385.                         const DisplayRowFromAlignment *aRow =
  386.                             dynamic_cast<const DisplayRowFromAlignment *>(rows[r]);
  387.                         if (aRow && aRow->alignment == alnRow->alignment) ++rowNum;
  388.                     }
  389.                     if (blockNum > 0)
  390.                         status.Printf("Block %i, Row %i", blockNum, rowNum);
  391.                     else
  392.                         status.Printf("Row %i", rowNum);
  393.                     if (alnRow->alignment->GetRowStatusLine(alnRow->row).size() > 0) {
  394.                         status += " ; ";
  395.                         status += alnRow->alignment->GetRowStatusLine(alnRow->row).c_str();
  396.                     }
  397.                 }
  398.             }
  400.             // else show length and description if we're in the title area
  401.             else if (column < 0) {
  402.                 sequence = displayRow->GetSequence();
  403.                 if (sequence) {
  404.                     idLoc.Printf("length %i", sequence->Length());
  405.                     status = sequence->description.c_str();
  406.                 }
  407.             }
  408.         }
  410.         (*viewerWindow)->SetStatusText(idLoc, 0);
  411.         (*viewerWindow)->SetStatusText(status, 1);
  412.     }
  413. }
  415. void SequenceDisplay::UpdateAfterEdit(const BlockMultipleAlignment *forAlignment)
  416. {
  417.     UpdateBlockBoundaryRow(forAlignment);
  418.     UpdateMaxRowWidth(); // in case alignment width has changed
  419.     (*viewerWindow)->viewer->Save();    // make undoable
  420.     (*viewerWindow)->UpdateDisplay(this);
  421.     if ((*viewerWindow)->AlwaysSyncStructures())
  422.         (*viewerWindow)->SyncStructures();
  423. }
  425. bool SequenceDisplay::MouseDown(int column, int row, unsigned int controls)
  426. {
  427.     TRACEMSG("got MouseDown at col:" << column << " row:" << row);
  429.     // process events in title area (launch of browser for entrez page on a sequence)
  430.     if (column < 0 && row >= 0 && row < NRows()) {
  431.         const Sequence *seq = rows[row]->GetSequence();
  432.         if (seq) seq->LaunchWebBrowserWithInfo();
  433.         return false;
  434.     }
  436.     shiftDown = ((controls & ViewableAlignment::eShiftDown) > 0);
  437.     controlDown = ((controls &
  438. #ifdef __WXMAC__
  439.         // on Mac, can't do ctrl-clicks, so use meta instead
  440.         ViewableAlignment::eAltOrMetaDown
  441. #else
  442.         ViewableAlignment::eControlDown
  443. #endif
  444.             ) > 0);
  445.     if (!shiftDown && !controlDown && column == -1)
  446.         GlobalMessenger()->RemoveAllHighlights(true);
  448.     // process events in sequence area
  449.     BlockMultipleAlignment *alignment = GetAlignmentForRow(row);
  450.     if (alignment && column >= 0) {
  452.         // operations for any viewer window
  453.         if ((*viewerWindow)->DoSplitBlock()) {
  454.             if (alignment->SplitBlock(column)) {
  455.                 if (!controlDown) (*viewerWindow)->SplitBlockOff();
  456.                 UpdateAfterEdit(alignment);
  457.             }
  458.             return false;
  459.         }
  461.         if ((*viewerWindow)->DoDeleteBlock()) {
  462.             if (alignment->DeleteBlock(column)) {
  463.                 if (!controlDown) (*viewerWindow)->DeleteBlockOff();
  464.                 UpdateAfterEdit(alignment);
  465.             }
  466.             return false;
  467.         }
  469.         // operations specific to the sequence window
  470.         SequenceViewerWindow *sequenceWindow = dynamic_cast<SequenceViewerWindow*>(*viewerWindow);
  471.         if (sequenceWindow && row >= 0) {
  473.             if (sequenceWindow->DoMarkBlock()) {
  474.                 if (alignment->MarkBlock(column)) {
  475.                     if (!controlDown) sequenceWindow->MarkBlockOff();
  476.                     GlobalMessenger()->PostRedrawSequenceViewer(sequenceWindow->sequenceViewer);
  477.                 }
  478.                 return false;
  479.             }
  481.             if (sequenceWindow->DoProximitySort()) {
  482.                 if (ProximitySort(row)) {
  483.                     sequenceWindow->ProximitySortOff();
  484.                     GlobalMessenger()->PostRedrawSequenceViewer(sequenceWindow->sequenceViewer);
  485.                 }
  486.                 return false;
  487.             }
  489.             if (sequenceWindow->DoRealignRow() || sequenceWindow->DoDeleteRow()) {
  490.                 DisplayRowFromAlignment *selectedRow = dynamic_cast<DisplayRowFromAlignment*>(rows[row]);
  491.                 if (!selectedRow || selectedRow->row == 0 || !selectedRow->alignment) {
  492.                     WARNINGMSG("Can't delete/realign that row...");
  493.                     return false;
  494.                 }
  496.                 if (sequenceWindow->DoRealignRow()) {
  497.                     vector < int > selectedSlaves(1);
  498.                     selectedSlaves[0] = selectedRow->row;
  499.                     sequenceWindow->sequenceViewer->alignmentManager->
  500.                         RealignSlaveSequences(alignment, selectedSlaves);
  501.                     if (!controlDown) sequenceWindow->RealignRowOff();
  502.                     return false;
  503.                 }
  505.                 if (sequenceWindow->DoDeleteRow()) {
  506.                     if (alignment->NRows() <= 2) {
  507.                         WARNINGMSG("Can't delete that row...");
  508.                         return false;
  509.                     }
  511.                     // in case we need to redraw molecule associated with removed row
  512.                     const Molecule *molecule = alignment->GetSequenceOfRow(selectedRow->row)->molecule;
  514.                     // delete row based on alignment row # (not display row #); redraw molecule
  515.                     if (alignment->DeleteRow(selectedRow->row)) {
  517.                         // delete this row from the display, and update higher row #'s
  518.                         RowVector::iterator r, re = rows.end(), toDelete;
  519.                         for (r=rows.begin(); r!=re; ++r) {
  520.                             DisplayRowFromAlignment
  521.                                 *currentARow = dynamic_cast<DisplayRowFromAlignment*>(*r);
  522.                             if (!currentARow)
  523.                                 continue;
  524.                             else if (currentARow->row > selectedRow->row)
  525.                                 (currentARow->row)--;
  526.                             else if (currentARow == selectedRow)
  527.                                 toDelete = r;
  528.                         }
  529.                         delete *toDelete;
  530.                         rows.erase(toDelete);
  532.                         if (!controlDown) sequenceWindow->DeleteRowOff();
  533.                         UpdateAfterEdit(alignment);
  534.                         if (molecule && sequenceWindow->AlwaysSyncStructures())
  535.                             GlobalMessenger()->PostRedrawMolecule(molecule);
  536.                     }
  537.                     return false;
  538.                 }
  539.             }
  540.         }
  542.         // operations specific to the update window
  543.         UpdateViewerWindow *updateWindow = dynamic_cast<UpdateViewerWindow*>(*viewerWindow);
  544.         if (updateWindow && row >= 0) {
  546.             // delete all blocks
  547.             if (updateWindow->DoDeleteAllBlocks()) {
  548.                 if (alignment->DeleteAllBlocks()) {
  549.                     if (!controlDown) updateWindow->DeleteAllBlocksOff();
  550.                     UpdateAfterEdit(alignment);
  551.                 }
  552.                 return false;
  553.             }
  555.             // thread single
  556.             if (updateWindow->DoThreadSingle()) {
  557.                 if (!updateWindow->updateViewer->alignmentManager->GetCurrentMultipleAlignment()) {
  558.                     ERRORMSG("Can't run threader without existing core alignment");
  559.                     return false;
  560.                 }
  561.                 // get threader options
  562.                 globalThreaderOptions.nRandomStarts = Threader::EstimateNRandomStarts(
  563.                     updateWindow->updateViewer->alignmentManager->GetCurrentMultipleAlignment(),
  564.                     alignment);
  565.                 ThreaderOptionsDialog optDialog(updateWindow, globalThreaderOptions);
  566.                 if (optDialog.ShowModal() == wxCANCEL) return false;  // user cancelled
  567.                 if (!optDialog.GetValues(&globalThreaderOptions)) {
  568.                     ERRORMSG("Error retrieving options values from dialog");
  569.                     return false;
  570.                 }
  571.                 updateWindow->updateViewer->alignmentManager->ThreadUpdate(globalThreaderOptions, alignment);
  572.                 updateWindow->ThreadSingleOff();
  573.                 return false;
  574.             }
  576.             // BLAST single
  577.             if (updateWindow->DoBlastSingle()) {
  578.                 updateWindow->updateViewer->BlastUpdate(alignment, false);
  579.                 if (!controlDown) updateWindow->BlastSingleOff();
  580.                 return false;
  581.             }
  583.             // BLAST/PSSM single
  584.             if (updateWindow->DoBlastPSSMSingle()) {
  585.                 updateWindow->updateViewer->BlastUpdate(alignment, true);
  586.                 if (!controlDown) updateWindow->BlastPSSMSingleOff();
  587.                 return false;
  588.             }
  590.             // BLAST neighbor single
  591.             if (updateWindow->DoBlastNeighborSingle()) {
  592.                 updateWindow->updateViewer->BlastNeighbor(alignment);
  593.                 if (!controlDown) updateWindow->BlastNeighborSingleOff();
  594.                 return false;
  595.             }
  597.             // Block align single
  598.             if (updateWindow->DoBlockAlignSingle()) {
  599.                 updateWindow->updateViewer->alignmentManager->BlockAlignUpdate(alignment);
  600.                 if (!controlDown) updateWindow->BlockAlignSingleOff();
  601.                 return false;
  602.             }
  604.             // set region (on slave sequence)
  605.             if (updateWindow->DoSetRegion()) {
  606.                 // dialog uses 1-based sequence locations
  607.                 RegionDialog dialog(updateWindow,
  608.                     alignment->GetSequenceOfRow(1), alignment->alignSlaveFrom + 1, alignment->alignSlaveTo + 1);
  609.                 if (dialog.ShowModal() == wxOK) {
  610.                     int from, to;
  611.                     if (!dialog.GetValues(&from, &to)) {
  612.                         ERRORMSG("RegionDialog returned OK, but values invalid");
  613.                     } else {
  614.                         TRACEMSG("set region (slave): " << from << " to " << to);
  615.                         alignment->alignSlaveFrom = from - 1;
  616.                         alignment->alignSlaveTo = to - 1;
  617.                     }
  618.                     if (!controlDown) updateWindow->SetRegionOff();
  619.                 }
  620.                 return false;
  621.             }
  623.             // merge single
  624.             if (updateWindow->DoMergeSingle()) {
  625.                 AlignmentManager::UpdateMap single;
  626.                 single[alignment] = true;
  627.                 updateWindow->updateViewer->alignmentManager->MergeUpdates(single, false);
  628.                 if (!controlDown) updateWindow->MergeSingleOff();
  629.                 return false;
  630.             }
  632.             // merge neighbor
  633.             if (updateWindow->DoMergeNeighbor()) {
  634.                 AlignmentManager::UpdateMap single;
  635.                 single[alignment] = true;
  636.                 updateWindow->updateViewer->alignmentManager->MergeUpdates(single, true);
  637.                 if (!controlDown) updateWindow->MergeNeighborOff();
  638.                 return false;
  639.             }
  641.             // delete single
  642.             if (updateWindow->DoDeleteSingle()) {
  643.                 updateWindow->updateViewer->DeleteAlignment(alignment);
  644.                 if (!controlDown) updateWindow->DeleteSingleOff();
  645.                 return false;
  646.             }
  647.         }
  648.     }
  650.     return true;
  651. }
  653. void SequenceDisplay::SelectedRectangle(int columnLeft, int rowTop,
  654.     int columnRight, int rowBottom)
  655. {
  656.     TRACEMSG("got SelectedRectangle " << columnLeft << ',' << rowTop << " to "
  657.         << columnRight << ',' << rowBottom);
  659. BlockMultipleAlignment::eUnalignedJustification justification =
  660. (*viewerWindow)->GetCurrentJustification();
  662.     BlockMultipleAlignment *alignment = GetAlignmentForRow(rowTop);
  663.     if (alignment && alignment == GetAlignmentForRow(rowBottom)) {
  664.         if ((*viewerWindow)->DoMergeBlocks()) {
  665.             if (alignment->MergeBlocks(columnLeft, columnRight)) {
  666.                 if (!controlDown) (*viewerWindow)->MergeBlocksOff();
  667.                 UpdateAfterEdit(alignment);
  668.             }
  669.             return;
  670.         }
  671.         if ((*viewerWindow)->DoCreateBlock()) {
  672.             if (alignment->CreateBlock(columnLeft, columnRight, justification)) {
  673.                 if (!controlDown) (*viewerWindow)->CreateBlockOff();
  674.                 UpdateAfterEdit(alignment);
  675.             }
  676.             return;
  677.         }
  678.     }
  680.     if (!shiftDown && !controlDown)
  681.         GlobalMessenger()->RemoveAllHighlights(true);
  683.     for (int i=rowTop; i<=rowBottom; ++i)
  684.         rows[i]->SelectedRange(columnLeft, columnRight, justification, controlDown); // toggle if control down
  685. }
  687. void SequenceDisplay::DraggedCell(int columnFrom, int rowFrom,
  688.     int columnTo, int rowTo)
  689. {
  690.     // special shift-by-one if shift/ctrl click w/ no drag
  691.     if (columnFrom == columnTo && rowFrom == rowTo) {
  692.         if (shiftDown && columnTo > 0)
  693.             --columnTo;
  694.         else if (controlDown && columnTo < maxRowWidth-1)
  695.             ++columnTo;
  696.     }
  698.     TRACEMSG("got DraggedCell " << columnFrom << ',' << rowFrom << " to "
  699.         << columnTo << ',' << rowTo);
  700.     if (rowFrom == rowTo && columnFrom == columnTo) return;
  701.     if (rowFrom != rowTo && columnFrom != columnTo) return;     // ignore diagonal drag
  703.     if (columnFrom != columnTo) {
  704.         BlockMultipleAlignment *alignment = GetAlignmentForRow(rowFrom);
  705.         if (alignment) {
  706.             // process horizontal drag on special block boundary row
  707.             DisplayRowFromString *strRow = dynamic_cast<DisplayRowFromString*>(rows[rowFrom]);
  708.             if (strRow) {
  709.                 wxString title;
  710.                 wxColour ignored;
  711.                 if (GetRowTitle(rowFrom, &title, &ignored) && title == blockBoundaryStringTitle.c_str()) {
  712.                     char ch = strRow->theString[columnFrom];
  713.                     if (ch == blockRightEdgeChar || ch == blockLeftEdgeChar || ch == blockOneColumnChar) {
  714.                         if (alignment->MoveBlockBoundary(columnFrom, columnTo))
  715.                             UpdateAfterEdit(alignment);
  716.                     }
  717.                 }
  718.                 return;
  719.             }
  721.             // process drag on regular row - block row shift
  722.             DisplayRowFromAlignment *alnRow = dynamic_cast<DisplayRowFromAlignment*>(rows[rowFrom]);
  723.             if (alnRow) {
  724.                 if (alignment->ShiftRow(alnRow->row, columnFrom, columnTo,
  725.                         (*viewerWindow)->GetCurrentJustification()))
  726.                     UpdateAfterEdit(alignment);
  727.                 return;
  728.             }
  729.         }
  730.         return;
  731.     }
  733.     // use vertical drag to reorder row; move rowFrom so that it ends up just before the
  734.     // initial rowTo row
  735.     if (rowFrom == rowTo - 1) return;
  736.     if (rowTo > rowFrom) --rowTo;
  737.     RowVector newRows(rows);
  738.     DisplayRow *row = newRows[rowFrom];
  739.     RowVector::iterator r = newRows.begin();
  740.     int i;
  741.     for (i=0; i<rowFrom; ++i) ++r; // get iterator for position rowFrom
  742.     newRows.erase(r);
  743.     for (r=newRows.begin(), i=0; i<rowTo; ++i) ++r; // get iterator for position rowTo
  744.     newRows.insert(r, row);
  746.     // make sure that the master row of an alignment is still first
  747.     bool masterOK = true;
  748.     for (i=0; i<newRows.size(); ++i) {
  749.         DisplayRowFromAlignment *alnRow = dynamic_cast<DisplayRowFromAlignment*>(newRows[i]);
  750.         if (alnRow) {
  751.             if (alnRow->row != 0) {
  752.                 WARNINGMSG("The first alignment row must always be the master sequence");
  753.                 masterOK = false;
  754.             }
  755.             break;
  756.         }
  757.     }
  758.     if (masterOK) {
  759.         rows = newRows;
  760.         (*viewerWindow)->UpdateDisplay(this);
  761.         (*viewerWindow)->viewer->Save();   // make this an undoable operation
  762.         GlobalMessenger()->PostRedrawAllSequenceViewers();
  763.     }
  764. }
  766. void SequenceDisplay::RedrawAlignedMolecules(void) const
  767. {
  768.     for (int i=0; i<rows.size(); ++i) {
  769.         const Sequence *sequence = rows[i]->GetSequence();
  770.         if (sequence && sequence->molecule)
  771.             GlobalMessenger()->PostRedrawMolecule(sequence->molecule);
  772.     }
  773. }
  775. DisplayRowFromString * SequenceDisplay::FindBlockBoundaryRow(const BlockMultipleAlignment *forAlignment) const
  776. {
  777.     DisplayRowFromString *blockBoundaryRow = NULL;
  778.     for (int row=0; row<rows.size(); ++row) {
  779.         if ((blockBoundaryRow = dynamic_cast<DisplayRowFromString*>(rows[row])) != NULL) {
  780.             if (blockBoundaryRow->alignment == forAlignment &&
  781.                 blockBoundaryRow->title == blockBoundaryStringTitle)
  782.                 break;
  783.             else
  784.                 blockBoundaryRow = NULL;
  785.         }
  786.     }
  787.     return blockBoundaryRow;
  788. }
  790. static inline DisplayRowFromString * CreateBlockBoundaryRow(BlockMultipleAlignment *forAlignment)
  791. {
  792.     return new DisplayRowFromString("", Vector(0,0,0),
  793.         blockBoundaryStringTitle, true, Vector(0.8,0.8,1), forAlignment);
  794. }
  796. void SequenceDisplay::AddBlockBoundaryRows(void)
  797. {
  798.     if (!IsEditable()) return;
  800.     // find alignment master rows
  801.     int i = 0;
  802.     map < const BlockMultipleAlignment * , bool > doneForAlignment;
  803.     do {
  804.         RowVector::iterator r;
  805.         for (r=rows.begin(), i=0; i<rows.size(); ++r, ++i) {
  806.             DisplayRowFromAlignment *alnRow = dynamic_cast<DisplayRowFromAlignment*>(*r);
  807.             if (!alnRow || alnRow->row != 0 || !alnRow->alignment ||
  808.                 doneForAlignment.find(alnRow->alignment) != doneForAlignment.end()) continue;
  810.             // insert block row before each master row
  811.             DisplayRowFromString *blockBoundaryRow = CreateBlockBoundaryRow(alnRow->alignment);
  812.             UpdateBlockBoundaryRow(blockBoundaryRow);
  813.             rows.insert(r, blockBoundaryRow);
  814.             doneForAlignment[alnRow->alignment] = true;
  815.             break;  // insert on vector can cause invalidation of iterators, so start over
  816.         }
  817.     } while (i < rows.size());
  819.     if (*viewerWindow) (*viewerWindow)->UpdateDisplay(this);
  820. }
  822. void SequenceDisplay::AddBlockBoundaryRow(BlockMultipleAlignment *forAlignment)
  823. {
  824.     DisplayRowFromString *blockBoundaryRow = CreateBlockBoundaryRow(forAlignment);
  825.     AddRow(blockBoundaryRow);
  826.     UpdateBlockBoundaryRow(blockBoundaryRow);
  827. }
  829. void SequenceDisplay::UpdateBlockBoundaryRow(const BlockMultipleAlignment *forAlignment) const
  830. {
  831.     DisplayRowFromString *blockBoundaryRow;
  832.     if (!IsEditable() || (blockBoundaryRow = FindBlockBoundaryRow(forAlignment)) == NULL ||
  833.         !blockBoundaryRow->alignment) return;
  834.     UpdateBlockBoundaryRow(blockBoundaryRow);
  835. }
  837. void SequenceDisplay::UpdateBlockBoundaryRow(DisplayRowFromString *blockBoundaryRow) const
  838. {
  839.     if (!IsEditable() || !blockBoundaryRow || !blockBoundaryRow->alignment) return;
  841.     int alignmentWidth = blockBoundaryRow->alignment->AlignmentWidth();
  842.     blockBoundaryRow->theString.resize(alignmentWidth);
  844.     // fill out block boundary marker string
  845.     int blockColumn, blockWidth;
  846.     for (int i=0; i<alignmentWidth; ++i) {
  847.         blockBoundaryRow->alignment->GetAlignedBlockPosition(i, &blockColumn, &blockWidth);
  848.         if (blockColumn >= 0 && blockWidth > 0) {
  849.             if (blockWidth == 1)
  850.                 blockBoundaryRow->theString[i] = blockOneColumnChar;
  851.             else if (blockColumn == 0)
  852.                 blockBoundaryRow->theString[i] = blockLeftEdgeChar;
  853.             else if (blockColumn == blockWidth - 1)
  854.                 blockBoundaryRow->theString[i] = blockRightEdgeChar;
  855.             else
  856.                 blockBoundaryRow->theString[i] = blockInsideChar;
  857.         } else
  858.             blockBoundaryRow->theString[i] = ' ';
  859.     }
  860.     if (*viewerWindow) GlobalMessenger()->PostRedrawSequenceViewer((*viewerWindow)->viewer);
  861. }
  863. void SequenceDisplay::RemoveBlockBoundaryRows(void)
  864. {
  865.     vector < bool > toRemove(rows.size(), false);
  866.     int nToRemove = 0;
  867.     for (int row=0; row<rows.size(); ++row) {
  868.         DisplayRowFromString *blockBoundaryRow = dynamic_cast<DisplayRowFromString*>(rows[row]);
  869.         if (blockBoundaryRow && blockBoundaryRow->title == blockBoundaryStringTitle) {
  870.             delete blockBoundaryRow;
  871.             toRemove[row] = true;
  872.             ++nToRemove;
  873.         }
  874.     }
  875.     VectorRemoveElements(rows, toRemove, nToRemove);
  876.     UpdateMaxRowWidth();
  877.     if (*viewerWindow) (*viewerWindow)->UpdateDisplay(this);
  878. }
  880. void SequenceDisplay::GetProteinSequences(SequenceList *seqs) const
  881. {
  882.     seqs->clear();
  883.     for (int row=0; row<rows.size(); ++row) {
  884.         const Sequence *seq = rows[row]->GetSequence();
  885.         if (seq && seq->isProtein)
  886.             seqs->push_back(seq);
  887.     }
  888. }
  890. void SequenceDisplay::GetSequences(const BlockMultipleAlignment *forAlignment, SequenceList *seqs) const
  891. {
  892.     seqs->clear();
  893.     for (int row=0; row<rows.size(); ++row) {
  894.         DisplayRowFromAlignment *alnRow = dynamic_cast<DisplayRowFromAlignment*>(rows[row]);
  895.         if (alnRow && alnRow->alignment == forAlignment)
  896.             seqs->push_back(alnRow->alignment->GetSequenceOfRow(alnRow->row));
  897.     }
  898. }
  900. void SequenceDisplay::GetRowOrder(
  901.     const BlockMultipleAlignment *forAlignment, vector < int > *slaveRowOrder) const
  902. {
  903.     slaveRowOrder->clear();
  904.     for (int row=0; row<rows.size(); ++row) {
  905.         DisplayRowFromAlignment *alnRow = dynamic_cast<DisplayRowFromAlignment*>(rows[row]);
  906.         if (alnRow && alnRow->alignment == forAlignment)
  907.             slaveRowOrder->push_back(alnRow->row);
  908.     }
  909. }
  911. // comparison function: if CompareRows(a, b) == true, then row a moves up
  912. typedef bool (*CompareRows)(const DisplayRowFromAlignment *a, const DisplayRowFromAlignment *b);
  914. static bool CompareRowsByIdentifier(const DisplayRowFromAlignment *a, const DisplayRowFromAlignment *b)
  915. {
  916.     return MoleculeIdentifier::CompareIdentifiers(
  917.         a->alignment->GetSequenceOfRow(a->row)->identifier,
  918.         b->alignment->GetSequenceOfRow(b->row)->identifier);
  919. }
  921. static bool CompareRowsByScore(const DisplayRowFromAlignment *a, const DisplayRowFromAlignment *b)
  922. {
  923.     return (a->alignment->GetRowDouble(a->row) > b->alignment->GetRowDouble(b->row));
  924. }
  926. static bool CompareRowsByEValue(const DisplayRowFromAlignment *a, const DisplayRowFromAlignment *b)
  927. {
  928.     return ((a->alignment->GetRowDouble(a->row) >= 0.0 &&
  929.              a->alignment->GetRowDouble(a->row) < b->alignment->GetRowDouble(b->row)) ||
  930.             b->alignment->GetRowDouble(b->row) < 0.0);
  931. }
  933. static bool CompareRowsFloatPDB(const DisplayRowFromAlignment *a, const DisplayRowFromAlignment *b)
  934. {
  935.     return (a->alignment->GetSequenceOfRow(a->row)->identifier->pdbID.size() > 0 &&
  936.             b->alignment->GetSequenceOfRow(b->row)->identifier->pdbID.size() == 0);
  937. }
  939. static bool CompareRowsFloatHighlights(const DisplayRowFromAlignment *a, const DisplayRowFromAlignment *b)
  940. {
  941.     return (GlobalMessenger()->IsHighlightedAnywhere(a->alignment->GetSequenceOfRow(a->row)->identifier) &&
  942.             !GlobalMessenger()->IsHighlightedAnywhere(b->alignment->GetSequenceOfRow(b->row)->identifier));
  943. }
  945. static Threader::GeometryViolationsForRow violations;
  946. static bool CompareRowsFloatGV(const DisplayRowFromAlignment *a, const DisplayRowFromAlignment *b)
  947. {
  948.     return (violations[a->row].size() > 0 && violations[b->row].size() == 0);
  949. }
  951. static CompareRows rowComparisonFunction = NULL;
  953. void SequenceDisplay::SortRowsByIdentifier(void)
  954. {
  955.     rowComparisonFunction = CompareRowsByIdentifier;
  956.     SortRows();
  957.     (*viewerWindow)->viewer->Save();   // make this an undoable operation
  958. (*viewerWindow)->UpdateDisplay(this);
  959. }
  961. void SequenceDisplay::SortRowsByThreadingScore(double weightPSSM)
  962. {
  963.     if (!CalculateRowScoresWithThreader(weightPSSM)) return;
  964.     rowComparisonFunction = CompareRowsByScore;
  965.     SortRows();
  966.     TRACEMSG("sorted rows");
  967.     (*viewerWindow)->viewer->Save();   // make this an undoable operation
  968. (*viewerWindow)->UpdateDisplay(this);
  969. }
  971. void SequenceDisplay::FloatPDBRowsToTop(void)
  972. {
  973.     rowComparisonFunction = CompareRowsFloatPDB;
  974.     SortRows();
  975.     (*viewerWindow)->viewer->Save();   // make this an undoable operation
  976. (*viewerWindow)->UpdateDisplay(this);
  977. }
  979. void SequenceDisplay::FloatHighlightsToTop(void)
  980. {
  981.     rowComparisonFunction = CompareRowsFloatHighlights;
  982.     SortRows();
  983.     (*viewerWindow)->viewer->Save();   // make this an undoable operation
  984. (*viewerWindow)->UpdateDisplay(this);
  985. }
  987. void SequenceDisplay::FloatGVToTop(void)
  988. {
  989.     DisplayRowFromAlignment *alnRow = NULL;
  990.     for (int row=0; row<rows.size(); ++row) {
  991.         alnRow = dynamic_cast<DisplayRowFromAlignment*>(rows[row]);
  992.         if (alnRow)
  993.             break;
  994.     }
  995.     if (!alnRow) {
  996.         ERRORMSG("SequenceDisplay::FloatGVToTop() - can't get alignment");
  997.         return;
  998.     }
  1000.     if ((*viewerWindow)->viewer->alignmentManager->threader->
  1001.             GetGeometryViolations(alnRow->alignment, &violations) == 0)
  1002.         return;
  1003.     if (!(*viewerWindow)->menuBar->IsChecked(ViewerWindowBase::MID_SHOW_GEOM_VLTNS))
  1004.         (*viewerWindow)->Command(ViewerWindowBase::MID_SHOW_GEOM_VLTNS);
  1006.     rowComparisonFunction = CompareRowsFloatGV;
  1007.     SortRows();
  1008.     (*viewerWindow)->viewer->Save();   // make this an undoable operation
  1009.     (*viewerWindow)->UpdateDisplay(this);
  1010. }
  1012. void SequenceDisplay::SortRowsBySelfHit(void)
  1013. {
  1014.     // get alignment
  1015.     for (int row=0; row<rows.size(); ++row) {
  1016.         DisplayRowFromAlignment *alnRow = dynamic_cast<DisplayRowFromAlignment*>(rows[row]);
  1017.         if (alnRow) {
  1018.             // do self-hit calculation
  1019.             (*viewerWindow)->viewer->CalculateSelfHitScores(alnRow->alignment);
  1021.             // then sort by score
  1022.             rowComparisonFunction = CompareRowsByEValue;
  1023.             SortRows();
  1024. (*viewerWindow)->viewer->Save();   // make this an undoable operation
  1025. (*viewerWindow)->UpdateDisplay(this);
  1026.             break;
  1027.         }
  1028.     }
  1029. }
  1031. void SequenceDisplay::SortRows(void)
  1032. {
  1033.     if (!rowComparisonFunction) {
  1034.         ERRORMSG("SequenceDisplay::SortRows() - must first set comparison function");
  1035.         return;
  1036.     }
  1038.     // to simplify sorting, construct list of slave rows only
  1039.     vector < DisplayRowFromAlignment * > slaves;
  1040.     int row;
  1041.     for (row=0; row<rows.size(); ++row) {
  1042.         DisplayRowFromAlignment *alnRow = dynamic_cast<DisplayRowFromAlignment*>(rows[row]);
  1043.         if (alnRow && alnRow->row > 0)
  1044.             slaves.push_back(alnRow);
  1045.     }
  1047.     // do the sort
  1048.     stable_sort(slaves.begin(), slaves.end(), rowComparisonFunction);
  1049.     rowComparisonFunction = NULL;
  1051.     // recreate the row list with new order
  1052.     RowVector newRows(rows.size());
  1053.     int nSlaves = 0;
  1054.     for (row=0; row<rows.size(); ++row) {
  1055.         DisplayRowFromAlignment *alnRow = dynamic_cast<DisplayRowFromAlignment*>(rows[row]);
  1056.         if (alnRow && alnRow->row > 0)
  1057.             newRows[row] = slaves[nSlaves++];   // put sorted slaves in place
  1058.         else
  1059.             newRows[row] = rows[row];           // leave other rows in original order
  1060.     }
  1061.     if (nSlaves == slaves.size())   // sanity check
  1062.         rows = newRows;
  1063.     else
  1064.         ERRORMSG("SequenceDisplay::SortRows() - internal inconsistency");
  1065. }
  1067. bool SequenceDisplay::ProximitySort(int displayRow)
  1068. {
  1069.     DisplayRowFromAlignment *keyRow = dynamic_cast<DisplayRowFromAlignment*>(rows[displayRow]);
  1070.     if (!keyRow || keyRow->row == 0) return false;
  1071.     if (keyRow->alignment->NRows() < 3) return true;
  1073.     TRACEMSG("doing Proximity Sort on alignment row " << keyRow->row);
  1074.     int row;
  1075.     BlockMultipleAlignment::UngappedAlignedBlockList blocks;
  1076.     keyRow->alignment->GetUngappedAlignedBlocks(&blocks);
  1077.     BlockMultipleAlignment::UngappedAlignedBlockList::const_iterator b, be = blocks.end();
  1078.     const Sequence *seq1 = keyRow->alignment->GetSequenceOfRow(keyRow->row);
  1079.     vector < DisplayRowFromAlignment * > sortedByScore;
  1081.     // calculate scores for each row based on simple Blosum62 sum of all aligned pairs
  1082.     for (row=0; row<rows.size(); ++row) {
  1083.         DisplayRowFromAlignment *alnRow = dynamic_cast<DisplayRowFromAlignment*>(rows[row]);
  1084.         if (!alnRow) continue;
  1085.         sortedByScore.push_back(alnRow);
  1087.         if (alnRow == keyRow) {
  1088.             keyRow->alignment->SetRowDouble(keyRow->row, kMax_Double);
  1089.             keyRow->alignment->SetRowStatusLine(keyRow->row, "(key row)");
  1090.         } else {
  1091.             const Sequence *seq2 = alnRow->alignment->GetSequenceOfRow(alnRow->row);
  1092.             double score = 0.0;
  1093.             for (b=blocks.begin(); b!=be; ++b) {
  1094.                 const Block::Range
  1095.                     *r1 = (*b)->GetRangeOfRow(keyRow->row),
  1096.                     *r2 = (*b)->GetRangeOfRow(alnRow->row);
  1097.                 for (int i=0; i<(*b)->width; ++i)
  1098.                     score += GetBLOSUM62Score(
  1099.                         seq1->sequenceString[r1->from + i], seq2->sequenceString[r2->from + i]);
  1100.             }
  1101.             alnRow->alignment->SetRowDouble(alnRow->row, score);
  1102.             wxString str;
  1103.             str.Printf("Score vs. key row: %i", (int) score);
  1104.             alnRow->alignment->SetRowStatusLine(alnRow->row, str.c_str());
  1105.         }
  1106.     }
  1107.     if (sortedByScore.size() != keyRow->alignment->NRows()) {
  1108.         ERRORMSG("SequenceDisplay::ProximitySort() - wrong # rows in sort list");
  1109.         return false;
  1110.     }
  1112.     // sort by these scores
  1113.     stable_sort(sortedByScore.begin(), sortedByScore.end(), CompareRowsByScore);
  1115.     // find where the master row is in sorted list
  1116.     int M;
  1117.     for (M=0; M<sortedByScore.size(); ++M) if (sortedByScore[M]->row == 0) break;
  1119.     // arrange by proximity to key row
  1120.     vector < DisplayRowFromAlignment * > arrangedByProximity(sortedByScore.size(), NULL);
  1122.     // add master and key row
  1123.     arrangedByProximity[0] = sortedByScore[M];  // move master back to top
  1124.     arrangedByProximity[M] = sortedByScore[0];  // move key row to M
  1125.     // remove these from sorted list
  1126.     vector < bool > toRemove(sortedByScore.size(), false);
  1127.     toRemove[M] = toRemove[0] = true;
  1128.     VectorRemoveElements(sortedByScore, toRemove, 2);
  1130.     // add the rest of the sequences in the sorted list to the arranged list
  1131.     int i = 1, j = 1, N, R = 0;
  1132.     while (R < sortedByScore.size()) {
  1133.         N = M + i*j;    // iterate N = M+1, M-1, M+2, M-2, ...
  1134.         j = -j;
  1135.         if (j > 0) ++i;
  1136.         if (N > 0 && N < arrangedByProximity.size())
  1137.             arrangedByProximity[N] = sortedByScore[R++];
  1138.     }
  1140.     // recreate the row list with new order
  1141.     RowVector newRows(rows.size());
  1142.     int nNewRows = 0;
  1143.     for (row=0; row<rows.size(); ++row) {
  1144.         DisplayRowFromAlignment *alnRow = dynamic_cast<DisplayRowFromAlignment*>(rows[row]);
  1145.         if (alnRow)
  1146.             newRows[row] = arrangedByProximity[nNewRows++];   // put arranged rows in place
  1147.         else
  1148.             newRows[row] = rows[row];           // leave other rows in original order
  1149.     }
  1150.     if (nNewRows == arrangedByProximity.size())   // sanity check
  1151.         rows = newRows;
  1152.     else
  1153.         ERRORMSG("SequenceDisplay::ProximitySort() - internal inconsistency");
  1155.     // finally, highlight the key row and scroll approximately there
  1156.     GlobalMessenger()->RemoveAllHighlights(true);
  1157.     GlobalMessenger()->AddHighlights(seq1, 0, seq1->Length() - 1);
  1158.     (*viewerWindow)->ScrollToRow((M - 3) > 0 ? (M - 3) : 0);
  1159.     (*viewerWindow)->viewer->Save();   // make this an undoable operation
  1160. (*viewerWindow)->UpdateDisplay(this);
  1161.     return true;
  1162. }
  1164. bool SequenceDisplay::CalculateRowScoresWithThreader(double weightPSSM)
  1165. {
  1166.     if (isEditable) {
  1167.         SequenceViewer *seqViewer = dynamic_cast<SequenceViewer*>((*viewerWindow)->viewer);
  1168.         if (seqViewer) {
  1169.             seqViewer->alignmentManager->CalculateRowScoresWithThreader(weightPSSM);
  1170.             TRACEMSG("calculated row scores");
  1171.             return true;
  1172.         }
  1173.     }
  1174.     return false;
  1175. }
  1177. void SequenceDisplay::RowsAdded(int nRowsAddedToMultiple, BlockMultipleAlignment *multiple, int alnWhere)
  1178. {
  1179.     if (nRowsAddedToMultiple <= 0) return;
  1181.     // find the last row that's from this multiple
  1182.     int r, nRows = 0, lastAlnRowIndex, displayWhere = -1;
  1183.     DisplayRowFromAlignment *lastAlnRow = NULL;
  1184.     for (r=0; r<rows.size(); ++r) {
  1185.         DisplayRowFromAlignment *alnRow = dynamic_cast<DisplayRowFromAlignment*>(rows[r]);
  1186.         if (alnRow && alnRow->alignment == multiple) {
  1187.             lastAlnRow = alnRow;
  1188.             lastAlnRowIndex = r;
  1189.             ++nRows;
  1190.             if (alnWhere >= 0 && alnRow->row == alnWhere)
  1191.                 displayWhere = r;  // convert 'where' from alignment row to display row
  1192.         }
  1193.     }
  1194.     if (!lastAlnRow || multiple->NRows() != nRows + nRowsAddedToMultiple) {
  1195.         ERRORMSG("SequenceDisplay::RowsAdded() - inconsistent parameters");
  1196.         return;
  1197.     }
  1198.     int rowToMergeAfter = (displayWhere >= 0) ? displayWhere : lastAlnRowIndex;
  1199.     INFOMSG("adding new row after display row #" << (rowToMergeAfter+1));
  1201.     // move higher rows up to leave space for new rows
  1202.     int nRowsToMove = rows.size() - 1 - rowToMergeAfter;
  1203.     rows.resize(rows.size() + nRowsAddedToMultiple);
  1204.     for (r=0; r<nRowsToMove; ++r)
  1205.         rows[rows.size() - 1 - r] = rows[rows.size() - 1 - r - nRowsAddedToMultiple];
  1207.     // add new rows, assuming new rows to add to the display are from the last rows of the multiple
  1208.     for (r=0; r<nRowsAddedToMultiple; ++r)
  1209.         rows[rowToMergeAfter + 1 + r] = new DisplayRowFromAlignment(
  1210.             multiple->NRows() + r - nRowsAddedToMultiple, multiple);
  1212.     UpdateAfterEdit(multiple);
  1213. }
  1215. void SequenceDisplay::RowsRemoved(const vector < int >& rowsRemoved,
  1216.     const BlockMultipleAlignment *multiple)
  1217. {
  1218.     if (rowsRemoved.size() == 0) return;
  1220.     // first, construct a map of old alignment row numbers -> new row numbers; also do sanity checks
  1221.     int i;
  1222.     vector < int > alnRowNumbers(multiple->NRows() + rowsRemoved.size());
  1223.     vector < bool > removedAlnRows(alnRowNumbers.size(), false);
  1224.     for (i=0; i<alnRowNumbers.size(); ++i) alnRowNumbers[i] = i;
  1225.     for (i=0; i<rowsRemoved.size(); ++i) {
  1226.         if (rowsRemoved[i] < 1 || rowsRemoved[i] >= alnRowNumbers.size()) {
  1227.             ERRORMSG("SequenceDisplay::RowsRemoved() - can't remove row " << removedAlnRows[i]);
  1228.             return;
  1229.         } else
  1230.             removedAlnRows[rowsRemoved[i]] = true;
  1231.     }
  1232.     VectorRemoveElements(alnRowNumbers, removedAlnRows, rowsRemoved.size());
  1233.     map < int, int > oldRowToNewRow;
  1234.     for (i=0; i<alnRowNumbers.size(); ++i) oldRowToNewRow[alnRowNumbers[i]] = i;
  1236.     // then tag rows to remove from display, and update row numbers for rows not removed
  1237.     vector < bool > removeDisplayRows(rows.size(), false);
  1238.     for (i=0; i<rows.size(); ++i) {
  1239.         DisplayRowFromAlignment *alnRow = dynamic_cast<DisplayRowFromAlignment*>(rows[i]);
  1240.         if (alnRow && alnRow->alignment == multiple) {
  1241.             if (removedAlnRows[alnRow->row]) {
  1242.                 delete rows[i];
  1243.                 removeDisplayRows[i] = true;
  1244.             } else
  1245.                 alnRow->row = oldRowToNewRow[alnRow->row];
  1246.         }
  1247.     }
  1248.     VectorRemoveElements(rows, removeDisplayRows, rowsRemoved.size());
  1250.     UpdateAfterEdit(multiple);
  1251. }
  1253. bool SequenceDisplay::GetDisplayCoordinates(const Molecule *molecule, int seqIndex,
  1254.     BlockMultipleAlignment::eUnalignedJustification justification, int *column, int *row)
  1255. {
  1256.     if (!molecule || seqIndex < 0) return false;
  1258.     int displayRow;
  1259.     const Sequence *seq;
  1261.     // search by Molecule*
  1262.     for (displayRow=0; displayRow<NRows(); ++displayRow) {
  1263.         seq = rows[displayRow]->GetSequence();
  1264.         if (seq && seq->molecule == molecule) {
  1265.             *row = displayRow;
  1267.             const DisplayRowFromAlignment *alnRow = dynamic_cast<DisplayRowFromAlignment*>(rows[displayRow]);
  1268.             if (alnRow) {
  1269.                 *column = alnRow->alignment->GetAlignmentIndex(alnRow->row, seqIndex, justification);
  1270.                 return (*column >= 0);
  1271.             }
  1273.             const DisplayRowFromSequence *seqRow = dynamic_cast<DisplayRowFromSequence*>(rows[displayRow]);
  1274.             if (seqRow && seqIndex >= seqRow->fromIndex && seqIndex <= seqRow->toIndex) {
  1275.                 *column = seqIndex - seqRow->fromIndex;
  1276.                 return true;
  1277.             }
  1278.         }
  1279.     }
  1280.     return false;
  1281. }
  1283. END_SCOPE(Cn3D)
  1286. /*
  1287. * ---------------------------------------------------------------------------
  1288. * $Log: sequence_display.cpp,v $
  1289. * Revision 1000.3  2004/06/01 18:29:04  gouriano
  1290. * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.73
  1291. *
  1292. * Revision 1.73  2004/05/21 21:41:39  gorelenk
  1293. * Added PCH ncbi_pch.hpp
  1294. *
  1295. * Revision 1.72  2004/03/15 17:55:06  thiessen
  1296. * prefer prefix vs. postfix ++/-- operators
  1297. *
  1298. * Revision 1.71  2004/02/19 17:05:05  thiessen
  1299. * remove cn3d/ from include paths; add pragma to disable annoying msvc warning
  1300. *
  1301. * Revision 1.70  2003/11/06 19:07:19  thiessen
  1302. * leave show gv's on if on already
  1303. *
  1304. * Revision 1.69  2003/10/20 13:17:15  thiessen
  1305. * add float geometry violations sorting
  1306. *
  1307. * Revision 1.68  2003/07/14 18:37:07  thiessen
  1308. * change GetUngappedAlignedBlocks() param types; other syntax changes
  1309. *
  1310. * Revision 1.67  2003/02/03 19:20:05  thiessen
  1311. * format changes: move CVS Log to bottom of file, remove std:: from .cpp files, and use new diagnostic macros
  1312. *
  1313. * Revision 1.66  2003/01/31 17:18:58  thiessen
  1314. * many small additions and changes...
  1315. *
  1316. * Revision 1.65  2003/01/29 01:41:05  thiessen
  1317. * add merge neighbor instead of merge near highlight
  1318. *
  1319. * Revision 1.64  2003/01/28 21:07:56  thiessen
  1320. * add block fit coloring algorithm; tweak row dragging; fix style bug
  1321. *
  1322. * Revision 1.63  2003/01/27 16:42:24  thiessen
  1323. * remove debugging messages
  1324. *
  1325. * Revision 1.62  2003/01/27 15:52:22  thiessen
  1326. * merge after highlighted row; show rejects; trim rejects from new reject list
  1327. *
  1328. * Revision 1.61  2003/01/23 20:03:05  thiessen
  1329. * add BLAST Neighbor algorithm
  1330. *
  1331. * Revision 1.60  2002/10/13 22:58:08  thiessen
  1332. * add redo ability to editor
  1333. *
  1334. * Revision 1.59  2002/09/16 21:24:58  thiessen
  1335. * add block freezing to block aligner
  1336. *
  1337. * Revision 1.58  2002/09/05 18:38:57  thiessen
  1338. * add sort by highlights
  1339. *
  1340. * Revision 1.57  2002/08/28 20:30:33  thiessen
  1341. * fix proximity sort bug
  1342. *
  1343. * Revision 1.56  2002/08/15 22:13:16  thiessen
  1344. * update for wx2.3.2+ only; add structure pick dialog; fix MultitextDialog bug
  1345. *
  1346. * Revision 1.55  2002/08/15 12:57:07  thiessen
  1347. * fix highlight redraw bug
  1348. *
  1349. * Revision 1.54  2002/08/13 20:46:37  thiessen
  1350. * add global block aligner
  1351. *
  1352. * Revision 1.53  2002/07/26 15:28:48  thiessen
  1353. * add Alejandro's block alignment algorithm
  1354. *
  1355. * Revision 1.52  2002/07/23 15:46:50  thiessen
  1356. * print out more BLAST info; tweak save file name
  1357. *
  1358. * Revision 1.51  2002/06/13 14:54:07  thiessen
  1359. * add sort by self-hit
  1360. *
  1361. * Revision 1.50  2002/05/17 19:10:27  thiessen
  1362. * preliminary range restriction for BLAST/PSSM
  1363. *
  1364. * Revision 1.49  2002/05/07 20:22:47  thiessen
  1365. * fix for BLAST/PSSM
  1366. *
  1367. * Revision 1.48  2002/05/02 18:40:25  thiessen
  1368. * do BLAST/PSSM for debug builds only, for testing
  1369. *
  1370. * Revision 1.47  2002/04/26 19:01:00  thiessen
  1371. * fix display delete bug
  1372. *
  1373. * Revision 1.46  2002/04/26 13:46:36  thiessen
  1374. * comment out all blast/pssm methods
  1375. *
  1376. * Revision 1.45  2002/03/28 14:06:02  thiessen
  1377. * preliminary BLAST/PSSM ; new CD startup style
  1378. *
  1379. * Revision 1.44  2002/02/28 19:11:52  thiessen
  1380. * wrap sequences in single-structure mode
  1381. *
  1382. * Revision 1.43  2002/02/22 14:24:01  thiessen
  1383. * sort sequences in reject dialog ; general identifier comparison
  1384. *
  1385. * Revision 1.42  2002/02/21 12:26:30  thiessen
  1386. * fix row delete bug ; remember threader options
  1387. *
  1388. * Revision 1.41  2002/02/19 14:59:39  thiessen
  1389. * add CDD reject and purge sequence
  1390. *
  1391. * Revision 1.40  2002/02/15 15:27:12  thiessen
  1392. * on Mac, use meta for MouseDown events
  1393. *
  1394. * Revision 1.39  2002/02/15 01:02:17  thiessen
  1395. * ctrl+click keeps edit modes
  1396. *
  1397. * Revision 1.38  2002/02/05 18:53:25  thiessen
  1398. * scroll to residue in sequence windows when selected in structure window
  1399. *
  1400. * Revision 1.37  2001/12/05 17:16:56  thiessen
  1401. * fix row insert bug
  1402. *
  1403. * Revision 1.36  2001/11/30 14:02:05  thiessen
  1404. * progress on sequence imports to single structures
  1405. *
  1406. * Revision 1.35  2001/11/27 16:26:08  thiessen
  1407. * major update to data management system
  1408. *
  1409. * Revision 1.34  2001/10/08 00:00:09  thiessen
  1410. * estimate threader N random starts; edit CDD name
  1411. *
  1412. * Revision 1.33  2001/09/27 15:37:59  thiessen
  1413. * decouple sequence import and BLAST
  1414. *
  1415. * Revision 1.32  2001/09/19 22:55:39  thiessen
  1416. * add preliminary net import and BLAST
  1417. *
  1418. * Revision 1.31  2001/08/24 14:54:50  thiessen
  1419. * make status row # order-independent :)
  1420. *
  1421. * Revision 1.30  2001/08/24 14:32:51  thiessen
  1422. * add row # to status line
  1423. *
  1424. * Revision 1.29  2001/08/08 02:25:27  thiessen
  1425. * add <memory>
  1426. *
  1427. * Revision 1.28  2001/07/10 16:39:55  thiessen
  1428. * change selection control keys; add CDD name/notes dialogs
  1429. *
  1430. * Revision 1.27  2001/06/21 02:02:34  thiessen
  1431. * major update to molecule identification and highlighting ; add toggle highlight (via alt)
  1432. *
  1433. * Revision 1.26  2001/06/07 19:05:38  thiessen
  1434. * functional (although incomplete) render settings panel ; highlight title - not sequence - upon mouse click
  1435. *
  1436. * Revision 1.25  2001/06/05 13:21:08  thiessen
  1437. * fix structure alignment list problems
  1438. *
  1439. * Revision 1.24  2001/06/04 14:58:00  thiessen
  1440. * add proximity sort; highlight sequence on browser launch
  1441. *
  1442. * Revision 1.23  2001/06/01 18:07:27  thiessen
  1443. * fix display clone bug
  1444. *
  1445. * Revision 1.22  2001/06/01 14:05:12  thiessen
  1446. * add float PDB sort
  1447. *
  1448. * Revision 1.21  2001/06/01 13:35:58  thiessen
  1449. * add aligned block number to status line
  1450. *
  1451. * Revision 1.20  2001/05/31 18:47:08  thiessen
  1452. * add preliminary style dialog; remove LIST_TYPE; add thread single and delete all; misc tweaks
  1453. *
  1454. * Revision 1.19  2001/05/22 19:09:31  thiessen
  1455. * many minor fixes to compile/run on Solaris/GTK
  1456. *
  1457. * Revision 1.18  2001/05/14 16:04:31  thiessen
  1458. * fix minor row reordering bug
  1459. *
  1460. * Revision 1.17  2001/05/11 02:10:42  thiessen
  1461. * add better merge fail indicators; tweaks to windowing/taskbar
  1462. *
  1463. * Revision 1.16  2001/05/09 17:15:06  thiessen
  1464. * add automatic block removal upon demotion
  1465. *
  1466. * Revision 1.15  2001/05/02 16:35:15  thiessen
  1467. * launch entrez web page on sequence identifier
  1468. *
  1469. * Revision 1.14  2001/04/19 12:58:32  thiessen
  1470. * allow merge and delete of individual updates
  1471. *
  1472. * Revision 1.13  2001/04/18 15:46:53  thiessen
  1473. * show description, length, and PDB numbering in status line
  1474. *
  1475. * Revision 1.12  2001/04/05 22:55:35  thiessen
  1476. * change bg color handling ; show geometry violations
  1477. *
  1478. * Revision 1.11  2001/04/04 00:27:14  thiessen
  1479. * major update - add merging, threader GUI controls
  1480. *
  1481. * Revision 1.10  2001/03/30 14:43:41  thiessen
  1482. * show threader scores in status line; misc UI tweaks
  1483. *
  1484. * Revision 1.9  2001/03/30 03:07:34  thiessen
  1485. * add threader score calculation & sorting
  1486. *
  1487. * Revision 1.8  2001/03/22 00:33:17  thiessen
  1488. * initial threading working (PSSM only); free color storage in undo stack
  1489. *
  1490. * Revision 1.7  2001/03/19 15:50:39  thiessen
  1491. * add sort rows by identifier
  1492. *
  1493. * Revision 1.6  2001/03/13 01:25:05  thiessen
  1494. * working undo system for >1 alignment (e.g., update window)
  1495. *
  1496. * Revision 1.5  2001/03/09 15:49:04  thiessen
  1497. * major changes to add initial update viewer
  1498. *
  1499. * Revision 1.4  2001/03/06 20:49:14  thiessen
  1500. * fix row->alignment bug
  1501. *
  1502. * Revision 1.3  2001/03/06 20:20:50  thiessen
  1503. * progress towards >1 alignment in a SequenceDisplay ; misc minor fixes
  1504. *
  1505. * Revision 1.2  2001/03/02 15:32:52  thiessen
  1506. * minor fixes to save & show/hide dialogs, wx string headers
  1507. *
  1508. * Revision 1.1  2001/03/01 20:15:51  thiessen
  1509. * major rearrangement of sequence viewer code into base and derived classes
  1510. *
  1511. */