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

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

生物技术

开发平台：

C/C++

alnmulti_pane.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: alnmulti_pane.cpp,v $
  4.  * PRODUCTION Revision 1000.6  2004/06/01 21:07:09  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.42
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: alnmulti_pane.cpp,v 1000.6 2004/06/01 21:07:09 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.  *
  39.  */
  41. #include <ncbi_pch.hpp>
  42. #include <corelib/ncbistl.hpp>
  43. #include <corelib/ncbitime.hpp>
  45. #include <gui/opengl/glutils.hpp>
  46. #include <gui/utils/command.hpp>
  47. #include <gui/widgets/aln_multiple/alnmulti_settings.hpp>
  48. #include <gui/widgets/aln_multiple/alnmulti_pane.hpp>
  49. #include <algorithm>
  52. #include <FL/Fl.H>
  54. BEGIN_NCBI_SCOPE
  56. static const int kRulerSpace = 4;
  57. static const int kMasterRowSpace = 4;
  59. CAlnMultiPane::CAlnMultiPane(int PosX, int PosY, int Width, int Height, const char* Label)
  60. : CGlCanvas2d(PosX, PosY, Width, Height, Label),
  61.   m_pParent(NULL),
  62.   m_pModel(NULL),
  63.   m_pCurrHandler(NULL),
  64.   m_Renderer(TVPRect(0, 0, Width, Height))
  65. {
  66.     m_Tooltip.SetMode(CTooltip::eHideOnMove);
  68.     m_HandlerPane.EnableOffset();
  70.     m_Renderer.SetBackColor(CGlColor(0.95f, 1.0f, 0.95f));
  71.     
  72.     //setup Event Handlers
  73.     m_MarkHandler.SetHost(static_cast<IAlignMarkHandlerHost*>(this));
  74.     x_AddHandler(dynamic_cast<IEventHandler*>(&m_MarkHandler), fAlignArea);
  76.     m_SelHandler.SetHost(static_cast<ISelHandlerHost*>(this));
  77.     x_AddHandler(dynamic_cast<IEventHandler*>(&m_SelHandler), fAlignArea);
  78.     
  79.     m_MouseZoomHandler.SetHost(static_cast<IMouseZoomHandlerHost*>(this));
  80.     x_AddHandler(dynamic_cast<IEventHandler*>(&m_MouseZoomHandler), fAlignArea);
  82.     x_AddHandler(dynamic_cast<IEventHandler*>(this), fDescrArea);
  84.     m_Event.StandardConfig();
  85. }
  87. void CAlnMultiPane::SetWidget(IAlnMultiPaneParent* p_parent)
  88. {
  89.     m_pParent = p_parent;
  90. }
  92. void CAlnMultiPane::SetContext(IAlnMultiRendererContext* p_context)    
  93. {
  94.     m_pContext = p_context;
  95.     m_Renderer.SetContext(m_pContext);
  97.     if(m_pContext)   {
  98.         m_HandlerPane = x_GetContext()->GetAlignPort();
  99.     }
  100. }
  102. void    CAlnMultiPane::SetBackColor(const CGlColor Color)
  103. {
  104.     m_Renderer.SetBackColor(Color);
  105. }
  107. CRuler&    CAlnMultiPane::GetRuler()
  108. {
  109.     return m_Renderer.GetRuler();
  110. }
  112. CAlnMultiRenderer&  CAlnMultiPane::GetRenderer()
  113. {
  114.     return m_Renderer;
  115. }
  117. void    CAlnMultiPane::resize(int x, int y, int w, int h)
  118. {
  119.     CGlCanvas2d::resize(x, y, w, h);
  120.     
  121.     m_Renderer.Resize(TVPRect(0, 0, w - 1, h - 1));
  122.     
  123.     if(x_GetParent())   
  124.         x_GetParent()->OnChildResize();
  125. }
  127. int  CAlnMultiPane::handle(int event)
  128. {
  129.     m_Event.OnFLTKEvent(event);
  131.     int res = 0;
  132.     switch(event)   {
  133.     case FL_FOCUS:
  134.     case FL_UNFOCUS:    redraw();   return 1;
  135.     case FL_KEYDOWN:
  136.     case FL_KEYUP:  res = x_HandleKeyEvent(); break;
  137.     case FL_MOVE:   res = x_HandleMouseMove(); break;
  138.     case FL_PUSH:   res = x_HandleMousePush(); break;
  139.     case FL_DRAG: res = x_HandleMouseDrag(); break;
  140.     case FL_RELEASE: res = x_HandleMouseRelease(); break;
  141.     case FL_MOUSEWHEEL: res = x_HandleMouseWheel(); break;
  142.     case FL_ENTER: 
  143.     case FL_LEAVE:  
  144.         //fl_cursor(FL_CURSOR_DEFAULT, FL_BLACK, FL_WHITE); // drop to default
  145.     default: res = CGlCanvas2d::handle(event);
  146.     }     
  148.     m_Tooltip.Handle(event);  
  149.     return res;
  150. }
  152. int    CAlnMultiPane::x_HandleKeyEvent()
  153. {
  154.     IEventHandler* pH = NULL; //dummy
  155.     int res = x_Handlers_handle(fAllAreas, pH, false);    
  157.     if(res == 0  &&  m_Event.GetFLTKEvent() == FL_KEYDOWN)   {
  158.         switch(m_Event.GetGUISignal())   {
  159.         case CGUIEvent::eZoomInSignal:  x_SendCommand(eCmdZoomIn); break;
  160.         case CGUIEvent::eZoomOutSignal:  x_SendCommand(eCmdZoomOut); break;
  161.         case CGUIEvent::eZoomAllSignal:  x_SendCommand(eCmdZoomAll); break;  
  162.         default: break;
  163.         }
  164.     }
  165.     return res;
  166. }
  168. void   CAlnMultiPane::x_SendCommand(TCmdID cmd)
  169. {
  170.     CCommandTarget* target = dynamic_cast<CCommandTarget*>(m_pParent);
  171.     if(target)  {
  172.         target->OnCommand(cmd);
  173.     }
  174. }
  176. int    CAlnMultiPane::x_HandleMouseMove()
  177. {
  178.     int res = 0;
  179.     IEventHandler* pH = NULL; //dummy
  181.     EColumnType type = m_Renderer.GetColumnTypeByX(Fl::event_x());
  182.     
  183.     switch(type)  {
  184.     case IAlignRow::eDescr: res = x_Handlers_handle(fDescrArea, pH, true); break;
  185.     case IAlignRow::eAlignment: 
  186.         res = x_Handlers_handle(fAlignArea, pH); break;
  187.     default: break;
  188.     }
  189.     if(res == 0)    { 
  190.         fl_cursor(FL_CURSOR_DEFAULT, FL_BLACK, FL_WHITE); 
  191.     }    
  193.     x_UpdateTooltip();
  194.     
  195.     m_pCurrHandler = NULL;
  196.     return res;
  197. }
  199. int    CAlnMultiPane::x_HandleMousePush()
  200. {
  201.     if(Fl::focus() != static_cast<Fl_Widget*>(this))    {
  202.         take_focus();
  203.         
  204.         m_Event.OnFLTKEvent(FL_PUSH); // restore event state after focus handling
  205.     }
  206.     
  207.     int res = 0;
  208.     if(m_Event.GetGUISignal() == CGUIEvent::ePopupSignal)   {
  209.         x_GetParent()->OnShowPopup();
  210.         res = 1;
  211.     } else {
  212.         IEventHandler* pH = NULL; //dummy
  214.         EColumnType type = m_Renderer.GetColumnTypeByX(Fl::event_x());
  215.     
  216.         switch(type)  {
  217.         case IAlignRow::eDescr: res = x_Handlers_handle(fDescrArea, pH, true); break;
  218.         case IAlignRow::eIcons: res = x_Row_handle(); break;
  219.         case IAlignRow::eAlignment: 
  220.             res = x_Handlers_handle(fAlignArea, pH); break;
  221.         default: break;
  222.         }
  223.         m_pCurrHandler = pH;
  224.     }    
  225.     if(res == 0)    {
  226.         fl_cursor(FL_CURSOR_DEFAULT, FL_BLACK, FL_WHITE); 
  227.     }
  228.     return res;
  229. }
  231. int    CAlnMultiPane::x_HandleMouseDrag()
  232. {
  233.     int res = 0;
  234.     if(m_pCurrHandler)  {
  235.         res = m_pCurrHandler->handle(m_Event, m_HandlerPane);
  236.     }
  237.     if(res ==0) {
  238.         fl_cursor(FL_CURSOR_DEFAULT, FL_BLACK, FL_WHITE); 
  239.     }
  240.     return res;
  241. }
  243. int    CAlnMultiPane::x_HandleMouseRelease()
  244. {
  245.     if(m_Event.GetGUISignal() == CGUIEvent::ePopupSignal)   {
  246.         x_GetParent()->OnShowPopup();
  247.         return 1;
  248.     } else return x_HandleMouseDrag();
  249. }
  251. int    CAlnMultiPane::x_HandleMouseWheel()
  252. {
  253.     IEventHandler* pH = NULL; //dummy
  254.     int res = x_Handlers_handle(fAllAreas, pH, false);    
  255.     if(! res)   {
  256.         int d_y = Fl::event_dy();
  257.         x_GetParent()->OnScroll(0, (TModelUnit) d_y);
  258.     }
  259.     return res;
  260. }
  262. int    CAlnMultiPane::x_Row_handle()
  263. {
  264.     int i_line = x_GetLineByWindowY(Fl::event_y());
  265.     if(i_line >= 0)  {
  266.         IAlignRow* p_row = x_GetContext()->GetRowByLine(i_line);
  267.         _ASSERT(p_row);
  268.         
  269.         int i_col = m_Renderer.GetColumnIndexByX(Fl::event_x());
  270.         IAlignRow::EColumnType type = (IAlignRow::EColumnType) 
  271.                                 (int) m_Renderer.GetColumn(i_col).m_UserData;
  273.         const CGlPane& VP = x_GetContext()->GetAlignPort();        
  274.         int vp_top_y = m_Renderer.GetVPListTop() + (int) VP.GetVisibleRect().Top() 
  275.                     - x_GetContext()->GetLinePosY(i_line);
  277.         CGlPane pane(CGlPane::eNeverUpdate);       
  278.         pane.EnableOffset();
  280.         m_Renderer.SetupPaneForRow(pane, p_row, vp_top_y);
  281.         m_Renderer.SetupPaneForColumn(pane, i_col);
  283.         return p_row->handle(m_Event, type, pane);
  284.     }
  285.     return 0;
  286. }
  288. void    CAlnMultiPane::x_UpdateTooltip()
  289. {
  290.     int x = Fl::event_x();
  291.     int y = Fl::event_y();
  292.         
  293.     int vp_top = m_Renderer.GetRulerAreaHeight() + m_Renderer.GetMasterAreaHeight();
  294.     bool b_deactivate = true;
  295.     IAlignRow* p_row = NULL;
  296.     int row_top_y = 0; 
  298.     if(x_GetContext()->GetMasterRow()  &&  
  299.        y >= m_Renderer.GetRulerAreaHeight() + kMasterRowSpace  &&
  300.        y < vp_top - kMasterRowSpace)   {
  302.         p_row = x_GetContext()->GetMasterRow();
  303.         row_top_y = m_Renderer.GetRulerAreaHeight() + kMasterRowSpace;
  305.     } else  if(y >= vp_top  &&  y < h())    { // show tooltips only for rows
  306.         int line =  x_GetLineByWindowY(y);  
  307.         if(line >= 0)   {      
  308.             p_row = x_GetContext()->GetRowByLine(line);
  309.             row_top_y = x_GetContext()->GetLinePosY(line);
  310.         }
  311.     }
  313.     if(p_row)  {                    
  314.         int i_col = m_Renderer.GetColumnIndexByX(x);
  315.         if(i_col != -1) {
  316.             const CGlPane& VP = x_GetContext()->GetAlignPort();        
  317.             int vp_top_y = m_Renderer.GetVPListTop() + (int) VP.GetVisibleRect().Top() - row_top_y;
  319.             string s_tip = x_GetRowTooltip(p_row, i_col, vp_top_y);
  321.             if(s_tip.size())   {
  322.                 b_deactivate = false;
  323.                 m_Tooltip.Activate(this, s_tip, x, y);
  324.             }
  325.         }
  326.     }
  327.     if(b_deactivate)    {
  328.         m_Tooltip.Deactivate(true);
  329.     }    
  330. }
  332. string CAlnMultiPane::x_GetRowTooltip(IAlignRow* p_row, int i_col, int vp_top_y)
  333. {
  334.     CGlPane pane;       
  335.     pane.EnableOffset();
  337.     m_Renderer.SetupPaneForRow(pane, p_row, vp_top_y);        
  338.     m_Renderer.SetupPaneForColumn(pane, i_col);
  339.     
  340.     EColumnType type = m_Renderer.GetColumnTypeByIndex(i_col);
  341.     return p_row->GetTooltip(type, pane);
  342. }
  344. ///////////////////////////////////////////////////////////////////////////////
  345. // Handlers management
  347. void    CAlnMultiPane::x_AddHandler(IEventHandler* handler, int area)
  348. {
  349.     _ASSERT(handler  &&  area);
  351.     m_lsHandlers.push_back(make_pair(handler, area));
  352. }
  354. int CAlnMultiPane::x_Handlers_handle(int area, 
  355.                                      IEventHandler*& handler, bool ignore_curr)
  356. {    
  357.     int res = 0;
  358.  
  359.     IEventHandler* pFirst = ignore_curr ? NULL : m_pCurrHandler;
  360.     if(pFirst)  {
  361.         handler = m_pCurrHandler;
  362.         res = m_pCurrHandler->handle(m_Event, m_HandlerPane);
  363.     }
  364.     
  365.     if(res == 0)    { // not handles by pFirst - iterate through over handlers
  366.         NON_CONST_ITERATE(THandlerList, it, m_lsHandlers) {
  367.             handler = it->first;
  368.             if( (it->second & area)  &&  (handler != pFirst) )    {
  369.                 res = handler->handle(m_Event, m_HandlerPane);
  370.                 if(res) break;
  371.             }
  372.         }
  373.     }
  374.     if(res == 0)    handler = NULL;
  375.     return res;
  376. }
  378. void    CAlnMultiPane::draw()
  379. {    
  380.     Render();    
  381. }
  383. void    CAlnMultiPane::Render()
  384. {
  385.     //_TRACE("nnCAlnMultiPane::Render()");
  386.     //CStopWatch sw;
  387.     //sw.Start();
  388.     
  389.     m_Renderer.SetFocused(Fl::focus() == this);
  390.     //CAlnMultiRenderer::TAreaVector areas;
  391.     //m_Renderer.Render(areas);
  392.     m_Renderer.Render();
  394.     x_RenderSelection();  
  395.     x_RenderMark(); 
  396.     x_RenderZoomHandler();
  398.     //_TRACE("nEND CAlnMultiPane::Render()  " << sw.Elapsed());
  399. }
  401. void    CAlnMultiPane::Update() 
  402. {
  403.     //_TRACE("nnBEGIN CAlnMultiPane::Update() ");        
  404.     m_Renderer.Update();
  406.     if(x_GetParent())   
  407.         x_GetParent()->OnChildResize();
  408.     //_TRACE("nEND CAlnMultiPane::Update() ");
  409. }
  411. //
  412. void    CAlnMultiPane::SetRulerHeight(int height)
  413. {
  414.     m_Renderer.SetRulerHeight(height);
  415. }
  417. CRange<TSeqPos> CAlnMultiPane::GetSelectionLimits()
  418. {
  419.     return m_SelHandler.GetSelectionLimits();
  420. }
  422. const CAlnMultiPane::TRangeColl&   CAlnMultiPane::GetSelection() const
  423. {
  424.     return m_SelHandler.GetSelection();
  425. }
  427. void    CAlnMultiPane::SetSelection(const TRangeColl& C, bool bRedraw)
  428. {
  429.     m_SelHandler.SetSelection(C, bRedraw);
  430. }
  432. void    CAlnMultiPane::ResetSelection(bool bRedraw)
  433. {
  434.     m_SelHandler.ResetSelection(bRedraw);
  435. }
  437. void    CAlnMultiPane::MarkSelectedRows(const TRangeColl& C, bool bMark)
  438. {
  439.     m_MarkHandler.MarkSelectedRows(C, bMark);
  440. }
  442. void    CAlnMultiPane::UnMarkAll()
  443. {
  444.     m_MarkHandler.UnMarkAll();
  445. }
  447. const   CAlnMultiPane::TRowToMarkMap&  CAlnMultiPane::GetMarks() const
  448. {
  449.     return m_MarkHandler.GetMarks();
  450. }
  451. int     CAlnMultiPane::GetAlignVPHeight() const
  452. {
  453.     return GetListAreaHeight();
  454. }
  456. int     CAlnMultiPane::GetAlignVPWidth() const
  457. {
  458.     int iAlign = m_Renderer.GetColumnIndexByType(IAlignRow::eAlignment);
  459.     return m_Renderer.GetColumn(iAlign).m_Width;
  460. }
  462. ////////////////////////////////////////////////////////////////////////////////
  463. /// protected members
  465. void    CAlnMultiPane::x_RenderSelection()
  466. {
  467.     if(x_GetParent()) {
  468.         const CGlPane& VP = x_GetContext()->GetAlignPort();
  469.         if(! VP.GetVisibleRect().IsEmpty())
  470.         {   
  471.             TVPRect rc_vp = m_Renderer.GetColumnRect(IAlignRow::eAlignment);
  472.             if(rc_vp.Width() > 0)   {
  473.                 m_HandlerPane.EnableOffset();
  474.                 m_HandlerPane.SetViewport(rc_vp);
  475.     
  476.                 TModelRect rcM = VP.GetModelLimitsRect();  
  477.                 rcM.SetVert(0, 1);          
  478.                 m_HandlerPane.SetModelLimitsRect(rcM);    
  480.                 TModelRect rcV = VP.GetVisibleRect();        
  481.                 rcV.SetVert(0, 1);          
  482.                 m_HandlerPane.SetVisibleRect(rcV);
  484.                 glEnable(GL_BLEND);
  485.                 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  487.                 m_SelHandler.Render(m_HandlerPane);
  488.        
  489.                 glDisable(GL_BLEND);
  490.             }
  491.         }
  492.     }
  493. }
  495. void    CAlnMultiPane::x_RenderMark()
  496. {
  497.     if(x_GetParent()) {
  498.         const CGlPane& VP = x_GetContext()->GetAlignPort();
  499.         
  500.         TVPRect rc_vp = m_Renderer.GetColumnRect(IAlignRow::eAlignment);
  501.         if(rc_vp.Width() > 0)   {
  502.             rc_vp.SetTop(m_Renderer.GetVPListTop()); 
  503.             m_HandlerPane.SetViewport(rc_vp);                
  504.         
  505.             TModelRect rcM = VP.GetModelLimitsRect();  
  506.             m_HandlerPane.SetModelLimitsRect(rcM);    
  508.             TModelRect rcV = VP.GetVisibleRect();        
  509.             rcV.SetBottom(rcV.Top() + rc_vp.Height());
  510.             m_HandlerPane.SetVisibleRect(rcV);
  512.             glEnable(GL_BLEND);
  513.             glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  515.             m_MarkHandler.Render(m_HandlerPane);        
  517.             glDisable(GL_BLEND);
  518.         }
  519.     }
  520. }
  522. void    CAlnMultiPane::x_RenderZoomHandler()
  523. {
  524.     if(x_GetParent()) {       
  525.         TVPRect rc_vp = m_Renderer.GetColumnRect(IAlignRow::eAlignment);
  526.         if(rc_vp.Width() > 0)   {
  527.             m_HandlerPane.SetViewport(rc_vp);
  528.             
  529.             glEnable(GL_BLEND);
  530.             glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  532.             m_MouseZoomHandler.Render(m_HandlerPane);
  533.        
  534.             glDisable(GL_BLEND);
  535.         }
  536.     }
  537. }
  539. int     CAlnMultiPane::x_GetLineByWindowY(int WinY) const
  540. {
  541.     int vpY = WinY - m_Renderer.GetListTop();
  542.     int OffsetY = (int) x_GetContext()->GetAlignPort().GetVisibleRect().Top();        
  543.     return x_GetContext()->GetLineByModelY(vpY + OffsetY);
  544. }
  546. TVPRect CAlnMultiPane::x_GetLineRect(int Index)
  547. {
  548.     int Top = 0, H = 0;
  549.     if(x_GetParent()  &&  Index >= 0) {
  550.         int OffsetY = (int) x_GetContext()->GetAlignPort().GetVisibleRect().Top();        
  551.         Top = x_GetContext()->GetLinePosY(Index) - OffsetY;
  552.         H = x_GetContext()->GetLineHeight(Index);
  553.     }
  554.     return TVPRect(0, Top + H -1, w()-1, Top);
  555. }
  557. ////////////////////////////////////////////////////////////////////////////////
  558. // ISelListView implementation
  559. void  CAlnMultiPane::SLV_SetModel(TSelListModel* pModel)
  560. {
  561.     m_pModel = pModel;
  562. }
  564. void  CAlnMultiPane::SLV_UpdateItems(const TIndexVector& v_indexes)
  565. {
  566.     bool bRedraw = false;
  568.     TVPRect rcVisible(0, 0, w() - 1, h() - 1);
  570.     for( size_t i = 0;  i < v_indexes.size() &&  ! bRedraw;  i++ ) {
  571.         int index = v_indexes[i];
  572.         TVPRect rcItem = x_GetLineRect(index);
  573.         bRedraw = rcItem.Intersects(rcVisible); 
  574.     }
  575.     if(bRedraw)
  576.         redraw();
  578.     x_NotifyParent(IAlnMultiPaneParent::eRowSelChanged);
  579. }
  581. void  CAlnMultiPane::SLV_UpdateRange(int iFirstItem, int iLastItem)
  582. {
  583.     if(iLastItem >= iFirstItem) {
  584.         TVPRect rcFirst = x_GetLineRect(iFirstItem);
  585.         TVPRect rcLast = x_GetLineRect(iLastItem);
  586.         rcFirst.CombineWith(rcLast);
  587.         TVPRect rcVisible(0, 0, w() - 1, h() - 1);
  588.     
  589.         if(rcFirst.Intersects(rcVisible))
  590.             redraw();
  591.     } else redraw();
  593.     x_NotifyParent(IAlnMultiPaneParent::eRowSelChanged);
  594. }
  596. ////////////////////////////////////////////////////////////////////////////////
  597. /// CSelListController extension
  598. CAlnMultiPane::TSelListModel* CAlnMultiPane::SLC_GetModel()
  599. {
  600.     return x_GetModel();
  601. }
  603. int     CAlnMultiPane::SLC_GetHeight()
  604. {
  605.     return h();
  606. }
  608. int CAlnMultiPane::SLC_GetLineByWindowY(int WinY, bool b_clip)
  609. {
  610.     int h = m_Renderer.GetRulerAreaHeight() + m_Renderer.GetMasterAreaHeight();
  611.     if(! b_clip  ||  WinY >= h) {
  612.         return  x_GetLineByWindowY(WinY);
  613.     } else return -1;
  614. }
  616. void    CAlnMultiPane::SLC_VertScrollToMakeVisible(int Index)
  617. {
  618.     // not implemented
  619. }
  621. ////////////////////////////////////////////////////////////////////////////////
  622. /// ISelHandlerHost implementation
  623. void CAlnMultiPane::SHH_Redraw()
  624. {
  625.     redraw();
  626. }
  628. TModelUnit  CAlnMultiPane::SHH_GetModelByWindow(int z, EOrientation orient)
  629. {
  630.     switch(orient)  {
  631.     case eHorz: return m_HandlerPane.UnProjectX(z);
  632.     case eVert: return m_HandlerPane.UnProjectY(h() - z);
  633.     default:    _ASSERT(false); return -1;
  634.     }
  635. }
  637. TVPUnit     CAlnMultiPane::SHH_GetWindowByModel(TModelUnit z, EOrientation orient)
  638. {
  639.     switch(orient)  {
  640.     case eHorz: return m_HandlerPane.ProjectX(z);
  641.     case eVert: return h() - m_HandlerPane.ProjectY(z);
  642.     default:    _ASSERT(false); return -1;
  643.     }
  644. }
  646. ////////////////////////////////////////////////////////////////////////////////
  647. /// IAlnMarkHandlerHost implementation
  648. const IAlnMultiDataSource*      CAlnMultiPane::MHH_GetAlnDS() const
  649. {
  650.     return x_GetParent()->GetDataSource();
  651. }
  653. const CAlnMultiPane::TSelListModel*    CAlnMultiPane::MHH_GetSelListModel() const
  654. {
  655.     return x_GetModel();
  656. }
  658. CAlnMultiPane::TNumrow    CAlnMultiPane::MHH_GetRowByLine(int Index) const
  659. {
  660.     return x_GetParent()->GetRowNumByLine(Index);
  661. }
  663. int CAlnMultiPane::MHH_GetLineByRowNum(TNumrow Row) const
  664. {
  665.     return x_GetParent()->GetLineByRowNum(Row);
  666. }
  668. int CAlnMultiPane::MHH_GetLineByWindowY(int Y) const
  669. {
  670.     return x_GetLineByWindowY(Y);
  671. }
  673. int CAlnMultiPane::MHH_GetLinePosY(int Index) const
  674. {
  675.     return x_GetContext()->GetLinePosY(Index);
  676. }
  678. int CAlnMultiPane::MHH_GetLineHeight(int Index) const
  679. {
  680.     return x_GetContext()->GetLineHeight(Index);
  681. }
  683. ///### refactor ??
  684. TModelUnit  CAlnMultiPane::MHH_GetSeqPosByX(int X) const
  685. {
  686.     return m_HandlerPane.UnProjectX(X);
  687. }
  689. void    CAlnMultiPane::MHH_Redraw()
  690. {
  691.     redraw();
  692. }
  694. TModelUnit  CAlnMultiPane::MZHH_GetScale(EScaleType type)
  695. {
  696.     const CGlPane& port = x_GetContext()->GetAlignPort();
  698.     switch(type)    {
  699.     case eCurrent:   return port.GetScaleX();
  700.     case eMin: return port.GetMinScaleX();
  701.     case eMax: return port.GetZoomAllScaleX();
  702.     default: _ASSERT(false); return -1;
  703.     }
  704. }
  706. void    CAlnMultiPane::MZHH_SetScale(TModelUnit scale, const TModelPoint& point) 
  707. {
  708.     x_GetParent()->OnSetScaleX(scale, point);
  709. }
  711. void     CAlnMultiPane::MZHH_ZoomRect(const TModelRect& rc)
  712. {
  713.     x_GetParent()->OnZoomRect(rc);
  714. }
  716. void    CAlnMultiPane::MZHH_Scroll(TModelUnit d_x, TModelUnit d_y)
  717. {
  718.     x_GetParent()->OnScroll(d_x, d_y);
  719. }
  721. TVPUnit  CAlnMultiPane::MZHH_GetVPPosByY(int y) const
  722. {
  723.     return h() - 1  - y;
  724. }
  726. void    CAlnMultiPane::MZHH_Redraw(void)
  727. {
  728.     redraw();
  729. }
  731. void    CAlnMultiPane::ARH_OnRowChanged(IAlignRow* p_row)
  732. {
  733.     x_GetParent()->OnRowChanged(p_row);
  734. }
  736. TVPPoint    CAlnMultiPane::ARH_GetVPMousePos()
  737. {
  738.     int y = h() - 1 - Fl::event_y();
  739.     int x = Fl::event_x();
  740.     return TVPPoint(x, y);
  741. }
  744. END_NCBI_SCOPE
  746. /*
  747.  * ===========================================================================
  748.  * $Log: alnmulti_pane.cpp,v $
  749.  * Revision 1000.6  2004/06/01 21:07:09  gouriano
  750.  * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.42
  751.  *
  752.  * Revision 1.42  2004/05/21 22:27:52  gorelenk
  753.  * Added PCH ncbi_pch.hpp
  754.  *
  755.  * Revision 1.41  2004/05/10 17:46:35  yazhuk
  756.  * Addressed GCC warnings
  757.  *
  758.  * Revision 1.40  2004/04/22 17:10:34  yazhuk
  759.  * Fixed rendering of focus state
  760.  *
  761.  * Revision 1.39  2004/04/06 16:05:24  yazhuk
  762.  * Clean-up
  763.  *
  764.  * Revision 1.38  2004/04/06 13:34:50  dicuccio
  765.  * Commented unused iteration over HTML active areas
  766.  *
  767.  * Revision 1.37  2004/04/05 14:50:05  yazhuk
  768.  * Zoom from keyboard
  769.  *
  770.  * Revision 1.36  2004/04/02 16:39:13  yazhuk
  771.  * Implemented parent notification about changes in selection
  772.  *
  773.  * Revision 1.35  2004/03/29 19:06:24  yazhuk
  774.  * Added GetRenderer(), implemented CHTMLActiveArea-s generation
  775.  *
  776.  * Revision 1.34  2004/03/25 13:05:49  dicuccio
  777.  * Use _TRACE() instead of cout
  778.  *
  779.  * Revision 1.33  2004/03/17 20:13:18  yazhuk
  780.  * Added SetContext(), modified SetWidget()
  781.  *
  782.  * Revision 1.32  2004/03/09 21:02:59  yazhuk
  783.  * Replaced some of the calls to x_GetParent() with x_GetContext(); cleaned-up
  784.  *
  785.  * Revision 1.31  2004/03/08 15:41:32  yazhuk
  786.  * Moved rendering to CAlnMultiRenderer class.
  787.  *
  788.  * Revision 1.30  2004/03/02 15:12:45  yazhuk
  789.  * Expanded "Icons" column
  790.  *
  791.  * Revision 1.29  2004/02/18 02:17:34  ucko
  792.  * Portability fix: don't try to use the return value of map<>::erase(),
  793.  * which yields void in many implementations.
  794.  *
  795.  * Revision 1.28  2004/02/17 15:19:24  yazhuk
  796.  * Support for graphics caching
  797.  *
  798.  * Revision 1.27  2004/01/15 20:14:46  yazhuk
  799.  * Fixed bug in focus handling; added new argument to SLC_GetLineByWindowY
  800.  *
  801.  * Revision 1.26  2004/01/08 19:43:24  yazhuk
  802.  * Refactored and improved tooltips support
  803.  *
  804.  * Revision 1.25  2003/12/29 23:21:27  yazhuk
  805.  * Implemented tooltips support using CTooltip
  806.  *
  807.  * Revision 1.24  2003/12/22 16:24:27  yazhuk
  808.  * Added SetRulerHeight(), clean-up
  809.  *
  810.  * Revision 1.23  2003/12/18 21:22:42  yazhuk
  811.  * Updated code to support template ISelListModel
  812.  *
  813.  * Revision 1.22  2003/12/10 17:10:04  yazhuk
  814.  * Updated IMouseZoomHandlerHost implementation.
  815.  * Basic support for popup menus.
  816.  *
  817.  * Revision 1.21  2003/12/08 15:15:18  yazhuk
  818.  * Removed x_RenderContent(). Implemented workaround for OpenGL precision problems.
  819.  *
  820.  * Revision 1.20  2003/12/01 17:00:22  yazhuk
  821.  * Refactored event handling - introduced CGUIEvent, updated
  822.  * ISelHandlerHost implementation.
  823.  *
  824.  * Revision 1.19  2003/11/24 20:32:22  friedman
  825.  * Commented out check for Fl:damage() == 0
  826.  *
  827.  * Revision 1.18  2003/11/24 15:15:27  dicuccio
  828.  * Added check for Fl::damage() = 0
  829.  *
  830.  * Revision 1.17  2003/11/18 17:58:08  yazhuk
  831.  * Fixed GCC warnings
  832.  *
  833.  * Revision 1.16  2003/11/17 21:20:10  yazhuk
  834.  * Fixed spelling errors, renamed GetScale() to MZHH_GetScale()
  835.  *
  836.  * Revision 1.15  2003/11/03 16:55:54  yazhuk
  837.  * Implemented IAlignRowHost interface and handling events by IAlignRow
  838.  * objects. Added x_SetupPaneForRow(), x_SetupPaneForColumn() functions.
  839.  *
  840.  * Revision 1.14  2003/10/29 23:33:16  yazhuk
  841.  * Migrated to new classes, did a lot of refactoring
  842.  *
  843.  * Revision 1.13  2003/10/20 15:50:28  yazhuk
  844.  * Implemented generalized event handling using IEventHandler. Added CMouseZoomHandler.
  845.  *
  846.  * Revision 1.12  2003/10/15 21:26:38  yazhuk
  847.  * Migrated from using CAlnVec to accessing data via "generic" interface in CAlignDataSource.
  848.  *
  849.  * Revision 1.11  2003/10/10 19:02:52  yazhuk
  850.  * Changed inheritance from CAlnMultiEditPane to CGlCanvas2d
  851.  *
  852.  * Revision 1.10  2003/09/29 17:00:09  dicuccio
  853.  * fl.H -> Fl.H
  854.  *
  855.  * Revision 1.9  2003/09/29 15:53:42  dicuccio
  856.  * Reordered #include statements
  857.  *
  858.  * Revision 1.8  2003/09/29 13:42:39  yazhuk
  859.  * Added "SeqEnd" column, implemented GetMarks()
  860.  *
  861.  * Revision 1.7  2003/09/23 21:05:20  yazhuk
  862.  * Added support for Marks, implemented mouse event handling functions, added x_RenderRow function
  863.  *
  864.  * Revision 1.6  2003/09/15 13:39:18  yazhuk
  865.  * SColumn::m_UserData compilation fix
  866.  *
  867.  * Revision 1.5  2003/09/10 21:49:47  yazhuk
  868.  * GCC compilation fixes
  869.  *
  870.  * Revision 1.4  2003/09/10 20:43:05  yazhuk
  871.  * Merged 4 Pane classes into CAlnMultiPane class. Introduced notion of Columns.
  872.  *
  873.  * Revision 1.3  2003/09/08 16:25:10  yazhuk
  874.  * Modified IAlignParent function calls
  875.  *
  876.  * Revision 1.2  2003/09/02 16:53:57  yazhuk
  877.  * GCC compilation fixes
  878.  *
  879.  * Revision 1.1  2003/08/28 18:25:28  yazhuk
  880.  * Initial revision
  881.  *
  882.  * ===========================================================================
  883.  */