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

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

生物技术

开发平台：

C/C++

glpane.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: glpane.cpp,v $
  4.  * PRODUCTION Revision 1000.3  2004/06/01 20:50:55  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.11
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: glpane.cpp,v 1000.3 2004/06/01 20:50:55 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 <gui/opengl/glpane.hpp>
  43. #include <gui/opengl/glutils.hpp>
  45. #include <math.h>
  47. BEGIN_NCBI_SCOPE
  49. ///////////////////////////////////////////////////////////////////////////////
  50. /// CGlPane
  52. CGlPane::CGlPane(EProjMatrixPolicy policy)
  53. : m_prcClip(NULL),
  54.   m_Mode(eNone),
  55.   m_MatrixPolicy(policy),
  56.   m_AdjustX(fAdjustAll),
  57.   m_AdjustY(fAdjustAll),
  58.   m_bEnableOffset(false),
  59.   m_bZoomEnX(true),
  60.   m_bZoomEnY(true),
  61.   m_ZoomFactor(2.0),
  62.   m_bProportionalMode(false),
  63.   m_TypeX(eOriginLeft), m_TypeY(eOriginBottom),
  64.   m_MinScaleX(0), m_MinScaleY(0)
  65. {
  66. }
  68. CGlPane::~CGlPane()
  69. {
  70.    // _ASSERT(m_Mode == eNone); // should be closed first
  71. }
  73. void    CGlPane::SetViewport(const TVPRect& r)
  74. {
  75.     m_rcVP = r;
  76.     
  77.     // applying constraints
  78.     x_CorrectScale(m_rcOrigVisible.CenterPoint());
  79.     x_ScaleToFitLimits();
  80.     x_ShiftToFitLimits();
  81.     x_AdjustVisibleRect();
  82. }
  84. void    CGlPane::SetVisibleRect(const TModelRect& r)
  85. {
  86.     m_rcVisible = m_rcOrigVisible = r;
  87. }
  89. TModelUnit  CGlPane::GetScaleX(void) const
  90. {
  91.     return m_rcVisible.Width() / m_rcVP.Width();
  92. }
  94. TModelUnit  CGlPane::GetScaleY(void) const
  95. {
  96.     return m_rcVisible.Height() / m_rcVP.Height();
  97. }
  99. TModelUnit    CGlPane::GetZoomAllScaleX(void) const
  100. {
  101.     return m_rcLimits.Width() / m_rcVP.Width();
  102. }
  104. TModelUnit    CGlPane::GetZoomAllScaleY(void) const
  105. {
  106.     return m_rcLimits.Height() / m_rcVP.Height();
  107. }
  109. inline void    CGlPane::x_AssertNotOpen(void) const
  110. {
  111.     _ASSERT(GetProjMode() == eNone);
  112. }
  114. inline void    CGlPane::x_AssertOrtho(void) const
  115. {
  116.     _ASSERT(GetProjMode() == eOrtho);
  117. }
  118.            
  119. bool    CGlPane::Open(EProjectionMode mode)
  120. {    
  121.     _ASSERT(mode != eNone);
  122.     _ASSERT(m_Mode == eNone); //should not be already open 
  124.     bool ok = false;
  125.     if (mode != m_Mode) {
  126.         switch (mode) {
  127.         case eOrtho: {
  128.             ok = x_OpenOrtho();
  129.             break;
  130.         }
  131.         case ePixels: {
  132.             ok = x_OpenPixels();
  133.             break;
  134.         }
  135.         default: _ASSERT(false); //other modes are unsupported
  136.         } //switch
  137.     } 
  138.     if (ok) {
  139.         m_Mode = mode;
  140.     }
  141.     return ok;
  142. }
  144. void    CGlPane::Close(void)
  145. {
  146.     _ASSERT(m_Mode != eNone); // should be open
  147.     if(m_Mode != eNone)
  148.     {
  149.         glMatrixMode(GL_PROJECTION);
  150.         //glPopMatrix();
  151.         glDisable(GL_SCISSOR_TEST);
  152.         m_Mode = eNone;
  153.     }
  154. }
  156. inline void    CGlPane::x_Open_SetViewport()
  157. {
  158.     _ASSERT(m_rcVP.Width()  &&  m_rcVP.Height());
  159.     
  160.     glViewport(m_rcVP.Left(), m_rcVP.Bottom(), m_rcVP.Width(), m_rcVP.Height());
  162.     // setup clipping
  163.     glEnable(GL_SCISSOR_TEST);
  164.     TVPRect rc_cl(m_rcVP);
  165.     if(m_prcClip) { //additional clip rect has been provided
  166.         rc_cl.IntersectWith(*m_prcClip);
  167.     }
  168.     glScissor(rc_cl.Left(), rc_cl.Bottom(), rc_cl.Width(), rc_cl.Height());
  169. }
  171. bool    CGlPane::x_OpenOrtho()
  172. {
  173.     x_Open_SetViewport();
  175.     glMatrixMode(GL_PROJECTION);
  176.     //glPushMatrix();
  177.     glLoadIdentity();
  179.     TModelUnit half_pix_w = m_rcVisible.Width() / (2 * m_rcVP.Width());
  180.     TModelUnit half_pix_h = m_rcVisible.Height() / (2 * m_rcVP.Height());
  181.     
  182.     TModelUnit left, right, top, bottom;
  184.     if(m_bEnableOffset) {
  185.         left = bottom = 0.0;
  186.         right = m_rcVisible.Width();
  187.         top = m_rcVisible.Height();
  188.     } else {
  189.         left = m_rcVisible.Left();
  190.         right = m_rcVisible.Right();
  191.         bottom = m_rcVisible.Bottom();
  192.         top = m_rcVisible.Top();
  193.     }
  194.     gluOrtho2D( left - half_pix_w, right + half_pix_w, 
  195.                 bottom - half_pix_h, top + half_pix_h);
  196.             
  198.     glMatrixMode(GL_MODELVIEW);
  200.     switch(m_MatrixPolicy)  {
  201.     case eNeverUpdate: break;
  202.     case eAlwaysUpdate:  x_UpdateProjectMatrices(); break;
  203.     }
  204.         
  205.     return true;
  206. }
  208. bool    CGlPane::x_OpenPixels()
  209. {
  210.     x_Open_SetViewport();
  211.         
  212.     glMatrixMode(GL_PROJECTION);
  213.     //glPushMatrix();
  214.     glLoadIdentity();
  215.     glOrtho(m_rcVP.Left() - 0.5, m_rcVP.Right() + 0.5, m_rcVP.Bottom() - 0.5, m_rcVP.Top() + 0.5,
  216.             -1, 1);
  218.     glMatrixMode(GL_MODELVIEW);
  219.     return true;
  220. }
  222. void    CGlPane::x_UpdateProjectMatrices(void)
  223. {
  224.     glGetIntegerv(GL_VIEWPORT, m_mxVP);
  225.     glGetDoublev(GL_PROJECTION_MATRIX, m_mxProjection);
  226.     glGetDoublev(GL_MODELVIEW_MATRIX, m_mxModelView);
  227. }
  229. ////////////////////////////////////////////////////////////////////////////////
  230. // Zoom fucntions
  232. bool    CGlPane::IsZoomInAvaiable()
  233. {        
  234.     return m_bZoomEnX || m_bZoomEnY;
  235. }
  237. bool    CGlPane::IsZoomOutAvaiable(void)
  238. {
  239.     bool    av_x = ::fabs(m_rcVisible.Right() - m_rcVisible.Left()) 
  240.                     < ::fabs(m_rcLimits.Right() - m_rcLimits.Left());    
  241.     bool    av_y = ::fabs(m_rcVisible.Top() - m_rcVisible.Bottom()) 
  242.                     < ::fabs(m_rcLimits.Top() - m_rcLimits.Bottom());    
  243.     return (m_bZoomEnX && av_x) || (m_bZoomEnY && av_y);
  244. }
  246. void    CGlPane::ZoomAll(int options)
  247. {
  248.     if((options & fZoomX)  && (m_bZoomEnX  ||  (options & fForce)))  {
  249.         m_rcVisible.SetLeft(m_rcLimits.Left());
  250.         m_rcVisible.SetRight(m_rcLimits.Right());
  251.         
  252.         m_rcOrigVisible.SetLeft(m_rcLimits.Left());    
  253.         m_rcOrigVisible.SetRight(m_rcLimits.Right());
  254.     }
  255.     if((options & fZoomY)  && (m_bZoomEnY  ||  (options & fForce)))  {
  256.         m_rcVisible.SetBottom(m_rcLimits.Bottom());
  257.         m_rcVisible.SetTop(m_rcLimits.Top());
  258.         
  259.         m_rcOrigVisible.SetBottom(m_rcLimits.Bottom());    
  260.         m_rcOrigVisible.SetTop(m_rcLimits.Top());
  261.     }
  262.     // applying constraints
  263.     x_CorrectScale(m_rcOrigVisible.CenterPoint());
  265.     x_AdjustVisibleRect();
  266. }
  268. void    CGlPane::ZoomPoint(TModelUnit x, TModelUnit y, TModelUnit factor, int options)
  269. {
  270.     _ASSERT(factor > 0.01  && factor < 100); // keep it reasonable
  272.     m_rcOrigVisible = m_rcVisible;
  273.     if ((options & fZoomX)  &&  m_bZoomEnX) {
  274.         TModelUnit new_w = m_rcVisible.Width() / factor;
  275.         TModelUnit left = x - new_w / 2;
  276.         m_rcOrigVisible.SetLeft(left);
  277.         m_rcOrigVisible.SetRight(left + new_w);
  278.     }
  279.     if ((options & fZoomY)  &&  m_bZoomEnY) {
  280.         TModelUnit new_h = m_rcVisible.Height() / factor;
  281.         TModelUnit bottom = y - new_h / 2;
  282.         m_rcOrigVisible.SetBottom(bottom);
  283.         m_rcOrigVisible.SetTop(bottom + new_h);
  284.     }    
  286.     m_rcVisible = m_rcOrigVisible;    
  287.     
  288.     // applying constraints
  289.     x_CorrectScale(m_rcOrigVisible.CenterPoint());
  290.     x_ScaleToFitLimits();
  291.     x_ShiftToFitLimits();
  292.     x_AdjustVisibleRect();
  293. }
  295. void    CGlPane::ZoomInCenter(int options)
  296. {
  297.     ZoomIn(m_rcVisible.CenterPoint(), options);
  298. }
  300. void    CGlPane::ZoomOutCenter(int options)
  301. {
  302.     ZoomOut(m_rcVisible.CenterPoint(), options);
  303. }
  305. void    CGlPane::ZoomRect(const TModelRect& r)
  306. {
  307.     SetVisibleRect(r);
  309.     TModelPoint p_center = m_rcVisible.CenterPoint();
  310.     
  311.     x_CorrectScale(p_center);
  312.     x_ScaleToFitLimits(); //### merege with CorrectScale
  313.     x_ShiftToFitLimits();
  315.     x_AdjustVisibleRect();
  316. }
  318. void    CGlPane::SetScale(TModelUnit scale_x, TModelUnit scale_y, TModelPoint p_center)
  319. {
  320.     TModelUnit new_w = ::abs(m_rcVP.Width()) * scale_x;
  321.     TModelUnit left = p_center.X() - new_w / 2;
  322.     m_rcOrigVisible.SetLeft(left);
  323.     m_rcOrigVisible.SetRight(left + new_w);
  324.     
  325.     TModelUnit new_h = ::abs(m_rcVP.Height()) * scale_y;
  326.     TModelUnit bottom = p_center.Y() - new_h / 2;
  327.     m_rcOrigVisible.SetBottom(bottom);
  328.     m_rcOrigVisible.SetTop(bottom + new_h); 
  329.     m_rcVisible = m_rcOrigVisible;
  331.     x_CorrectScale(p_center);
  332.     x_ScaleToFitLimits(); 
  333.     x_ShiftToFitLimits();
  335.     x_AdjustVisibleRect();
  336. }
  339. void    CGlPane::SetScaleRefPoint(TModelUnit scale_x, TModelUnit scale_y,
  340.                              TModelPoint p_ref)
  341. {
  342.     TModelUnit new_w = ::abs(m_rcVP.Width()) * scale_x;    
  343.     TModelUnit left_ratio = (p_ref.X() - m_rcVisible.Left()) / m_rcVisible.Width();
  344.     TModelUnit left = p_ref.X() - new_w * left_ratio;
  345.     m_rcOrigVisible.SetLeft(left);
  346.     m_rcOrigVisible.SetRight(left + new_w);
  348.     TModelUnit new_h = ::abs(m_rcVP.Height()) * scale_y;
  349.     TModelUnit bottom_ratio = (p_ref.Y() - m_rcVisible.Bottom()) / m_rcVisible.Height();
  350.     TModelUnit bottom = p_ref.Y() - new_h * bottom_ratio;
  351.     m_rcOrigVisible.SetBottom(bottom);
  352.     m_rcOrigVisible.SetTop(bottom + new_h); 
  354.     m_rcVisible = m_rcOrigVisible;
  356.     x_CorrectScale(m_rcVisible.CenterPoint());
  357.     x_ScaleToFitLimits(); 
  358.     x_ShiftToFitLimits();
  360.     x_AdjustVisibleRect();
  361. }
  364. void    CGlPane::SetScale(TModelUnit scale_x, TModelUnit scale_y)
  365. {
  366.     SetScale(scale_x, scale_y, m_rcVisible.CenterPoint());
  367. }
  369. // constraints forced by x_CorrectScale() may be conflicting with other constraints
  370. // in that case x_CorrectScale() has the lowerest priority
  371. // does not work on negative scales
  372. void    CGlPane::x_CorrectScale(TModelPoint p_center)
  373. {    
  374.     if(m_MinScaleX != 0)    {
  375.         TModelUnit scale_x = GetScaleX();
  376.         if(scale_x < m_MinScaleX)   {
  377.             scale_x = m_MinScaleX;
  378.         
  379.             TModelUnit new_w = m_rcVP.Width() * scale_x;
  380.             TModelUnit left = p_center.X() - new_w / 2;
  381.             m_rcOrigVisible.SetLeft(left);
  382.             m_rcOrigVisible.SetRight(left + new_w);
  383.         }
  384.     }
  385.     if(m_MinScaleY != 0)    {
  386.         TModelUnit scale_y = GetScaleY();
  387.         if(scale_y < m_MinScaleX)   {
  388.             scale_y = m_MinScaleY;
  389.         
  390.             TModelUnit new_h = m_rcVP.Height() * scale_y;
  391.             TModelUnit bottom = p_center.Y() - new_h / 2;
  392.             m_rcOrigVisible.SetBottom(bottom);
  393.             m_rcOrigVisible.SetTop(bottom + new_h);
  394.         }
  395.     }
  396. }
  398. // this funtions make sure that visible area is not larger then model limits
  399. // it works fine with negative scales
  400. void    CGlPane::x_ScaleToFitLimits(void)
  401. {
  402.     if(m_AdjustX & fScaleToLimits)  {
  403.         TModelUnit w = ::fabs(m_rcOrigVisible.Width());
  404.         if(w > ::fabs(m_rcLimits.Width())) {
  405.             m_rcOrigVisible.SetLeft(m_rcLimits.Left());
  406.             m_rcOrigVisible.SetRight(m_rcLimits.Right());
  407.         }
  408.     }
  409.     if(m_AdjustY & fScaleToLimits)  {
  410.         TModelUnit h = ::fabs(m_rcOrigVisible.Height());
  411.         if(h > ::fabs(m_rcLimits.Height())) {
  412.             m_rcOrigVisible.SetBottom(m_rcLimits.Bottom());
  413.             m_rcOrigVisible.SetTop(m_rcLimits.Top());
  414.         }
  415.     }
  416. }
  418. // Moves visible area so that it will be located within model limits.
  419. // If visible area is greater then limits rect, function aligns origin of the visible
  420. // rect with the origin of the limits rect and lets the other corner of visible rect
  421. // extend outside limits.
  422. // works on negative scales
  423. void CGlPane::x_ShiftToFitLimits(void)
  424. {    
  425.     if(m_AdjustX & fShiftToLimits)  { //horizontal adjustment
  426.         TModelUnit shift = 0;    
  427.         bool neg_range = m_rcLimits.Right() < m_rcLimits.Left();
  428.         TModelUnit left_shift = m_rcLimits.Left() - m_rcOrigVisible.Left();
  429.         TModelUnit right_shift = m_rcLimits.Right() - m_rcOrigVisible.Right();
  431.         shift = s_GetShift(left_shift, right_shift, neg_range, m_TypeX); 
  432.         m_rcOrigVisible.Offset(shift, 0);
  433.     }
  434.     if(m_AdjustY & fShiftToLimits)  { // vertical adjustment
  435.         TModelUnit shift = 0;    
  436.         bool neg_range = m_rcLimits.Top() < m_rcLimits.Bottom(); 
  437.         TModelUnit bottom_shift = m_rcLimits.Bottom() - m_rcOrigVisible.Bottom();
  438.         TModelUnit top_shift = m_rcLimits.Top() - m_rcOrigVisible.Top();
  439.     
  440.         shift = s_GetShift(bottom_shift, top_shift, neg_range, m_TypeY);
  441.         m_rcOrigVisible.Offset(0, shift);
  442.     }    
  443.     m_rcVisible = m_rcOrigVisible;
  444. }
  446. // adjust only m_rcVisible not m_rcOrigVisible
  447. // does not work on negative scales
  448. void    CGlPane::x_AdjustVisibleRect(void)
  449. {
  450.     TModelUnit scale_x = GetScaleX();
  451.     TModelUnit scale_y = GetScaleY();
  453.     TModelUnit new_scale_x = scale_x;
  454.     TModelUnit new_scale_y = scale_y;
  455.     
  456.     if(m_bProportionalMode) { 
  457.         new_scale_x = new_scale_y = max(scale_x, scale_y);
  458.     }    
  460.     // use scale to adjust m_rcVisible with regard to its origin
  461.     if (new_scale_x != scale_x) {
  462.         TModelUnit w = m_rcVP.Width() * new_scale_x;
  463.         TModelUnit left = m_rcOrigVisible.Left();
  464.         TModelUnit right = m_rcOrigVisible.Right();
  466.         switch(m_TypeX) {
  467.         case eOriginLeft:   right = left + w; break;
  468.         case eOriginRight:  left = right - w; break;
  469.         case eOriginCenter: {
  470.             left = (left + right - w) / 2;
  471.             right = left + w;
  472.         }; break;
  473.         case eOriginBottom:
  474.         case eOriginTop: _ASSERT(false); break; // invalid values
  475.         }
  476.         m_rcVisible.SetLeft(left);
  477.         m_rcVisible.SetRight(right);
  478.     }
  479.     if (new_scale_y != scale_y) {
  480.         TModelUnit h = m_rcVP.Height() * new_scale_y;
  481.         TModelUnit  top = m_rcOrigVisible.Top();
  482.         TModelUnit  bottom = m_rcOrigVisible.Bottom();
  484.         switch(m_TypeY) {
  485.         case eOriginBottom: top = bottom + h; break;
  486.         case eOriginTop: bottom = top - h; break;
  487.         case eOriginCenter: {
  488.             bottom = (top + bottom - h) / 2;
  489.             top = bottom + h;
  490.         }; break;
  491.         case eOriginLeft:
  492.         case eOriginRight: _ASSERT(false); break; // invalid values
  493.         }
  494.         m_rcVisible.SetBottom(bottom);
  495.         m_rcVisible.SetTop(top);
  496.     }
  497. }
  499. double  CGlPane::s_GetShift(TModelUnit low_shift, TModelUnit high_shift, bool neg_range, EOriginType type)
  500. {
  501.     TModelUnit shift = 0;
  502.     switch(type)    {
  503.     case eOriginBottom:
  504.     case eOriginLeft: {
  505.         if(neg_range)   {
  506.             if(low_shift < 0)
  507.                 shift = low_shift;
  508.             else if(high_shift > 0)
  509.                 shift = min(high_shift, low_shift);
  510.         } else {
  511.             if(low_shift > 0)
  512.                 shift = low_shift;
  513.             else if(high_shift < 0)
  514.                 shift = max(high_shift, low_shift);
  515.         }
  516.     }; break;
  517.     case eOriginRight:
  518.     case eOriginTop: {
  519.         if(neg_range)   {
  520.             if(high_shift > 0)
  521.                 shift = high_shift;
  522.             else if(low_shift < 0)
  523.                 shift = max(high_shift, low_shift);
  524.         } else {
  525.             if(high_shift < 0)
  526.                 shift = high_shift;
  527.             else if(low_shift > 0)
  528.                 shift = max(high_shift, low_shift);
  529.         }
  530.     }; break;
  531.     case eOriginCenter: {
  532.         shift = (low_shift + high_shift) / 2;
  533.     }; break;
  534.     } //switch
  535.     return shift;
  536. }
  538. ////////////////////////////////////////////////////////////////////////////////
  539. // Scroll functions
  540. bool    CGlPane::NeedsScrollX(void) const
  541. {
  542.     return (m_rcVisible.Left() > m_rcLimits.Left())
  543.             ||  (m_rcVisible.Right() < m_rcLimits.Right());
  544. }
  546. bool    CGlPane::NeedsScrollY(void) const
  547. {
  548.     TModelUnit d1 = ::fabs(m_rcVisible.Height());
  549.     TModelUnit d2 = ::fabs(m_rcLimits.Height());
  550.     return d1 < d2;
  551. }
  553. void    CGlPane::Scroll(TModelUnit dx, TModelUnit dy)
  554. {
  555.     m_rcOrigVisible.Offset(dx, dy);
  556.     m_rcVisible.Offset(dx, dy);
  557.     
  558.     x_ShiftToFitLimits();  
  559. }
  561. ////////////////////////////////////////////////////////////////////////////////
  562. // Coordinate transformations (Project - UnProject)
  563.     
  564. TVPUnit CGlPane::ProjectX(TModelUnit m_x) const
  565. {
  566.     _ASSERT(m_MatrixPolicy == eAlwaysUpdate);
  567.     if(m_bEnableOffset) {
  568.         m_x -= m_rcVisible.Left();
  569.     }
  570.     GLdouble x = 0;
  571.     GLdouble y = 0;
  572.     GLdouble z = 0;
  573.     gluProject( (GLdouble) m_x, 0.0, 0.0,  
  574.                 m_mxModelView, m_mxProjection, m_mxVP, &x, &y, &z);    
  575.     
  576.     return (TVPUnit) x;
  577. }
  579. TVPUnit CGlPane::ProjectY(TModelUnit m_y) const
  580. {
  581.     _ASSERT(m_MatrixPolicy == eAlwaysUpdate);
  582.     if(m_bEnableOffset) {
  583.         m_y -= m_rcVisible.Bottom();
  584.     }
  585.     GLdouble x = 0;
  586.     GLdouble y = 0;
  587.     GLdouble z = 0;
  588.     gluProject( 0.0, (GLdouble) m_y, 0.0,  
  589.                 m_mxModelView, m_mxProjection, m_mxVP, &x, &y, &z);    
  590.     if(m_bEnableOffset) {
  591.         y += m_rcVisible.Bottom();
  592.     }
  593.     return (TVPUnit) y;
  594. }
  596. TVPPoint    CGlPane::Project(TModelUnit m_x, TModelUnit m_y) const
  597. {
  598.     _ASSERT(m_MatrixPolicy == eAlwaysUpdate);
  599.     if(m_bEnableOffset) {
  600.         m_x -= m_rcVisible.Left();
  601.         m_y -= m_rcVisible.Bottom();
  602.     }
  603.     GLdouble x = 0;
  604.     GLdouble y = 0;
  605.     GLdouble z = 0;
  606.     gluProject( (GLdouble) m_x, (GLdouble) m_y, 0.0,  
  607.                 m_mxModelView, m_mxProjection, m_mxVP, &x, &y, &z);    
  608.     return TVPPoint((TVPUnit) x, (TVPUnit) y);
  609. }
  611. TModelUnit CGlPane::UnProjectX(TVPUnit m_x) const
  612. {
  613.     _ASSERT(m_MatrixPolicy == eAlwaysUpdate);
  615.     GLdouble x = 0;
  616.     GLdouble y = 0;
  617.     GLdouble z = 0;
  618.     gluUnProject( (GLdouble) m_x, 0.0, 0.0, 
  619.                    m_mxModelView, m_mxProjection, m_mxVP,
  620.                    &x, &y, &z);    
  621.     if(m_bEnableOffset) {
  622.         x += m_rcVisible.Left();
  623.     }    
  624.     return x;
  625. }
  627. TModelUnit CGlPane::UnProjectY(TVPUnit m_y) const
  628. {
  629.     _ASSERT(m_MatrixPolicy == eAlwaysUpdate);
  630.     
  631.     GLdouble x = 0;
  632.     GLdouble y = 0;
  633.     GLdouble z = 0;
  634.     gluUnProject( 0.0, (GLdouble) m_y, 0.0, 
  635.                   m_mxModelView, m_mxProjection, m_mxVP,
  636.                   &x, &y, &z);
  637.     if(m_bEnableOffset) {
  638.         y += m_rcVisible.Bottom();
  639.     }    
  640.     return y;
  641. }
  643. TModelPoint CGlPane::UnProject(TVPUnit m_x, TVPUnit m_y) const
  644. {
  645.     _ASSERT(m_MatrixPolicy == eAlwaysUpdate);
  646.     
  647.     GLdouble x = 0;
  648.     GLdouble y = 0;
  649.     GLdouble z = 0;
  650.     gluUnProject( (GLdouble) m_x, (GLdouble) m_y, 0.0, 
  651.                   m_mxModelView, m_mxProjection, m_mxVP,
  652.                   &x, &y, &z);
  653.     if(m_bEnableOffset) {
  654.         x += m_rcVisible.Left();
  655.         y += m_rcVisible.Bottom();
  656.     }    
  657.     return TModelPoint(x, y);
  658. }
  660. TModelUnit  CGlPane::UnProjectWidth(TVPUnit vp_w)
  661. {
  662.     _ASSERT(m_MatrixPolicy == eAlwaysUpdate);
  663.     
  664.     GLdouble x1 = 0;
  665.     GLdouble x2 = 0;
  666.     GLdouble y  = 0;
  667.     GLdouble z  = 0;
  668.     gluUnProject( 0.0, 0.0, 0.0, m_mxModelView, m_mxProjection, m_mxVP, &x1, &y, &z);
  669.     gluUnProject( vp_w, 0.0, 0.0, m_mxModelView, m_mxProjection, m_mxVP, &x2, &y, &z);    
  670.     return x2 - x1;
  671. }
  673. TModelUnit  CGlPane::UnProjectHeight(TVPUnit vp_h)
  674. {
  675.     _ASSERT(m_MatrixPolicy == eAlwaysUpdate);
  676.     
  677.     GLdouble x  = 0;
  678.     GLdouble y1 = 0;
  679.     GLdouble y2 = 0;
  680.     GLdouble z  = 0;
  681.     gluUnProject( 0.0, 0.0, 0.0, m_mxModelView, m_mxProjection, m_mxVP, &x, &y1, &z);
  682.     gluUnProject( 0.0, vp_h, 0.0, m_mxModelView, m_mxProjection, m_mxVP, &x, &y2, &z);    
  683.     return y2 - y1;
  684. }
  686. END_NCBI_SCOPE
  688. /*
  689.  * ===========================================================================
  690.  * $Log: glpane.cpp,v $
  691.  * Revision 1000.3  2004/06/01 20:50:55  gouriano
  692.  * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.11
  693.  *
  694.  * Revision 1.11  2004/05/21 22:27:45  gorelenk
  695.  * Added PCH ncbi_pch.hpp
  696.  *
  697.  * Revision 1.10  2004/04/08 13:51:11  dicuccio
  698.  * Initialize variables prior to calling glUnproject
  699.  *
  700.  * Revision 1.9  2003/12/08 15:07:48  yazhuk
  701.  * Workaround for OpenGL rounding/precision problems
  702.  *
  703.  * Revision 1.8  2003/11/17 20:28:22  yazhuk
  704.  * Introduced zoom options - added EZoomOptions and modified zoom functions.
  705.  *
  706.  * Revision 1.7  2003/10/29 22:24:02  yazhuk
  707.  * Added clipping capabilities, fixed SetScaleRefPoint()
  708.  *
  709.  * Revision 1.6  2003/10/27 19:57:51  dicuccio
  710.  * Removedcall to CGlUtils::CheckGlError()
  711.  *
  712.  * Revision 1.5  2003/10/22 18:26:45  lebedev
  713.  * SetScale method with reference point added
  714.  *
  715.  * Revision 1.4  2003/10/20 15:43:34  yazhuk
  716.  * Replaced boolean flags with EAdjustmentPolicy enumeration.
  717.  *
  718.  * Revision 1.3  2003/10/15 21:13:24  yazhuk
  719.  * Introduced projection matrix updating policy, fixed some minor problems
  720.  *
  721.  * Revision 1.2  2003/10/10 17:16:51  dicuccio
  722.  * Removed unnecessary call to CGlUtils::DumpState()
  723.  *
  724.  * Revision 1.1  2003/10/08 12:53:38  dicuccio
  725.  * Moved from gui/graph
  726.  *
  727.  * Revision 1.14  2003/10/07 20:56:39  yazhuk
  728.  * Added assertions, simplified destructor
  729.  *
  730.  * Revision 1.13  2003/10/03 16:24:49  yazhuk
  731.  * Modified open() functions so that OpenPixels() will not change projection matrices
  732.  *
  733.  * Revision 1.12  2003/09/30 18:19:36  yazhuk
  734.  * Fixed compilation problem in SetScale()
  735.  *
  736.  * Revision 1.11  2003/09/30 18:06:01  yazhuk
  737.  * Replaced fabs() with ::fabs()
  738.  *
  739.  * Revision 1.9  2003/09/25 20:35:49  yazhuk
  740.  * Added support for Visible rect adjustment
  741.  *
  742.  * Revision 1.8  2003/09/24 19:53:20  yazhuk
  743.  * Enforced coding policy. Fixed visible rect adjustment problems.
  744.  *
  745.  * Revision 1.7  2003/09/10 20:36:24  yazhuk
  746.  * Added GetScale() functions, modified ZoomAll(). Added glScissors() calls to
  747.  * Open() functions
  748.  *
  749.  * Revision 1.6  2003/08/28 19:20:10  yazhuk
  750.  * Implemented specification of the port origin and  autoadjustment of visible
  751.  * rect
  752.  *
  753.  * Revision 1.5  2003/08/14 17:58:55  yazhuk
  754.  * Changed default for m_bZoomEnY
  755.  *
  756.  * Revision 1.4  2003/08/11 16:10:57  yazhuk
  757.  * Compilation fixes for GCC
  758.  *
  759.  * Revision 1.3  2003/08/10 14:11:47  dicuccio
  760.  * Added makefiles for Unix projects; compilation fixes for gcc
  761.  *
  762.  * Revision 1.2  2003/08/08 15:59:36  yazhuk
  763.  * Comments added
  764.  *
  765.  * ===========================================================================
  766.  */