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

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

生物技术

开发平台：

C/C++

align_mark_handler.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: align_mark_handler.cpp,v $
  4.  * PRODUCTION Revision 1000.3  2004/06/01 21:06:57  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.17
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: align_mark_handler.cpp,v 1000.3 2004/06/01 21:06:57 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:  Andrey Yazhuk
  36.  *
  37.  * File Description:
  38.  * CAlignMarkHandler - class implementing support for Marks in alignments.
  39.  * IAlignMarkHandlerHost - context in which CAlignMarkHandler operates.
  40.  */
  42. #include <ncbi_pch.hpp>
  43. #include <FL/Fl.H>
  44. #include <FL/Enumerations.H>
  46. #include <gui/widgets/aln_multiple/align_mark_handler.hpp>
  47. #include <gui/widgets/aln_multiple/alnmulti_settings.hpp>
  49. #include <math.h>
  51. BEGIN_NCBI_SCOPE
  52. USING_SCOPE(objects);
  55. CAlignMarkHandler::CAlignMarkHandler()
  56. : m_pHost(NULL),
  57.     m_pPane(NULL),
  58.     m_bHitResizable(false),
  59.     m_State(eIdle),
  60.     m_Cursor(FL_CURSOR_DEFAULT),
  61.     m_PrevPos((TSeqPos)-1),
  62.     m_FillColor(0.5f, 0.5f, 1.0f, 0.5f),
  63.     m_FrameColor(0.25f, 0.25f, 0.5f, 1.0f)        
  64. {    
  65. }
  67. void    CAlignMarkHandler::SetHost(IAlignMarkHandlerHost* pHost)
  68. {
  69.     m_pHost = pHost;
  70. }
  72. //FLTK-like event handler
  73. int CAlignMarkHandler::handle(CGUIEvent& event, CGlPane& pane)
  74. {
  75.     m_pPane = &pane;
  77.     int res = 0;
  78.     switch(event.GetFLTKEvent())   {
  79.     case FL_PUSH: res =  x_OnMousePush(event); break;
  80.     case FL_DRAG: res =  x_OnMouseDrag(event); break;
  81.     case FL_RELEASE: res =  x_OnMouseRelease(event); break;
  82.     case FL_MOVE: res =  x_OnMouseMove(event); break;
  83.     case FL_KEYDOWN: res =  x_OnKeyDown(event); break;
  84.     case FL_KEYUP: res =  x_OnKeyUp(event); break;
  85.     }
  87.     m_pPane = 0;
  88.     return res;
  89. }
  91. ////////////////////////////////////////////////////////////////////////////////
  92. // opeartions with Mark
  94. void    CAlignMarkHandler::MarkSelectedRows(const TRangeColl& C, bool bMark)
  95. {
  96.     const TSelListModel* pModel = x_GetHost()->MHH_GetSelListModel();
  97.     TSelListModel::TIndexVector vSel;
  98.     pModel->SLM_GetSelectedIndices(vSel);
  100.     const IAlnMultiDataSource*  pAlnDS = x_GetHost()->MHH_GetAlnDS();
  101.     
  102.     ITERATE(TSelListModel::TIndexVector, it, vSel)  { // for each Mark
  103.         TNumrow Row = pModel->SLM_GetItem(*it);
  104.         
  105.         TRowToMarkMap::iterator itM = m_mpRowToMark.find(Row);
  106.         if(itM == m_mpRowToMark.end()) 
  107.             itM = m_mpRowToMark.insert(TRowToMarkMap::value_type(Row, TRangeColl())).first;
  108.                 
  109.         TRangeColl& Mark = itM->second;
  110.         
  111.         ITERATE(TRangeColl, itR, C) { // for each Range in C
  112.             // translate Range to sequence coordinates
  113.             TSeqPos From = 
  114.                 pAlnDS->GetSeqPosFromAlnPos(Row, itR->GetFrom(),
  115.                                             IAlnMultiDataSource::
  116.                                             TSearchDirection::eRight);
  117.             TSeqPos To =
  118.                 pAlnDS->GetSeqPosFromAlnPos(Row, itR->GetTo(),
  119.                                             IAlnMultiDataSource::
  120.                                             TSearchDirection::eRight);
  121.             TSeqRange  R(From, To);    
  122.             // modify Mark
  123.             if(bMark)
  124.                     Mark += R;
  125.             else    Mark -= R;
  126.         }
  127.     }
  128. }
  130. void    CAlignMarkHandler::UnMarkAll()
  131. {
  132.     m_mpRowToMark.clear();
  133. }
  135. void    CAlignMarkHandler::UnMarkSelected()
  136. {
  137.     // get selected lines
  138.     const TSelListModel* pModel = x_GetHost()->MHH_GetSelListModel();
  139.     TSelListModel::TIndexVector vIndices;
  140.     pModel->SLM_GetSelectedIndices(vIndices);
  141.         
  142.     // for each selected Line
  143.     ITERATE(TSelListModel::TIndexVector, it, vIndices)  {
  144.         TNumrow Row = x_GetHost()->MHH_GetRowByLine(*it);        
  145.         m_mpRowToMark.erase(Row);
  146.     }
  147. }
  149. const   CAlignMarkHandler::TRowToMarkMap&  CAlignMarkHandler::GetMarks() const
  150. {
  151.     return m_mpRowToMark;
  152. }
  154. ////////////////////////////////////////////////////////////////////////////////
  155. // event handlers
  157. int CAlignMarkHandler::x_OnMousePush(CGUIEvent& event)
  158. {    
  159.     if(event.GetGUIState() == CGUIEvent::eMarkState  &&
  160.         event.GetGUISignal() == CGUIEvent::ePush) {  
  161.         if(Fl::event_clicks() == 0) {
  162.             x_OnStartSel();
  163.             x_OnSelectCursor();
  164.         }                
  165.         return 1;
  166.     }
  167.     return 0;
  168. }
  170. int CAlignMarkHandler::x_OnMouseDrag(CGUIEvent& event)
  171. {
  172.     if(m_State == eResize  &&  event.GetGUIState() == CGUIEvent::eMarkState) {
  173.         x_OnChangeSelRange();
  174.     }
  175.     return 1; // always handle drags
  176. }
  178. int CAlignMarkHandler::x_OnMouseRelease(CGUIEvent& event)
  179. {
  180.     if(m_State != eIdle)    {
  181.         if(event.GetGUISignal() == CGUIEvent::eRelease)    {
  182.             if(m_State == eResize)  { 
  183.                 bool b_mark = (event.GetGUIState() == CGUIEvent::eMarkState);
  184.                 EState new_state = b_mark ? eReady : eIdle;
  185.                                     
  186.                 x_OnEndSelRange(new_state);
  187.             }
  188.             return 1;
  189.         }
  190.     }
  191.     return 0;
  192. }
  194. int CAlignMarkHandler::x_OnMouseMove(CGUIEvent& event)
  195. {
  196.     //if(x_OpKeyPressed()) {
  197.     if(event.GetGUIState() == CGUIEvent::eMarkState)    {
  198.         x_OnSelectCursor();
  199.         return 1;
  200.     } else return 0;
  201. }
  203. int CAlignMarkHandler::x_OnKeyDown(CGUIEvent& event)
  204. {
  205.     if(event.GetGUIState() == CGUIEvent::eMarkState)    {
  206.         int k = Fl::event_key();    
  207.         if(k == FL_Delete)  {
  208.             UnMarkSelected();
  209.             x_GetHost()->MHH_Redraw();
  210.             return 1;
  211.         }
  212.         x_UpdateState(true);        
  213.     }
  214.     return 0;
  215. }
  217. int CAlignMarkHandler::x_OnKeyUp(CGUIEvent& event)
  218. {
  219.     //int k = Fl::event_key();
  220.     //if(k == FL_Control_L  ||  k == FL_Control_R)    { //Control is released
  221.     if(m_State == eResize)   { 
  222.         if(event.GetGUIState() != CGUIEvent::eMarkState)    {
  223.             EState new_state = (event.GetGUIState() == CGUIEvent::eMarkState) ? eReady : eIdle;
  224.             x_OnEndSelRange(new_state);
  225.         } else    x_UpdateState(true);
  226.     }    
  227.     return 0;
  228. }
  230. ////////////////////////////////////////////////////////////////////////////////
  231. /// Signal handlers
  232. void    CAlignMarkHandler::x_OnStartSel()
  233. {    
  234.     if(x_HitSelectedLine()) {
  235.         m_PrevPos = (TSeqPos) -1;
  237.         x_InitDeltaMap();
  239.         m_State = eResize; 
  240.         m_pHost->MHH_Redraw();
  241.     }
  242. }
  244. void    CAlignMarkHandler::x_OnChangeSelRange()
  245. {    
  246.     TModelUnit mX = x_MouseToSeqPos();
  247.     TSeqPos Pos = (TSeqPos) floor(mX);
  248.     Pos = x_ClipPosByRange(Pos);
  250.     if(Pos != m_PrevPos)    {
  251.         x_UpdateSelection(Pos);
  252.         m_pHost->MHH_Redraw();
  253.     }
  255.     m_PrevPos = Pos;
  256. }
  258. void    CAlignMarkHandler::x_OnEndSelRange(EState new_state)
  259. {
  260.     x_OnChangeSelRange();            
  261.             
  262.     x_UpdateMarks();
  263.     //m_State = x_OpKeyPressed() ? eReady : eIdle;
  264.     m_State = new_state;
  266.     x_OnSelectCursor();
  267.     m_pHost->MHH_Redraw();    
  268. }
  270. void    CAlignMarkHandler::x_OnResetAll()
  271. {
  272.     m_mpRowToMark.clear();
  273.     m_mpRowToDelta.clear();
  275.     m_State = eIdle;
  276.     m_PrevPos = (TSeqPos) -1;
  278.     m_pHost->MHH_Redraw();
  279. }
  281. void    CAlignMarkHandler::x_UpdateState(bool b_key)
  282. {
  283.     //bool b_key = x_OpKeyPressed();
  284.     bool bHit = x_HitSelectedLine();
  286.     EState NewState = m_State;
  287.     switch(m_State) {
  288.     case    eIdle:  
  289.     case    eReady: NewState = (b_key  &&  bHit) ? eReady : eIdle;  break;
  290.     case    eResize:  NewState = b_key ? eResize : eIdle;  break;
  291.     }
  293.     if(NewState != m_State) {
  294.         m_State = NewState; 
  295.            
  296.         x_OnSelectCursor();
  297.         m_pHost->MHH_Redraw();
  298.     }    
  299. }
  301. // Select cursor depending on the current state and mouse position
  302. void    CAlignMarkHandler::x_OnSelectCursor()
  303. {
  304.     switch(m_State)    {
  305.     case eIdle:    m_Cursor = FL_CURSOR_DEFAULT; break;
  306.     case eReady:    {
  307.         if(x_HitSelectedLine()) {
  308.             m_Cursor = x_HitRangeBorder() ? FL_CURSOR_WE : FL_CURSOR_INSERT;
  309.         } else m_Cursor = FL_CURSOR_DEFAULT;
  310.     }; break;
  311.     case eResize:   m_Cursor = FL_CURSOR_WE; break;
  312.     default: break;
  313.     }   
  315.     fl_cursor(m_Cursor, FL_BLACK, FL_WHITE);
  316. }
  318. ////////////////////////////////////////////////////////////////////////////////
  319. /// helper functions
  321. // returns true if modifier Key assigned to the operations with Mark is pressed
  322. bool CAlignMarkHandler::x_OpKeyPressed()    const
  323. {
  324.     int ModState = Fl::event_state() & (FL_SHIFT | FL_ALT | FL_CTRL);
  325.     return ModState == FL_CTRL;
  326. }
  328. //returns true if no conflicting modifier keys are pressed
  329. bool CAlignMarkHandler::x_ModifiersOk()    const
  330. {
  331.     int State = Fl::event_state() & (FL_SHIFT | FL_ALT);
  332.     return State == 0;
  333. }
  335. // converts mouse X position to the position in Alignment
  336. TModelUnit CAlignMarkHandler::x_MouseToSeqPos()
  337. {
  338.     _ASSERT(m_pPane);
  339.     int x = Fl::event_x();
  340.     return m_pHost->MHH_GetSeqPosByX(x) + 0.5;
  341. }
  343. // functions creates a "Delta" map for ranges  that will be resized
  344. void    CAlignMarkHandler::x_InitDeltaMap()
  345. {
  346.     m_mpRowToDelta.clear();
  348.     int X = Fl::event_x();
  350.     // get selected lines
  351.     const TSelListModel* pModel = x_GetHost()->MHH_GetSelListModel();
  352.     TSelListModel::TIndexVector vIndices;
  353.     pModel->SLM_GetSelectedIndices(vIndices);
  355.     const IAlnMultiDataSource* pAlnDS = x_GetHost()->MHH_GetAlnDS();
  356.             
  357.     // for each selected Line
  358.     ITERATE(TSelListModel::TIndexVector, it, vIndices)  {
  359.         TNumrow Row = x_GetHost()->MHH_GetRowByLine(*it);
  360.         TSeqRange HitR;
  361.         
  362.         // hit testing Mark corresponding to the Row (if it exists)
  363.         bool bHitStart = false;
  364.         SMarkDelta::EExtState StartState, State;
  366.         TRowToMarkMap::iterator itM = m_mpRowToMark.find(Row);
  367.         if(itM != m_mpRowToMark.end())   {
  368.             TRangeColl& Mark = itM->second;
  369.             x_HitTest(Row, Mark, X, HitR, bHitStart);
  370.         } else { // if Mark does not exist - create it
  371. m_mpRowToMark[Row] = TRangeColl(); 
  372. }
  373.         
  374.         TSeqPos StartPos;
  375.         if(HitR.NotEmpty()) {   // hit a border of the marked range
  376.             StartState = State = bHitStart ? SMarkDelta::eExtRangeStart : SMarkDelta::eExtRangeEnd;
  377.             StartPos = bHitStart ? HitR.GetFrom() : HitR.GetToOpen();        
  378.         } else {        
  379.             StartState = SMarkDelta::eNoExt;
  380.             State = SMarkDelta::eExtRangeEnd;    
  382.             TModelUnit mX = x_MouseToSeqPos(); //###
  383.             StartPos = (TSeqPos) floor(mX);
  384.             StartPos = pAlnDS->GetSeqPosFromAlnPos(Row, StartPos,
  385.                                                    IAlnMultiDataSource::
  386.                                                    TSearchDirection::eRight);
  388.             HitR.SetFrom(StartPos);
  389.             HitR.SetLength(0);
  390.         }
  391.     
  392.     // initate Map record    
  393.         m_mpRowToDelta[Row] = SMarkDelta(HitR, TSeqRange(StartPos, StartPos - 1), StartState, State);        
  394.     }
  395. }
  397. //returns true if mouse pointer is over selected line
  398. bool    CAlignMarkHandler::x_HitSelectedLine()
  399. {
  400.     const TSelListModel* pModel = x_GetHost()->MHH_GetSelListModel();
  401.     int Y = Fl::event_y();
  402.     int Index = x_GetHost()->MHH_GetLineByWindowY(Y);
  404.     return Index >=0  &&  pModel->SLM_IsItemSelected(Index); 
  405. }
  407. // returns true if mouse pointer is located over the end of one of the marked segments
  408. bool    CAlignMarkHandler::x_HitRangeBorder() const
  409. {
  410.     int X = Fl::event_x();
  411.     int Y = Fl::event_y();
  412.     int Index = x_GetHost()->MHH_GetLineByWindowY(Y);
  413.     
  414.     if(Index >= 0)  {
  415.         const TSelListModel* pModel = x_GetHost()->MHH_GetSelListModel();
  416.        
  417.         if(pModel->SLM_IsItemSelected(Index))   { 
  418.             TNumrow Row = x_GetHost()->MHH_GetRowByLine(Index);
  419.             TSeqRange HitR;
  420.             bool bHitStart = false;
  421.             // test the Mark corresponding to the Row
  422.             TRowToMarkMap::const_iterator it = m_mpRowToMark.find(Row);
  423.             if(it != m_mpRowToMark.end())   {
  424.                 const TRangeColl& Mark = it->second;
  425.                 x_HitTest(Row, Mark, X, HitR, bHitStart);
  426.                 if(HitR.NotEmpty())
  427.                     return true;
  428.             }
  429.         }
  430.     }
  431.     return false;
  432. }
  434. // perfroms a hit test of a given position "X" agains given TRangeColl C
  435. // if positions hits a range in the C, this range is returned in "Range"
  436. // (in "sequence" coordinates), overwise "Range" is set empty. If position 
  437. // hits the start of a range then "bHitStart" is assigned "true"
  438. void    CAlignMarkHandler::x_HitTest(TNumrow Row, const TRangeColl& C, int X, TSeqRange& Range, bool& bHitStart) const
  439. {
  440.     _ASSERT(m_pPane);    
  441.     
  442.     int MinD = -1;
  443.     bool bMinStart = false;
  444.     TRangeColl::const_iterator itMinRange = C.end();
  445.     const IAlnMultiDataSource *pAlnDS = x_GetHost()->MHH_GetAlnDS();
  447.     ITERATE(TRangeColl, itR, C)  { // iterating by Ranges in C
  448.         TSeqPos From = pAlnDS->GetAlnPosFromSeqPos(Row, itR->GetFrom());
  449.         TSeqPos To = pAlnDS->GetAlnPosFromSeqPos(Row, itR->GetTo());
  450.         TSeqRange  AlnR(From, To);
  452.         int FromX = m_pPane->ProjectX(AlnR.GetFrom());
  453.         int ToX = m_pPane->ProjectX(AlnR.GetToOpen());
  454.         
  455.         int D = abs(X - FromX); // distance from the start of the range
  456.         if(MinD < 0 || MinD > D)    {
  457.             MinD = D;
  458.             bMinStart = true;
  459.             itMinRange = itR;
  460.         }
  462.         D = abs(X - ToX); // distance from the stop of the range
  463.         if(MinD > D)    {
  464.             MinD = D;
  465.             bMinStart = false;
  466.             itMinRange = itR;
  467.         }        
  468.     }
  470.     if(MinD > -1  && MinD <= CAlnMultiSettings::GetDragThreshold()) {
  471.         bHitStart = bMinStart;
  472.         _ASSERT(itMinRange != C.end());
  473.         Range  = *itMinRange;
  474.     } else Range.SetLength(0);
  475. }
  477. TSeqPos CAlignMarkHandler::x_ClipPosByRange(TSeqPos Pos)
  478. {
  479.     TModelRect rcL = m_pPane->GetModelLimitsRect();
  480.     Pos = min(Pos, (TSeqPos) rcL.Right() - 1);
  481.     Pos = max(Pos, (TSeqPos) rcL.Left());
  482.     return Pos;
  483. }
  485. // updates Ranges being dragged accordingly to the given position
  486. void    CAlignMarkHandler::x_UpdateSelection(TSeqPos Pos)
  487. {
  488.     const IAlnMultiDataSource* pAlnDS = x_GetHost()->MHH_GetAlnDS();
  490.     NON_CONST_ITERATE(TRowToDeltaMap, it, m_mpRowToDelta)    {
  491.         SMarkDelta& Delta = it->second;
  493.         TSeqPos SeqPos = pAlnDS->GetSeqPosFromAlnPos(it->first, Pos,
  494.                                                      IAlnMultiDataSource::
  495.                                                      TSearchDirection::eRight);
  496.         x_UpdateDelta(Delta.m_Range, Delta.m_State, SeqPos);
  497.     }
  498. }
  500. // update given range so that the range end specified by "State" becomes equal
  501. // to "Pos".
  502. void    CAlignMarkHandler::x_UpdateDelta(TSeqRange& R, 
  503.                                     SMarkDelta::EExtState& State, TSeqPos Pos)
  504. {
  505.     if(State == SMarkDelta::eNoExt  &&  Pos != R.GetFrom())   {
  506.         if(Pos > R.GetFrom()) {
  507.             R.SetToOpen(Pos);
  508.             State = SMarkDelta::eExtRangeEnd;
  509.         } else  {
  510.             R.SetToOpen(R.GetFrom());
  511.             R.SetFrom(Pos);
  512.             State = SMarkDelta::eExtRangeStart;
  513.         }
  514.     } else if(State == SMarkDelta::eExtRangeEnd &&  Pos != R.GetToOpen()) {
  515.         if(Pos > R.GetFrom())  { 
  516.             R.SetToOpen(Pos);
  517.         } else { //flip
  518.             R.SetToOpen(R.GetFrom());
  519.             R.SetFrom(Pos);
  520.             State = SMarkDelta::eExtRangeStart;
  521.         }
  522.     } else if(State == SMarkDelta::eExtRangeStart  &&  Pos != R.GetFrom())    {
  523.         if(Pos <= R.GetToOpen())  { 
  524.             R.SetFrom(Pos);
  525.         } else {
  526.             R.SetFrom(R.GetToOpen());
  527.             R.SetToOpen(Pos);
  528.             State = SMarkDelta::eExtRangeEnd;
  529.         }
  530.     }
  531. }
  533. void CAlignMarkHandler::x_UpdateMarks()
  534. {
  535.     ITERATE(TRowToDeltaMap, it, m_mpRowToDelta)    {
  536.         TNumrow Row = it->first;
  537.         TRowToMarkMap::iterator itMark = m_mpRowToMark.find(Row);
  538.         if(itMark == m_mpRowToMark.end())   {
  539.             itMark = m_mpRowToMark.insert(
  540.                         TRowToMarkMap::value_type(Row, TRangeColl())).first;
  541.         }
  542.         TRangeColl& C = itMark->second;
  544.         const SMarkDelta& Delta = it->second;    
  545.         const TSeqRange& R = Delta.m_Range;
  546.         const TSeqRange& HitR = Delta.m_HitRange;
  547.         
  548.         switch(Delta.m_StartState)  {
  549.         case SMarkDelta::eNoExt:    {
  550.             if(R.NotEmpty())
  551.                 C.CombineWith(R);
  552.         }; break;
  553.         case SMarkDelta::eExtRangeEnd:  {
  554.             if(R.GetTo() > HitR.GetTo())  {
  555.                 C.CombineWith(R);
  556.             } else {
  557.                 TSeqPos P = max(HitR.GetFrom(), R.GetFrom());
  558.                 C.Subtract(TSeqRange(P, HitR.GetTo()));
  559.                 if(R.GetFrom() < HitR.GetFrom())
  560.                     C.CombineWith(TSeqRange(R.GetFrom(), HitR.GetFrom() - 1));
  561.             }
  562.         }; break;
  563.         case SMarkDelta::eExtRangeStart:  {
  564.             if(R.GetFrom() < HitR.GetFrom())  {
  565.                 C.CombineWith(R);
  566.             } else {
  567.                 TSeqPos P = min(HitR.GetTo(), R.GetTo());
  568.                 C.Subtract(TSeqRange(HitR.GetFrom(), P));
  569.                 if(R.GetTo() > HitR.GetTo())
  570.                     C.CombineWith(TSeqRange(HitR.GetToOpen(), R.GetTo()));
  571.             }
  572.         }; break;
  573.         };
  574.     }
  575.     m_mpRowToDelta.clear();
  576. }
  578. void    CAlignMarkHandler::Render(CGlPane& pane)
  579. {
  580.     TModelRect rcV = pane.GetVisibleRect();
  581.     
  582.     const IAlnMultiDataSource* pAlnDS = x_GetHost()->MHH_GetAlnDS();
  583.     const TSelListModel* pModel = x_GetHost()->MHH_GetSelListModel();        
  584.  
  585.     if(! rcV.IsEmpty()  && pAlnDS  && pModel) {
  586.         TVPRect rcVP = pane.GetViewport();
  588.         pane.OpenOrtho();
  590.         TModelUnit offset_x = pane.GetOffsetX();
  591.         TModelUnit offset_y = pane.GetOffsetY();
  592.         
  593.         ITERATE(TRowToMarkMap, itM, m_mpRowToMark)  { // for each Mark
  594.             TNumrow Row = itM->first; 
  595.             int Index = x_GetHost()->MHH_GetLineByRowNum(Row);
  596.                             
  597.             if(Index >= 0)  { // row exists      
  598.                           
  599.                 TModelUnit top_y = x_GetHost()->MHH_GetLinePosY(Index);
  600.                 TModelUnit bottom_y = top_y + x_GetHost()->MHH_GetLineHeight(Index) - 1;
  601.                 bool bVisible = ! (bottom_y < rcV.Top()  ||  top_y > rcV.Bottom());
  602.                 
  603.                 if(bVisible) {
  604.                     bool bSelected = pModel->SLM_IsItemSelected(Index);
  605.                     const TRangeColl& Mark = itM->second;
  607.                     // draw existing mark
  608.                     ITERATE(TRangeColl, itR, Mark)  { // for each Range in Mark
  609.                         TSeqPos From = pAlnDS->
  610.                             GetAlnPosFromSeqPos(Row, itR->GetFrom(),
  611.                                                 IAlnMultiDataSource::
  612.                                                 TSearchDirection::eRight);
  613.                         TSeqPos To = pAlnDS->
  614.                             GetAlnPosFromSeqPos(Row, itR->GetTo(),
  615.                                                 IAlnMultiDataSource::
  616.                                                 TSearchDirection::eLeft);
  617.                         TSeqRange R(From ,To);
  619.                         glColorC(m_FillColor);
  620.                         glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
  621.                         glRectd(R.GetFrom() - offset_x, bottom_y - offset_y, 
  622.                                 R.GetToOpen() - offset_x, top_y - offset_y);
  623.                         
  624.                         if(bSelected)   {                            
  625.                             glColorC(m_FrameColor);
  626.                             glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
  627.                             glRectd(R.GetFrom() - offset_x, bottom_y - offset_y, 
  628.                                     R.GetToOpen() - offset_x, top_y - offset_y);
  629.                         }
  630.                     }
  632.                     // draw Delta - range being edited
  633.                     TRowToDeltaMap::const_iterator itD = m_mpRowToDelta.find(Row);
  634.                     if(itD != m_mpRowToDelta.end())  {
  635.                         const SMarkDelta& Delta = itD->second;
  636.                         const TSeqRange& delta_R = Delta.m_Range;
  638.                         TSeqPos From = pAlnDS->
  639.                             GetAlnPosFromSeqPos(Row, delta_R.GetFrom(),
  640.                                                 IAlnMultiDataSource::
  641.                                                 TSearchDirection::eRight);
  642.                         TSeqPos To = pAlnDS->
  643.                             GetAlnPosFromSeqPos(Row, delta_R.GetTo(),
  644.                                                 IAlnMultiDataSource::
  645.                                                 TSearchDirection::eLeft);
  646.                         TSeqRange R(From ,To);
  648.                         glColor4d(0.25, 0.25, 1.0, 1.0);
  649.                         glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
  650.                         glRectd(R.GetFrom() - offset_x, bottom_y - offset_y, 
  651.                                 R.GetToOpen() - offset_x, top_y - offset_y);
  652.                     }
  653.                 }
  654.             }
  655.         }
  656.         pane.Close();
  657.     }
  658. }
  660. END_NCBI_SCOPE
  662. /*
  663.  * ===========================================================================
  664.  * $Log: align_mark_handler.cpp,v $
  665.  * Revision 1000.3  2004/06/01 21:06:57  gouriano
  666.  * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.17
  667.  *
  668.  * Revision 1.17  2004/05/21 22:27:52  gorelenk
  669.  * Added PCH ncbi_pch.hpp
  670.  *
  671.  * Revision 1.16  2004/04/02 17:09:40  yazhuk
  672.  * Updated function calls to renamed function
  673.  *
  674.  * Revision 1.15  2004/03/11 17:50:41  dicuccio
  675.  * Updated typedefs: dropped TDimension, TPosition, TIndex, TColor; use TSeqRange
  676.  * instead of TRange
  677.  *
  678.  * Revision 1.14  2003/12/18 21:13:08  yazhuk
  679.  * Updated code to supported template ISelListModel
  680.  *
  681.  * Revision 1.13  2003/12/10 17:11:38  yazhuk
  682.  * Clean-up.
  683.  *
  684.  * Revision 1.12  2003/12/08 15:15:55  yazhuk
  685.  * Implemented workaround for OpenGL precision problems.
  686.  *
  687.  * Revision 1.11  2003/12/05 17:51:57  yazhuk
  688.  * Disabled traces
  689.  *
  690.  * Revision 1.10  2003/12/01 16:43:18  yazhuk
  691.  * Refactored event handling - introduced CGUIEvent
  692.  *
  693.  * Revision 1.9  2003/11/26 16:52:00  johnson
  694.  * switch IAlnMultiDataSource to use CAlnMap::ESearchDirection instead of it's
  695.  * own ESearchDirection
  696.  *
  697.  * Revision 1.8  2003/10/29 23:23:25  yazhuk
  698.  * Replaced CAlnMultiDataSource with IAlignMultiDataSource
  699.  *
  700.  * Revision 1.7  2003/10/20 15:47:31  yazhuk
  701.  * Changed keyboard events handling policy. Clean-up.
  702.  *
  703.  * Revision 1.6  2003/10/15 21:27:19  yazhuk
  704.  * Migrated from using CAlnVec to accessing data via "generic" interface in CAlignDataSource.
  705.  *
  706.  * Revision 1.5  2003/10/12 16:28:40  ucko
  707.  * Properly capitalize (and <delimit>, while I'm at it) FLTK headers
  708.  *
  709.  * Revision 1.4  2003/09/29 13:45:49  yazhuk
  710.  * Added GetMarks()
  711.  *
  712.  * Revision 1.3  2003/09/25 20:47:10  yazhuk
  713.  * Fixed problem with displaying marks over inserts
  714.  *
  715.  * Revision 1.2  2003/09/24 02:52:54  ucko
  716.  * Add missing include of <math.h>
  717.  *
  718.  * Revision 1.1  2003/09/23 21:18:25  yazhuk
  719.  * Initial revision
  720.  *
  721.  * ===========================================================================
  722.  */