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

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

生物技术

开发平台：

C/C++

ruler.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: ruler.cpp,v $
  4.  * PRODUCTION Revision 1000.4  2004/06/01 21:10:43  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.15
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: ruler.cpp,v 1000.4 2004/06/01 21:10:43 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.  */
  42. #include <ncbi_pch.hpp>
  43. #include <corelib/ncbistd.hpp>
  45. #include <gui/opengl/glhelpers.hpp>
  46. #include <gui/widgets/gl/ruler.hpp>
  48. #include <math.h>
  51. BEGIN_NCBI_SCOPE
  53. CRuler::CRuler(bool b_horz)
  54. :   m_bHorz(b_horz),
  55.     m_bAutoRange(true),
  56.     m_Start(0),
  57.     m_End(0),
  58.     m_Offset(0),
  59.     m_bReverseDisplay(false),
  60.     m_DisplayOptions(0),
  61.     m_Font(CGlBitmapFont::eHelvetica12),
  62.     m_TextColor(0.2f, 0.4f, 0.2f),
  63.     m_RullerColor(0.2f, 0.2f, 0.2f),
  64.     m_BackColor(0.95f, 0.95f, 0.95f),
  65.     m_MajorTickSize(6),
  66.     m_RegTickSize(3),
  67.     m_bDirty(true),
  68.     m_PosLabelsStep(-1)
  69. {
  70.     m_LabelPlace = m_bHorz ? eBottom : eLeft;
  71. }
  73. CRuler::~CRuler()
  74. {
  75. }
  77. void    CRuler::SetHorizontal(bool b_horz, ELabelPlacement place)
  78. {
  79.     m_bHorz = b_horz;
  81.     if(m_bHorz) {
  82.         switch(place)   {
  83.         case eLeft:
  84.         case eRight:    _ASSERT(false);
  85.         case eDefault: 
  86.         case eBottom: m_LabelPlace = eBottom; break;
  87.         case eTop: m_LabelPlace = eTop; break;
  88.         }
  89.     } else {
  90.         switch(place)   {
  91.         case eBottom:
  92.         case eTop:    _ASSERT(false);
  93.         case eDefault: 
  94.         case eLeft: m_LabelPlace = eLeft; break;
  95.         case eRight: m_LabelPlace = eRight; break;
  96.         }
  97.     }
  98.     m_bDirty = true;
  99. }
  101. void    CRuler::SetColor(EColorType type, const CGlColor& color)
  102. {
  103.     switch(type)    {
  104.     case eRuller: m_RullerColor = color; break;
  105.     case eText: m_TextColor = color; break;
  106.     case eBackground: m_BackColor = color; break;
  107.     default: _ASSERT(false);
  108.     }
  109.     m_bDirty = true;
  110. }
  112. void    CRuler::SetFont(CGlBitmapFont::EFont font_type)
  113. {
  114.     m_Font.SetFont(font_type);
  115.     m_bDirty = true;
  116. }
  118. void    CRuler::SetDisplayOptions(int options)
  119. {
  120.     m_DisplayOptions = options;
  121. }
  123. void    CRuler::SetAutoRange()
  124. {
  125.     m_bAutoRange = true;
  127.     m_Offset = 0;
  128.     m_bReverseDisplay = false;
  129. }
  131. void    CRuler::SetRange(int Start, int End, int SeqStart, bool b_reverse)
  132. {
  133.     m_bAutoRange = false;
  135.     m_Start = Start;
  136.     m_End = End;
  137.     m_Offset = SeqStart - (b_reverse ? 0 : m_Start);
  138.     m_bReverseDisplay = b_reverse;
  139. }
  141. void    CRuler::SetGeometryParam(EGeometryParam geom, int value)
  142. {
  143.     switch(geom)    {
  144.     case eRegularTickHeight: m_RegTickSize = value;    break;
  145.     case eMajorTickHeight: m_MajorTickSize = value;    break;
  146.     default: _ASSERT(false);
  147.     }
  148.     m_bDirty = true;
  149. }
  151. /// vertical spacing between text and borders or between text and other graphics
  152. static int  kTextSpaceY = 3; 
  154. TVPPoint     CRuler::GetPreferredSize() const
  155. {
  156.     int w = 0, h = 0;
  157.     if(m_bHorz) {
  158.         h = x_GetBaseHeight();
  160.         if(m_DisplayOptions & (fShowOrigin | fShowMetric))  {
  161.             double t_h = m_Font.GetMetric(CGlBitmapFont::eMetric_FullCharHeight);
  162.             int text_h = (int) ceil(t_h);
  163.             h += max(text_h, m_MajorTickSize) + kTextSpaceY;
  164.         }
  165.     } else {        
  166.     }
  167.     return TVPPoint(w, h);
  168. }
  170. TVPRect    CRuler::GetVPRect()
  171. {
  172.     TVPPoint pt = GetPreferredSize();
  173.     return TVPRect(0, 0, pt.X(), pt.Y());
  174. }
  176. TModelRect CRuler::GetModelRect()
  177. {
  178.     return TModelRect();
  179. }
  181. const static int kLabelSepX = 8;
  182. const static int kLabelSepY = 4;
  183. const static int kMinTickStepPixels = 5;
  184. const static int kLabelSepPix = 24; // min distance between labels
  186. // calculates distance in pixels between position labels
  187. void CRuler::x_CalculatePosLabelsStep(CGlPane& pane)
  188. {
  189.     m_MaxLabelH = m_Font.TextHeight();
  191.     double char_w = m_Font.GetMetric(CGlBitmapFont::eMetric_AvgCharWidth);            
  192.     double comma_w = m_Font.TextWidth(",");
  193.     
  194.     // determining maximal number of characters in a label
  195.     double max_num = max(x_ToDisplay(m_Start), x_ToDisplay(m_End));     
  197.     int digits_count = (int) ceil(log10(max_num));    
  198.     int commas_count = (digits_count - 1) / 3;
  199.     
  200.     // length of the longest possible label in pixels (add 2 for separation)
  201.     m_MaxLabelW = kLabelSepPix + digits_count * char_w + commas_count * comma_w; 
  203.     // calculate size of the longest label in model coords
  204.     double scale = m_bHorz ? pane.GetScaleX() : pane.GetScaleY();
  205.     double max_label_sym = 0;  // in symbols
  206.     if(m_bHorz) {        
  207.         max_label_sym = scale * m_MaxLabelW;
  208.         
  209.     } else {
  210.         max_label_sym = 2 * scale * m_MaxLabelH;
  211.     }
  212.     
  213.     // choosing step in model coords
  214.     double log = (max_label_sym >= 1.0) ? log10(max_label_sym) : 0;
  215.     log = ceil(log);
  216.     double step = pow((double)10, log);
  217.     double base_step = step;
  219.     if(step > 10.001)   {
  220.         // try to mimimize step without intersecting labels
  221.         if(m_bHorz)   {
  222.             // using compact notation (1 K vs 1,000) saves space, check if we can 
  223.             // benefit from this
  225.             // adjusting order
  226.             int groups_n = 0;
  227.             step = step * 10; // to compensate effect of fisrt iteration
  228.             double max_label_w = m_MaxLabelW;
  229.             do
  230.             {
  231.                 _ASSERT(step > 0);
  232.                 step = step / 10;
  233.                 log = ceil(log10(step));
  234.                 groups_n = (int) (log / 3);
  235.                 if(groups_n)  {
  236.                     int d_digits =  3 * groups_n - 2; 
  237.                     max_label_w = m_MaxLabelW - d_digits * char_w + groups_n * comma_w;
  238.                     max_label_sym = scale * max_label_w;
  239.                 }
  240.             } while(groups_n  &&  step > max_label_sym * 10);
  241.             m_MaxLabelW = max_label_w;
  242.             base_step = step;
  243.         }
  244.         // currently step has a form   10^X, lets check if we can choose
  245.         // a smaller step in a form  K * 10^(X-1), where K = 2, 5
  246.         // this adjusment does not affect labels size
  247.         if(step > max_label_sym * 5)    {
  248.             base_step = step / 10;  // 10^(X-1)
  249.             step = step / 5;        // 2 * 10^(X-1)
  250.         }
  251.         else if(step > max_label_sym * 2)   {
  252.             base_step = step / 10;  // 10^(X-1)
  253.             step = step / 2;        // 5 * 10^(X-1)          
  254.         }
  255.     }
  256.         
  257.     m_BaseStep = (int) base_step;
  258.     m_BaseStep = max(m_BaseStep, 1);
  260.     m_PosLabelsStep = (int) step;
  261.     m_PosLabelsStep  = max(m_PosLabelsStep , 1);
  263.     // choosing optimal distance between ticks
  264.     m_TickSpace = m_BaseStep;
  265.     int ar_K[] = { 10, 5 ,2 };
  266.     for( int i = 0; i < 3; i++ )    {
  267.         int space = m_TickSpace / ar_K[i];
  268.         if(space >= 1  &&  space / scale > kMinTickStepPixels)   {
  269.             m_TickSpace = space; 
  270.             break;
  271.         }
  272.     }
  274.     m_bDirty = false;
  275. }
  277. void  CRuler::Render(CGlPane& pane)
  278. {
  279.     CGlAttrGuard AttrGuard(GL_POLYGON_BIT | GL_LINE_BIT);
  280.     glLineWidth(1.0f);
  282.     const TModelRect& rc_lim = pane.GetModelLimitsRect();
  283.         
  284.     if(m_bAutoRange)    {
  285.         m_Start = (int) (m_bHorz ? rc_lim.Left() : rc_lim.Bottom());
  286.         m_End = (int) (m_bHorz ? rc_lim.Right() : rc_lim.Top()) - 1;
  287.     }
  288.     bool b_update = m_bDirty || m_PosLabelsStep <= 0;
  289.     if(! b_update)  {
  290.         bool b_scale_changed = m_bHorz ? (m_ScaleX != pane.GetScaleX())
  291.                                        : (m_ScaleY != pane.GetScaleY());
  292.         b_update =  b_scale_changed  ||  ! (m_rcLimits == rc_lim);
  293.         
  294.         m_rcLimits = rc_lim;
  295.         m_ScaleX = pane.GetScaleX();
  296.         m_ScaleY = pane.GetScaleY();
  297.     }
  298.     if(b_update)   
  299.         x_CalculatePosLabelsStep(pane);
  300.     
  301.     if(m_PosLabelsStep > 0) { // step is valid
  302.         // calculating range to draw
  303.         TModelRect rcV = pane.GetVisibleRect();
  304.         
  305.         // [first_elem, last_elem] - is a range being rendered in model coords
  306.         int first_elem = (int) floor(m_bHorz ? rcV.Left() : rcV.Bottom());
  307.         int last_elem = (int) ceil(m_bHorz ? rcV.Right() : rcV.Top()) -1;
  308.         first_elem = max(m_Start, first_elem);
  309.         last_elem = min(m_End, last_elem);
  311.         if(last_elem >= first_elem) {            
  312.             pane.OpenOrtho(); 
  313.         
  314.             // fill background
  315.             glColorC(m_BackColor);
  316.             glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
  318.             TModelUnit offset_x = pane.GetOffsetX();    
  319.             glRectd(rcV.Left() - offset_x, rcV.Bottom(), 
  320.                     rcV.Right() - offset_x, rcV.Top());
  321.         
  322.             // render ticks and labels
  323.             x_RenderScale(pane, first_elem, last_elem);
  324.             
  325.             if((m_DisplayOptions & fHideLabels) == 0) {
  326.                 x_RenderAllPosLabels(pane, first_elem, last_elem);  
  327.             }
  328.             pane.Close();
  330.             pane.OpenPixels();
  332.             x_RenderOriginAndMetric(pane);
  334.             pane.Close();
  335.         }
  336.     }
  337. }
  339. int     CRuler::x_ToDisplay(int model) const
  340. {
  341.     return m_Offset + 1 + (m_bReverseDisplay ? (m_End - model) : model);
  342. }
  344. int     CRuler::x_ToModel(int display) const
  345. {
  346.     int off = display - (m_Offset + 1);
  347.     return (m_bReverseDisplay ? (m_End - off) : off);
  348. }
  350. void CRuler::x_RenderScale(CGlPane& pane, int first_elem, int last_elem)
  351. {
  352.     TModelUnit offset_x = pane.GetOffsetX();
  353.     TModelUnit offset_y = pane.GetOffsetY();
  355.     int Length = last_elem - first_elem + 1;
  356.     if(Length > 0)  {                          
  357.         // draw horizonatl line            
  358.         double MinU = m_Start + 0.5;
  359.         double MaxU = m_End + 0.5;
  361.         double u1 = max(MinU, (double) first_elem);
  362.         double u2 = min(MaxU, (double) last_elem + 1);
  363.   
  364.         TModelUnit v1 = 0, v2 = 0, v3 = 0;
  365.         switch(m_LabelPlace)    {
  366.         case eTop:
  367.         case eRight: {
  368.             v1 = m_MajorTickSize;
  369.             v2 = v1 - m_RegTickSize;
  370.             v3 = v1 - m_MajorTickSize;
  371.         }; break;
  372.         case eLeft: {
  373.             v1 = pane.GetVisibleRect().Width() - m_MajorTickSize - 1; 
  374.             v2 = v1 + m_RegTickSize;
  375.             v3 = v1 + m_MajorTickSize;
  376.         };  break;
  377.         case eBottom:   {
  378.             v1 = pane.GetVisibleRect().Height() - m_MajorTickSize - 1; 
  379.             v2 = v1 + m_RegTickSize;
  380.             v3 = v1 + m_MajorTickSize;
  381.         };  break;
  382.         default: _ASSERT(false);
  383.         }
  384.                     
  385.         glColorC(m_RullerColor);
  386.         glBegin(GL_LINES);
  387.     
  388.         if(m_bHorz) {
  389.             glVertex2d(u1 - offset_x, v1 - offset_y);
  390.             glVertex2d(u2 - offset_x, v1 - offset_y);
  391.         } else {
  392.            glVertex2d(v1 - offset_x, u1 - offset_y);
  393.            glVertex2d(v1 - offset_x, u2 - offset_y);
  394.         }
  396.         // draw regular ticks            
  397.         if(m_TickSpace) {   
  398.             int orig_disp = (x_ToDisplay(m_Start) / m_BaseStep) * m_BaseStep;
  399.             int orig = x_ToModel(orig_disp);
  401.             int i_first_disp = (x_ToDisplay(first_elem) / m_TickSpace ) * m_TickSpace;
  402.             int i_last_disp = (x_ToDisplay(last_elem) / m_TickSpace) * m_TickSpace;        
  403.     
  404.             int i_start = x_ToModel(i_first_disp);
  405.             int i_end = x_ToModel(i_last_disp) + m_TickSpace;
  406.             if(i_start < first_elem)
  407.                  i_start += m_TickSpace;
  409.             while(i_end > last_elem)
  410.                 i_end -= m_TickSpace;
  412.             for( int i = i_start; i <= i_end;  i += m_TickSpace ) {
  413.                 double v = ((i - orig) % m_BaseStep) ? v2 : v3;
  414.                 double u = 0.5 + i;
  415.                 if(m_bHorz) {
  416.                     glVertex2d(u - offset_x, v - offset_y);
  417.                     glVertex2d(u - offset_x, v1 - offset_y);
  418.                 } else {
  419.                     glVertex2d(v - offset_x, u - offset_y);
  420.                     glVertex2d(v1 - offset_x, u - offset_y);
  421.                 }
  422.             }
  423.         }        
  424.         glEnd();
  425.     }
  426. }
  428. // This function fills given vector with indeces of the Alignment elements 
  429. // for which position labels should be shown
  430. void  CRuler::x_GenerateLabelPositions(int first_elem, int last_elem, 
  431.                                                vector<int>& vElemPos)
  432. {
  433.     vElemPos.clear();
  434.     const int& step = m_PosLabelsStep;  
  435.     
  436.     // i_start and i_end are positions in model space    
  437.     int i_first_disp = (x_ToDisplay(first_elem) / step ) * step;
  438.     int i_last_disp = (x_ToDisplay(last_elem) / step) * step;        
  439.     
  440.     int i_start = x_ToModel(i_first_disp);
  441.     int i_end = x_ToModel(i_last_disp) + step;
  442.         
  443.     while(i_start < first_elem)
  444.          i_start += step;
  446.     while(i_end > last_elem)
  447.         i_end -= step;
  449.     for( int i = i_start; i <= i_end; i += step )
  450.         vElemPos.push_back(i);
  451. }
  453. /// Renders all labels on the ruller.
  454. void  CRuler::x_RenderAllPosLabels(CGlPane& pane, int first_elem, int last_elem)
  455. {      
  456.     vector<int> vLabelsPos;
  457.     x_GenerateLabelPositions(first_elem, last_elem, vLabelsPos);
  459.     // setup text output params    
  460.     double scale =  m_bHorz ? pane.GetScaleX() : pane.GetScaleY();    
  461.     
  462.     // draw the First Label
  463.     int pos = m_Start;
  464.     string S = x_GetPositionLabel(m_Start);
  465.     
  466.     double label_size = 0;
  467.     if(m_bHorz) {
  468.         label_size = (m_Font.TextWidth(S.c_str()) + kLabelSepPix) * scale;
  469.     } else {
  470.         label_size = (m_Font.TextHeight() + kLabelSepPix) * scale;
  471.     }
  473.     double label_u = 0.5 + m_Start;
  474.     x_RenderPosLabel(pane, label_u, 0, S);
  475.     double low_limit = label_u + label_size;
  477.     // draw the Last label
  478.     label_u = 0.5 + m_End;
  479.     S = x_GetPositionLabel(m_End);    
  480.     
  481.     if(m_bHorz) {
  482.         label_size = m_Font.TextWidth(S.c_str()) * scale;
  483.     }
  484.     if(label_u) // there is enough space at least for the last label
  485.     {
  486.         x_RenderPosLabel(pane, label_u, -label_size, S.c_str()); 
  487.         double high_limit = label_u - (label_size + kLabelSepPix * scale);    
  488.         
  489.         // draw regular labels
  490.         int labels_n = vLabelsPos.size();
  491.         for( int i_label = labels_n - 1; i_label >= 0; i_label-- )  {
  492.             pos = vLabelsPos[i_label];            
  493.             string S = x_GetPositionLabel(pos);
  494.             label_u = pos + 0.5;
  496.             if(m_bHorz) {
  497.                 label_size = m_Font.TextWidth(S.c_str()) * scale;
  498.             }
  499.             double half_size = label_size / 2.0;
  501.             bool b_draw_text = (label_u + half_size < high_limit)  
  502.                                 &&  (label_u - half_size > low_limit);
  503.             if(! b_draw_text)   {
  504.                 S = "";
  505.             } else {
  506.                 high_limit = label_u - half_size;
  507.             }
  509.             x_RenderPosLabel(pane, label_u, -half_size, S);                
  510.         }      
  511.     }
  512. }
  514. /// distnce in pixels between left side of ruler and origin labels
  515. const static int kOriginOffsetX = 6; 
  517. /// minimal size of the metric in pixels
  518. const static int kMinMetricPix = 20;    
  520. /// returns height necessary for drawing ticks and tick labels (if not hidden)
  521. int     CRuler::x_GetBaseHeight() const
  522. {
  523.     int h = m_MajorTickSize + kTextSpaceY;
  524.     if((m_DisplayOptions & fHideLabels) == 0) {
  525.         h +=  m_MajorTickSize + (int)m_Font.TextHeight() + kTextSpaceY;
  526.     }
  527.     return h;
  528. }
  530. void    CRuler::x_RenderOriginAndMetric(CGlPane& pane)
  531. {
  532.     if(m_bHorz) {
  533.         TVPRect rc_vp = pane.GetViewport();
  535.         double t_h = m_Font.GetMetric(CGlBitmapFont::eMetric_FullCharHeight);
  536.         int text_h = (int) ceil(t_h);
  537.         TModelUnit y = rc_vp.Bottom() + x_GetBaseHeight(); // bottoom
  538.         int origin_right = rc_vp.Left(); // rightmost point of the origin label
  540.         if(m_DisplayOptions & fShowOrigin)  {   // render Origin label
  541.             
  542.             int origin = x_ToModel(1) + 1;
  543.             string s = "Origin : " + CTextUtils::FormatSeparatedNumber(origin, true);
  544.             int or_text_w = (int) ceil(m_Font.TextWidth(s.c_str()));
  545.         
  546.             or_text_w = min(or_text_w, rc_vp.Width() - kOriginOffsetX);
  547.             int x = rc_vp.Left() + kOriginOffsetX;
  548.             m_Font.TextOut(x, y, or_text_w, text_h, s.c_str()); // render label
  550.             origin_right += kOriginOffsetX + or_text_w;
  551.         }
  553.         if(m_DisplayOptions & fShowMetric)  {
  554.             // choose metric size
  555.             TModelUnit scale_x = pane.GetScaleX();
  556.             TModelUnit step = m_BaseStep;        
  557.             while(step / scale_x < kMinMetricPix)  {
  558.                 step *= 10;
  559.             }
  561.             int pix_l = (int) ceil(step / scale_x); //length of metric in pixels
  562.             string s = CTextUtils::FormatSeparatedNumber((int) step, true);       
  563.             s += "  ";
  564.             int text_w = (int) ceil(m_Font.TextWidth(s.c_str()));
  565.         
  566.             int metric_w = max(pix_l, text_w);        
  567.             if(origin_right + metric_w + kOriginOffsetX < rc_vp.Right()) { 
  568.                 // there is enough space for rendering metric
  570.                 TModelUnit x = rc_vp.Right() - kOriginOffsetX - metric_w;        
  571.                 TModelUnit yc = y + max(text_h, m_MajorTickSize) / 2;
  572.                 
  573.                 TModelUnit y1 = yc + m_MajorTickSize / 2;                
  574.                 TModelUnit y2 = yc - m_MajorTickSize / 2;                
  576.                 glBegin(GL_LINES);
  577.                     glVertex2d(x, y1);
  578.                     glVertex2d(x, y2);
  579.                     
  580.                     glVertex2d(x, yc);
  581.                     glVertex2d(x + pix_l, yc);
  582.                     
  583.                     glVertex2d(x + pix_l, y1);
  584.                     glVertex2d(x + pix_l, y2);            
  585.                 glEnd();                
  587.                 m_Font.TextOut(x - text_w, y, text_w, text_h, s.c_str(), FL_ALIGN_RIGHT);                
  588.             }
  589.         }
  590.     }
  591. }
  593. // pos_u is in model coords
  594. void  CRuler::x_RenderPosLabel(CGlPane& pane, double pos_u, 
  595.                                 double u_label_offset, const string& s_text )
  596. {
  597.     TModelUnit offset_x = pane.GetOffsetX();
  598.     TModelUnit offset_y = pane.GetOffsetY();
  599.     
  600.     if(m_bHorz) { // horizontal orientation
  601.         TModelUnit y1, y2, text_y;
  602.         TModelUnit tick_h = 2 * m_MajorTickSize;
  603.     
  604.         if(m_LabelPlace == eTop)    {
  605.             y1 = 0; 
  606.             y2 = tick_h;
  607.             text_y = y2 + kTextSpaceY;
  608.         } else {
  609.             y2 = pane.GetVisibleRect().Top();
  610.             y1 = y2 - tick_h;
  611.             text_y = y1 - kTextSpaceY - m_Font.TextHeight();
  612.         }
  614.         glColorC(m_TextColor);
  615.         m_Font.TextOut(pos_u + u_label_offset - offset_x, text_y - offset_y, s_text.c_str());  
  616.         
  617.         // draw label's tick
  618.         glColorC(m_RullerColor);
  619.         glBegin(GL_LINES);
  620.             glVertex2d(pos_u - offset_x, y1 - offset_y);
  621.             glVertex2d(pos_u - offset_x, y2 - offset_y);
  622.         glEnd();
  623.     } else { // vertical orientation
  624.         TModelUnit tick_w = 2 * m_MajorTickSize;
  625.         TModelUnit text_w = pane.GetVisibleRect().Width() - tick_w;
  626.         
  627.         TModelUnit y = pos_u + u_label_offset;
  628.         TModelUnit h = m_Font.TextHeight();
  629.         
  630.         TModelUnit x0 = pane.GetVisibleRect().Left();
  631.         TModelUnit tick_x = text_w;
  632.         if (m_LabelPlace == eRight)  {
  633.             x0 += tick_w + kLabelSepX;
  634.             tick_x = 0;
  635.         }
  636.         int text_align = FL_ALIGN_BOTTOM | ((m_LabelPlace == eRight) 
  637.                                     ? FL_ALIGN_LEFT : FL_ALIGN_RIGHT);
  638.         
  639.         glColorC(m_TextColor);
  640.         m_Font.TextOut(x0 - offset_x, y - offset_y, text_w - kLabelSepX, h, s_text.c_str(), text_align);  
  642.         // draw label's tick
  643.         glColorC(m_RullerColor);
  644.         glBegin(GL_LINES);
  645.             glVertex2d(tick_x - offset_x, pos_u - offset_y);
  646.             glVertex2d(tick_x + tick_w - offset_x, pos_u - offset_y);            
  647.         glEnd();
  648.     }
  649. }
  651. // i_elem is in model coords
  652. string  CRuler::x_GetPositionLabel(int i_elem)
  653. {
  654.     int pos = x_ToDisplay(i_elem);
  655.     string S = CTextUtils::FormatSeparatedNumber(pos, true);
  656.     return S;
  657. }
  659. END_NCBI_SCOPE
  661. /*
  662.  * ===========================================================================
  663.  * $Log: ruler.cpp,v $
  664.  * Revision 1000.4  2004/06/01 21:10:43  gouriano
  665.  * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.15
  666.  *
  667.  * Revision 1.15  2004/05/21 22:27:54  gorelenk
  668.  * Added PCH ncbi_pch.hpp
  669.  *
  670.  * Revision 1.14  2004/03/23 14:07:37  dicuccio
  671.  * Fixed compiler warnings
  672.  *
  673.  * Revision 1.13  2004/03/04 19:31:48  yazhuk
  674.  * Improved layout, labels spacing
  675.  *
  676.  * Revision 1.12  2004/03/02 21:54:12  yazhuk
  677.  * Added rendering of origin and metric
  678.  *
  679.  * Revision 1.11  2004/02/17 15:23:10  yazhuk
  680.  * Refactoring - replaced CGlParam with CGlAttrGuard
  681.  *
  682.  * Revision 1.10  2004/02/11 15:24:57  yazhuk
  683.  * Fixed background rendering
  684.  *
  685.  * Revision 1.9  2003/12/23 17:39:19  yazhuk
  686.  * Fixed bug with labels generation in "reverse" mode.
  687.  *
  688.  * Revision 1.8  2003/12/12 17:37:24  ivanov
  689.  * Explicit using pow(double,double) to avoid compilation error on MSVC 7
  690.  *
  691.  * Revision 1.7  2003/12/10 16:55:34  yazhuk
  692.  * Implemented control over displayed range, offset and direction.
  693.  *
  694.  * Revision 1.6  2003/12/08 15:12:02  yazhuk
  695.  * Fixed "first label is always 1" problem. Workaround for OpenGL
  696.  * rounding/precision problems.
  697.  *
  698.  * Revision 1.5  2003/12/01 16:36:06  yazhuk
  699.  * Improved labels layout algorithm and ruller ticks rendering .
  700.  *
  701.  * Revision 1.4  2003/11/18 17:57:08  yazhuk
  702.  * Fixed GCC warnings
  703.  *
  704.  * Revision 1.3  2003/11/18 00:59:03  yazhuk
  705.  * Restored IRenderable implementation
  706.  *
  707.  * Revision 1.2  2003/11/17 23:43:12  yazhuk
  708.  * Fixed GCC compilation problem.
  709.  *
  710.  * Revision 1.1  2003/11/17 20:24:19  yazhuk
  711.  * Renamed from ruller.cpp
  712.  *
  713.  * Revision 1.2  2003/10/31 14:04:18  dicuccio
  714.  * Corrected spelling error: CRuller -> CRuler
  715.  *
  716.  * Revision 1.1  2003/10/29 23:18:28  yazhuk
  717.  * Initial revision
  718.  *
  719.  * ===========================================================================
  720.  */