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

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

生物技术

开发平台：

C/C++

mouse_zoom_handler.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: mouse_zoom_handler.cpp,v $
  4.  * PRODUCTION Revision 1000.3  2004/06/01 21:10:40  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.10
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: mouse_zoom_handler.cpp,v 1000.3 2004/06/01 21:10:40 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.  */
  40. #include <ncbi_pch.hpp>
  41. #include <corelib/ncbistd.hpp>
  43. #include <gui/opengl/glhelpers.hpp>
  44. #include <gui/widgets/gl/mouse_zoom_handler.hpp>
  46. #include <math.h>
  47. #include <FL/Fl.H>
  50. BEGIN_NCBI_SCOPE
  52. ////////////////////////////////////////////////////////////////////////////////
  53. /// class CMouseZoomHandler
  55. CMouseZoomHandler::CMouseZoomHandler()
  56. :   m_pHost(NULL),
  57.     m_State(eIdle),    
  58.     m_PixPerNorm(50),
  59.     m_MouseStartX(0), m_MouseStartY(0),
  60.     m_CurrPosX(0), m_CurrPosY(0),
  61.     m_ScaleColor(0.0f, 0.5f, 0.0f, 0.5f),
  62.     m_TickColor(1.0f, 1.0f, 1.0f),
  63.     m_RectColor(0.0f, 0.5f, 0.0f, 0.25f)
  64. {
  65. }
  67. CMouseZoomHandler::~CMouseZoomHandler()
  68. {
  69. }
  71. void    CMouseZoomHandler::SetHost(IMouseZoomHandlerHost* pHost)
  72. {
  73.     m_pHost = pHost;
  74. }
  76. static int kMarkerSize = 20;
  77. static int kMarkerOffset = 10;
  78. static int kGaugeW = 60;
  79. static int kEndTickW = 20;
  80. static int kMajorTickW = 14;
  81. static int kMinorTickW = 8;
  82. static int kCenterOffset = 4;
  84. void    CMouseZoomHandler::Render(CGlPane& pane)
  85. {
  86.     CGlAttrGuard  AttrGuard(GL_ENABLE_BIT | GL_POLYGON_BIT | GL_HINT_BIT);
  88.     switch(m_State) {
  89.     case eReadyScale:
  90.     case eScale: x_RenderScale(pane); break;
  91.     case eZoomRect: x_RenderZoomRect(pane); break;
  92.     //case ePan: x_RenderPan(pane); break; // temporary disabled
  93.     default: break;
  94.     }
  95. }
  97. void CMouseZoomHandler::x_RenderScale(CGlPane& pane)
  98. {
  99.     pane.OpenPixels();
  101.     int base_x = m_MarkerPosX;
  103.     int down_y = x_NormToPixels(m_CurrNorm);
  104.     int top_y = x_NormToPixels(m_MinNorm);    
  105.     int bottom_y = x_NormToPixels(m_MaxNorm);
  107.     glColorC(m_ScaleColor);
  108.     glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
  109.     
  110.     //drawing "gauge box"
  111.     glRectd(base_x - kGaugeW / 2, bottom_y - kCenterOffset, 
  112.             base_x + kGaugeW / 2, top_y + kCenterOffset);
  113.     
  114.     // drawing Markers
  115.     int half = kMarkerSize / 2;
  116.     x_DrawMarker(base_x - kGaugeW / 2 - kMarkerOffset, down_y, half);
  117.     x_DrawMarker(base_x + kGaugeW / 2 + kMarkerOffset, down_y, -half);
  119.     
  120.     glColorC(m_TickColor);
  121.     glLineWidth(1.0);
  122.     glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
  123.     
  124.     //drawing "gauge box"
  125.     glRectd(base_x - kGaugeW / 2, bottom_y - kCenterOffset, 
  126.             base_x + kGaugeW / 2, top_y + kCenterOffset);
  127.     
  128.     // drawing Markers
  129.     x_DrawMarker(base_x - kGaugeW / 2 - kMarkerOffset, down_y, half);
  130.     x_DrawMarker(base_x + kGaugeW / 2 + kMarkerOffset, down_y, -half);
  132.     // draw Scale - lines and ticks
  133.     glColorC(m_TickColor);
  135.     int x1 = base_x - kCenterOffset;
  136.     int x2 = base_x + kCenterOffset;
  137.     
  138.     glBegin(GL_LINES);
  139.         // draw vertical lines
  140.         glVertex2d(x1, top_y);
  141.         glVertex2d(x1, bottom_y);
  143.         glVertex2d(x2, top_y);
  144.         glVertex2d(x2, bottom_y);
  146.         // draw min-max ticks
  147.         x_DrawTicks(base_x, top_y, kEndTickW);
  148.         x_DrawTicks(base_x, bottom_y, kEndTickW);
  149.     
  150.         // draw minor ticks every 0.2 of norm value
  151.         int start_i = (int) ceil(m_MinNorm * 5);
  152.         int end_i = (int) floor(m_MaxNorm * 5);
  153.         
  154.         // draw regular ticks
  155.         for( int i = start_i; i <= end_i; i++ )   {
  156.             TModelUnit norm = 0.2 * i; 
  157.             int y = x_NormToPixels(norm);
  158.             int width = ((i - start_i) % 5) ? kMinorTickW : kMajorTickW;
  160.             x_DrawTicks(base_x, y, width);                
  161.         }        
  162.     glEnd();
  164.     pane.Close();
  165. }
  167. void CMouseZoomHandler::x_RenderZoomRect(CGlPane& pane)
  168. {
  169.     pane.OpenPixels();
  170.     
  171.     int x1 = m_MouseStartX; 
  172.     int y1 = m_pHost->MZHH_GetVPPosByY(m_MouseStartY);
  173.     int x2 = m_CurrPosX;
  174.     int y2 = m_pHost->MZHH_GetVPPosByY(m_CurrPosY);
  175.     if(x2 < x1)
  176.         swap(x1, x2);
  177.     if(y2 < y1)
  178.         swap(y1, y2);
  180.     glLineWidth(1.0f);
  181.     glColorC(m_ScaleColor);
  182.     
  183.     glLineStipple(1, 0x0F0F);
  184.     glEnable(GL_LINE_STIPPLE);
  186.     glBegin(GL_LINES);
  187.         glVertex2d(x1, y2);
  188.         glVertex2d(x2, y2);
  190.         glVertex2d(x2, y2);
  191.         glVertex2d(x2, y1);
  193.         glVertex2d(x1, y2);
  194.         glVertex2d(x1, y1);
  195.     
  196.         glVertex2d(x1, y1);
  197.         glVertex2d(x2, y1);
  198.     glEnd();
  200.     glDisable(GL_LINE_STIPPLE);
  202.     glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
  203.     glColorC(m_RectColor);
  205.     glRectd(x1, y1, x2, y2);
  206.     
  207.     pane.Close();
  208. }
  210. static const int kArrowBodyW = 10;
  211. static const int kArrowHeadW = 20;
  212. static const int kArrowHeadL = 20;
  214. void CMouseZoomHandler::x_RenderPan(CGlPane& pane)
  215. {
  216.     pane.OpenPixels();
  218.     glLineWidth(1.0f);
  219.     glColorC(m_ScaleColor);
  220.     
  221.     glEnable(GL_POLYGON_SMOOTH);
  222.     glHint(GL_POLYGON_SMOOTH_HINT, GL_FASTEST);
  224.     int x1 = m_MouseStartX; 
  225.     int y1 = m_pHost->MZHH_GetVPPosByY(m_MouseStartY);
  226.     int x2 = m_CurrPosX;
  227.     int y2 = m_pHost->MZHH_GetVPPosByY(m_CurrPosY);
  228.     
  229.     double d_x = x2 - x1;
  230.     double d_y = y2 - y1;
  231.     double angle = 90.0 * atan2(d_y, d_x) / atan2(1.0, 0.0);
  232.     double hyp = sqrt(d_x * d_x + d_y * d_y);
  234.     // move and rotate origin and then draw arrow horizontally
  235.     glTranslated(x1, y1, 0);
  236.     glRotated(angle, 0.0, 0.0, 1.0);
  237.     
  238.     glBegin(GL_QUADS);
  239.         if(hyp > kArrowHeadL)  { // draw full arrow
  240.             glVertex2d(0, kArrowBodyW);
  241.             glVertex2d(hyp - kArrowHeadL, kArrowBodyW);
  242.             glVertex2d(hyp - kArrowHeadL, -kArrowBodyW);
  243.             glVertex2d(0, -kArrowBodyW);
  245.             glVertex2d(hyp - kArrowHeadL, 0);
  246.             glVertex2d(hyp - kArrowHeadL, kArrowHeadW);
  247.             glVertex2d(hyp, 0);
  248.             glVertex2d(hyp - kArrowHeadL, -kArrowHeadW);            
  249.         } else { // draw simplified arrow
  250.             glVertex2d(0, 0);
  251.             glVertex2d(0, kArrowHeadW);
  252.             glVertex2d(hyp, 0);
  253.             glVertex2d(0, -kArrowHeadW);
  254.         }
  255.     glEnd();
  256.     
  257.     glRotated(-angle, 0.0, 0.0, 1.0);
  258.     glTranslated(-x1, -y1, 0);
  259.     
  260.     //glDisable(GL_POLYGON_SMOOTH);
  261.     
  262.     pane.Close();
  263. }
  265. void CMouseZoomHandler::x_DrawMarker(int x_c, int y_c, int half)
  266. {
  267.     glBegin(GL_POLYGON);
  268.         glVertex2d(x_c + half, y_c);
  269.         glVertex2d(x_c, y_c - half);
  270.         glVertex2d(x_c - half, y_c - half);
  271.         glVertex2d(x_c - half, y_c + half);
  272.         glVertex2d(x_c, y_c + half);
  273.     glEnd();
  274. }
  276. void CMouseZoomHandler::x_DrawTicks(int center_x, int y, int tick_w)
  277. {
  278.     int x1 = center_x - kCenterOffset;
  279.     int x2 = center_x + kCenterOffset;
  280.         
  281.     glVertex2d(x1 - tick_w, y);
  282.     glVertex2d(x1, y);
  284.     glVertex2d(x2, y);
  285.     glVertex2d(x2 + tick_w, y);
  286. }
  288. int  CMouseZoomHandler::x_NormToPixels(TModelUnit norm) const
  289. {
  290.     int y = m_pHost->MZHH_GetVPPosByY(m_CurrPosY);
  291.     return y - (int) ((norm - m_CurrNorm) * m_PixPerNorm);
  292. }
  294. int CMouseZoomHandler::handle(CGUIEvent& event, CGlPane& Pane)
  295. {
  296.     m_pPane = &Pane;
  298.     int res = 0;
  299.     switch(event.GetFLTKEvent())   {
  300.     case FL_PUSH: res =  x_OnMousePush(event); break;
  301.     case FL_DRAG: res =  x_OnMouseDrag(event); break;
  302.     case FL_RELEASE: res =  x_OnMouseRelease(event); break;
  303.     case FL_MOVE: res =  x_OnMouseMove(); break;
  304.     case FL_MOUSEWHEEL: res = x_OnMouseWheel(event); break;
  305.     case FL_KEYDOWN: res =  x_OnKeyDown(event); break;
  306.     case FL_UNFOCUS:
  307.     case FL_KEYUP: res =  x_OnKeyUp(event); break;
  308.     }
  310.     m_pPane = 0;
  311.     return res;
  312. }
  314. ////////////////////////////////////////////////////////////////////////////////
  315. /// event handlers
  317. int CMouseZoomHandler::x_OnMousePush(CGUIEvent& event)
  318. {    
  319.    if(event.GetGUISignal() == CGUIEvent::ePush  &&  Fl::event_clicks() == 0) {
  320.         CGUIEvent::EGUIState state = event.GetGUIState();
  321.         
  322.         EState ready_st = eIdle, active_st = eIdle;
  323.         switch(state)   {
  324.         case CGUIEvent::eZoomState: {
  325.             ready_st = eReadyScale;
  326.             active_st = eScale;
  327.         }; break;
  328.         case CGUIEvent::eZoomRectState: {        
  329.             ready_st = eReadyZoomRect;
  330.             active_st = eZoomRect;
  331.             x_OnSelectCursor();
  332.         }; break;
  333.         case CGUIEvent::ePanState: {        
  334.             ready_st = eReadyPan;
  335.             active_st = ePan;            
  336.         }; break;
  337.         default: break;
  338.         }
  339.         
  340.         if(ready_st != eIdle)    {
  341.             x_SwitchToReadyState(ready_st, Fl::event_x(), Fl::event_y());
  342.             x_SwithToActiveState(active_st, Fl::event_x(), Fl::event_y());
  343.             x_OnSelectCursor();
  344.         }
  345.         return 1;
  346.     }
  347.     return 0;
  348. }
  350. int CMouseZoomHandler::x_OnMouseDrag(CGUIEvent& event)
  351. {
  352.     switch(m_State) {
  353.     case eScale: {
  354.         int d_y = Fl::event_y() - m_MouseStartY;
  355.         x_OnChangeScale(d_y);
  356.     }; break;
  357.     case eZoomRect: {
  358.         x_OnChangeZoomRectPan(Fl::event_x(), Fl::event_y());
  359.     }; break;
  360.     case ePan:  {
  361.         
  362.         x_OnChangePan();
  363.         x_OnSelectCursor();
  364.     }; break;
  365.     default: break;
  366.     }
  367.     return 1; // always handle drags
  368. }
  372. void CMouseZoomHandler::x_OnChangePan()
  373. {
  374.     m_CurrPosX = Fl::event_x();
  375.     m_CurrPosY = Fl::event_y();
  376.     
  377.     int y1 = m_pHost->MZHH_GetVPPosByY(m_MouseStartY);
  378.     int y2 = m_pHost->MZHH_GetVPPosByY(m_CurrPosY);
  379.     
  380.     TModelUnit m_x1 = m_pPane->UnProjectX(m_MouseStartX);
  381.     TModelUnit m_y1 = m_pPane->UnProjectY(y1);
  382.     TModelUnit m_x2 = m_pPane->UnProjectX(m_CurrPosX);
  383.     TModelUnit m_y2 = m_pPane->UnProjectY(y2);    
  384.     
  385.     m_pHost->MZHH_Scroll(m_x1 - m_x2, m_y1 - m_y2);
  386.     m_pHost->MZHH_Redraw();
  388.     m_MouseStartX = m_CurrPosX;
  389.     m_MouseStartY = m_CurrPosY;
  390. }
  394. int CMouseZoomHandler::x_OnMouseRelease(CGUIEvent& event)
  395. {
  396.     switch(m_State) {
  397.     case eScale: {
  398.         int d_y = Fl::event_y() - m_MouseStartY;
  399.         x_OnChangeScale(d_y);
  400.         x_OnEndScale(eReadyScale);
  401.         x_OnSelectCursor();
  402.         return 1;
  403.     }; break;
  404.     case eZoomRect: {
  405.         x_OnChangeZoomRectPan(Fl::event_x(), Fl::event_y());
  406.         x_OnEndZoomRect(eReadyZoomRect);
  407.         x_OnSelectCursor();
  408.         return 1;
  409.     }; break;
  410.     case ePan: {
  411.         x_OnChangeZoomRectPan(Fl::event_x(), Fl::event_y());
  412.         x_OnEndPan(eReadyPan);
  413.         x_OnSelectCursor();
  414.         return 1;
  415.     }; break;
  416.     default: break;
  417.     }
  418.     return 0;
  419. }
  421. int CMouseZoomHandler::x_OnMouseMove(void)
  422. {
  423.     if(m_State != eIdle)    {
  424.         x_OnSelectCursor();
  425.         return 1;
  426.     }
  427.     else return  0;
  428. }
  430. static int kWheelRatio = 10;
  432. int CMouseZoomHandler::x_OnMouseWheel(CGUIEvent& event)
  433. {
  434.     if(event.GetGUIState() == CGUIEvent::eZoomState) {
  435.         switch(m_State) {
  436.         case eIdle:  
  437.             x_SwitchToReadyState(eReadyScale, Fl::event_x(), Fl::event_y()); // continue                        
  438.         case eReadyScale: {
  439.             m_WheelTotalShift = 0;            
  440.             x_SwithToActiveState(eScale, Fl::event_x(), Fl::event_y());
  441.         }; // continue
  442.         case eScale: {
  443.             m_WheelTotalShift += Fl::event_dy() * kWheelRatio; 
  444.             x_OnChangeScale(m_WheelTotalShift);
  445.             
  446.             // updating shift after clipping with Min and Max norm values
  447.             m_WheelTotalShift = (int) ((m_StartNorm - m_CurrNorm) * m_PixPerNorm);
  448.         }; break;
  449.         default: _ASSERT(false); break;
  450.         }
  451.         x_OnSelectCursor();
  452.         return 1;
  453.     } else return 0;
  455. }
  457. int CMouseZoomHandler::x_OnKeyDown(CGUIEvent& event)
  458. {
  459.     if(m_State == eIdle)    {
  460.         EState ready_st = eIdle;
  462.         switch(event.GetGUIState()) {
  463.         case CGUIEvent::eZoomState: ready_st =  eReadyScale; break;
  464.         case CGUIEvent::eZoomRectState: ready_st =  eReadyZoomRect; break;
  465.         case CGUIEvent::ePanState: ready_st =  eReadyPan; break;
  466.         default: break;
  467.         }
  469.         if(ready_st != eIdle)   {
  470.             x_SwitchToReadyState(ready_st, Fl::event_x(), Fl::event_y()); 
  471.             x_OnSelectCursor();
  472.         }
  473.     }
  474.     return (m_State == eIdle) ? 0 : 1;   
  475. }
  477. int CMouseZoomHandler::x_OnKeyUp(CGUIEvent& event)
  478. {    
  479.     CGUIEvent::EGUIState state = event.GetGUIState();
  480.     if(state != CGUIEvent::eZoomState  &&  
  481.         state != CGUIEvent::eZoomRectState)  {
  482.         switch(m_State) {
  483.         case    eIdle: break;
  484.         case    eReadyScale:
  485.         case    eReadyZoomRect:
  486.         case    eReadyPan:
  487.         case    eZoomRect: 
  488.         case    ePan: {
  489.             m_pHost->MZHH_Redraw(); 
  490.             m_State = eIdle;
  491.             x_OnSelectCursor();
  492.         }; break;
  493.         case    eScale: {
  494.             x_OnEndScale(eIdle); 
  495.             m_State = eIdle;
  496.             x_OnSelectCursor();
  497.         }; break;
  498.         default: break;
  499.         };
  500.     }    
  501.     return (m_State == eIdle) ? 0 : 1;   
  502. }
  504. ////////////////////////////////////////////////////////////////////////////////
  505. /// Signal handlers
  507. void    CMouseZoomHandler::x_SwitchToReadyState(EState new_state, int pos_x, int pos_y)
  508. {    
  509.     _ASSERT(m_pHost);
  510.     if(m_State != new_state)   {
  511.         m_State = new_state; 
  513.         m_CurrPosX = m_MarkerPosX = pos_x;
  514.         m_CurrPosY = m_MarkerPosY = pos_y;
  515.                 
  516.         if(m_State == eReadyScale)  {            
  517.             m_CurrNorm = m_StartNorm = x_ScaleToNorm(m_pHost->MZHH_GetScale(IMouseZoomHandlerHost::eCurrent));
  518.     
  519.             m_MinNorm = x_ScaleToNorm(m_pHost->MZHH_GetScale(IMouseZoomHandlerHost::eMin));
  520.             m_MaxNorm = x_ScaleToNorm(m_pHost->MZHH_GetScale(IMouseZoomHandlerHost::eMax));                
  521.         }    
  522.         m_pHost->MZHH_Redraw();
  523.     }
  524. }
  526. void    CMouseZoomHandler::x_SwithToActiveState(EState state, int pos_x, int pos_y)
  527. {    
  528.     _ASSERT(m_pHost);
  529.     
  530.     m_State = state;
  531.     m_MouseStartX = pos_x;
  532.     m_MouseStartY = pos_y;
  534.     m_ptStart = m_pPane->UnProject(m_MouseStartX, m_pHost->MZHH_GetVPPosByY(m_MouseStartY));
  535. }
  537. /// d_y is the absolute shift in pixels from  the position where m_StartNorm have
  538. /// been initialized
  539. void    CMouseZoomHandler::x_OnChangeScale(int d_y)
  540. { 
  541.     if(d_y) {
  542.         TModelUnit norm = m_StartNorm - ((TModelUnit) (d_y)) / m_PixPerNorm;
  543.         norm = max(norm, m_MinNorm);
  544.         norm = min(norm, m_MaxNorm);
  546.         if(norm != m_CurrNorm)  {
  547.             m_CurrNorm = norm;
  548.             TModelUnit scale = x_NormToScale(norm);
  549.             
  550.             m_pHost->MZHH_SetScale(scale, m_ptStart);            
  551.         }
  552.     }
  553. }
  555. void    CMouseZoomHandler::x_OnEndScale(EState new_state)
  556. {
  557.     _ASSERT(new_state != eScale);
  559.     m_State = new_state;    
  560.     m_StartNorm = m_CurrNorm;
  561.     
  562.     m_pHost->MZHH_Redraw();    
  563. }
  565. void    CMouseZoomHandler::x_OnChangeZoomRectPan(int x, int y)
  566. { 
  567.     if(x != m_CurrPosX  ||  y != m_CurrPosY) {
  568.         m_CurrPosX = x;
  569.         m_CurrPosY = y;
  571.         m_pHost->MZHH_Redraw();
  572.     }
  573. }
  575. void    CMouseZoomHandler::x_OnEndZoomRect(EState new_state)
  576. {
  577.     m_State = new_state;    
  578.     
  579.     TModelRect rc;
  580.     
  581.     int x1 = m_MouseStartX; 
  582.     int y1 = m_pHost->MZHH_GetVPPosByY(m_MouseStartY);
  583.     int x2 = m_CurrPosX;
  584.     int y2 = m_pHost->MZHH_GetVPPosByY(m_CurrPosY);
  585.     
  586.     rc.SetLeft(m_pPane->UnProjectX(min(x1, x2)));
  587.     rc.SetRight(m_pPane->UnProjectX(max(x1, x2)));
  588.     rc.SetBottom(m_pPane->UnProjectY(min(y1, y2)));
  589.     rc.SetTop(m_pPane->UnProjectY(max(y1, y2)));
  591.     m_pHost->MZHH_ZoomRect(rc);    
  592.     m_pHost->MZHH_Redraw();    
  593. }
  595. void    CMouseZoomHandler::x_OnEndPan(EState new_state)
  596. {
  597.     m_State = new_state;    
  599.     int y1 = m_pHost->MZHH_GetVPPosByY(m_MouseStartY);
  600.     int y2 = m_pHost->MZHH_GetVPPosByY(m_CurrPosY);
  601.     
  602.     TModelUnit m_x1 = m_pPane->UnProjectX(m_MouseStartX);
  603.     TModelUnit m_y1 = m_pPane->UnProjectY(y1);
  604.     TModelUnit m_x2 = m_pPane->UnProjectX(m_CurrPosX);
  605.     TModelUnit m_y2 = m_pPane->UnProjectY(y2);    
  606.     
  607.     m_pHost->MZHH_Scroll(m_x1 - m_x2, m_y1 - m_y2);
  608.     m_pHost->MZHH_Redraw();    
  609. }
  611. void    CMouseZoomHandler::x_OnSelectCursor(void)
  612. {
  613.     switch(m_State)    {
  614.     case eIdle:  
  615.     case eReadyScale: m_Cursor = FL_CURSOR_DEFAULT; break;
  616.     case eScale: m_Cursor = FL_CURSOR_HAND; break;        
  617.     case eReadyPan: 
  618.     case ePan: m_Cursor = FL_CURSOR_MOVE; break;
  619.     case eReadyZoomRect:    
  620.     case eZoomRect: m_Cursor = FL_CURSOR_CROSS; break;
  621.     default: break;
  622.     }   
  623.     //cout << "nCMouseZoomHandler::x_OnSelectCursor  " << m_Cursor;
  624.     fl_cursor(m_Cursor, FL_BLACK, FL_WHITE);
  625. }
  627. ////////////////////////////////////////////////////////////////////////////////
  628. /// helper functions
  630. TModelUnit  CMouseZoomHandler::x_ScaleToNorm(TModelUnit scale) const
  631. {
  632.     return log(scale);
  633. }
  635. TModelUnit  CMouseZoomHandler::x_NormToScale(TModelUnit norm) const
  636. {
  637.     return exp(norm);
  638. }
  640. END_NCBI_SCOPE
  642. /*
  643.  * ===========================================================================
  644.  * $Log: mouse_zoom_handler.cpp,v $
  645.  * Revision 1000.3  2004/06/01 21:10:40  gouriano
  646.  * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.10
  647.  *
  648.  * Revision 1.10  2004/05/21 22:27:54  gorelenk
  649.  * Added PCH ncbi_pch.hpp
  650.  *
  651.  * Revision 1.9  2004/03/26 15:03:48  yazhuk
  652.  * Fixed stuff broken by previous changes
  653.  *
  654.  * Revision 1.8  2004/03/04 14:36:41  lebedev
  655.  * Enable panning while mouse drag
  656.  *
  657.  * Revision 1.7  2004/03/02 21:54:52  yazhuk
  658.  * Fixed CGlAttrGuard usage
  659.  *
  660.  * Revision 1.6  2004/02/17 15:23:01  yazhuk
  661.  * Refactoring - replaced CGlParam with CGlAttrGuard
  662.  *
  663.  * Revision 1.5  2003/12/10 16:54:32  yazhuk
  664.  * Added support for using mouse position to specify reference point for "active zoom".
  665.  *
  666.  * Revision 1.4  2003/12/08 15:12:48  yazhuk
  667.  * Implemented deactivation on FL_UNFOCUS.
  668.  *
  669.  * Revision 1.3  2003/12/01 22:32:14  yazhuk
  670.  * GCC ompilation fixes
  671.  *
  672.  * Revision 1.2  2003/12/01 16:41:30  yazhuk
  673.  * Refactored event handling - introduced CGUIEvent; implemented zooming by
  674.  * rectangle and panoraming.
  675.  *
  676.  * Revision 1.1  2003/11/17 20:24:51  yazhuk
  677.  * Moved from widgetsaln_multiple
  678.  *
  679.  * Revision 1.3  2003/10/29 23:32:47  yazhuk
  680.  * Updated includes
  681.  *
  682.  * Revision 1.2  2003/10/20 16:27:55  yazhuk
  683.  * x_OnKeyUp() bug fix.
  684.  *
  685.  * Revision 1.1  2003/10/20 15:44:58  yazhuk
  686.  * Initial revision.
  687.  *
  688.  * ===========================================================================
  689.  */