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

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

生物技术

开发平台：

C/C++

splitter.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: splitter.cpp,v $
  4.  * PRODUCTION Revision 1000.1  2004/06/01 21:09:10  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.7
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: splitter.cpp,v 1000.1 2004/06/01 21:09:10 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>
  42. #include <corelib/ncbistl.hpp>
  44. #include <algorithm>
  46. #include <gui/widgets/fl/splitter.hpp>
  48. #include <FL/fl_draw.H>
  49. #include <FL/Fl.H>
  52. BEGIN_NCBI_SCOPE
  54. CSplitter::CSplitter(int x, int y, int w, int h, const char* label)
  55.     : Fl_Group(x, y, w, h, label),
  56.     m_Mode(eHorizontal),
  57.     m_SepSize(4),
  58.     m_iDragSepX(-1), m_iDragSepY(-1)
  60. {
  61.     Fl_Group::end();
  62.     
  63.     color(fl_rgb_color(224, 224, 224));
  64.     box(FL_FLAT_BOX);
  66.     m_vCells.resize(1, NULL); // by default it has a single cell
  67.     m_vNormSizeX.resize(1, -1);
  68.     m_vNormSizeY.resize(1, -1);
  70.     m_Event.StandardConfig();
  71. }
  73. CSplitter::~CSplitter()
  74. {
  75. }
  77. CSplitter::EMode   CSplitter::GetMode()    const
  78. {
  79.     return m_Mode;
  80. }
  81. void    CSplitter::Create(EMode mode)
  82. {
  83.     if(m_Mode != mode)  {
  84.         x_Clear();
  85.         m_Mode = mode;
  86.     }
  87. }
  89. const static int    kMaxCells = 64;
  91. void    CSplitter::Create(EMode mode, const TPosVector& sizes)
  92. {
  93.     x_Clear();
  94.     switch(mode)  {
  95.     case    eHorizontal:  x_Create(mode, TPosVector(), sizes);    break;
  96.     case    eVertical:    x_Create(mode, sizes, TPosVector());    break;
  97.     case    eGrid:    x_Create(mode, sizes, sizes);    break;
  98.     };
  99. }
  101. void    CSplitter::Create(EMode mode, const int ar_size[])
  102. {
  103.     TPosVector sizes;
  104.     int  i = 0;
  105.     for(; i < kMaxCells; i++ )   {
  106.         if(ar_size[i] >= 0)
  107.             sizes.push_back(ar_size[i]);
  108.         else break;
  109.     }
  110.     _ASSERT(i < kMaxCells);
  112.     Create(mode, sizes);
  113. }
  115. void    CSplitter::Create(EMode mode, const TPosVector& widths, const TPosVector& heights)
  116. {
  117.     x_Create(mode, widths, heights);
  118. }
  120. void    CSplitter::Create(EMode mode, const int ar_w[], const int ar_h[])
  121. {
  122.     TPosVector widths;
  123.     int  i = 0;
  124.     for(; i < kMaxCells; i++ )   {
  125.         if(ar_w[i] >= 0)
  126.             widths.push_back(ar_w[i]);
  127.         else break;
  128.     }
  129.     _ASSERT(i < kMaxCells);
  130.     
  131.     TPosVector heights;
  132.     for( i = 0; i < kMaxCells; i++ )   {
  133.         if(ar_h[i] >= 0)
  134.             heights.push_back(ar_h[i]);
  135.         else break;
  136.     }
  137.     _ASSERT(i < kMaxCells);
  139.     x_Create(mode, widths, heights);
  140. }
  142. void    CSplitter::Create(int n_horz_panes, int n_vert_panes)
  143. {
  144.     vector<int> widths;
  145.     vector<int> heights;
  146.     
  147.     n_horz_panes = max(1, n_horz_panes);
  148.     n_vert_panes = max(1, n_vert_panes);
  150.     for( int i = 0; i < n_horz_panes; i++)
  151.         widths.push_back(10);
  152.     for( int i = 0; i < n_vert_panes; i++)
  153.         heights.push_back(10);
  155.     EMode mode = (n_horz_panes == 1) ? eVertical :
  156.                     ((n_vert_panes == 1) ? eHorizontal : eGrid);
  157.     x_Create(mode, widths, heights);
  159.     x_DistributeEvenly(true, true);
  160. }
  162. void    CSplitter::x_Create(EMode mode, const TPosVector& widths, const TPosVector& heights)
  163. {
  164.     m_Mode = mode;    
  165.     int n_w = widths.size(); 
  166.     int n_h = heights.size();
  168.     if(n_w == 0)    n_w++;
  169.     if(n_h == 0)    n_h++;
  171.     _ASSERT(n_w < kMaxCells  &&  n_h < kMaxCells); // keep 'em reasonable
  173.     x_Clear();    
  174.     
  175.     for( int pos = 0, i = 0; i < n_w - 1; i++)  {
  176.         pos += widths[i];
  177.         m_vSplitPosX.push_back(pos);
  178.     }
  179.     m_vNormSizeX.resize(n_w, -1);
  180.     
  181.     for( int pos = 0, i = 0; i < n_h - 1; i++)  {        
  182.         pos += heights[i];
  183.         m_vSplitPosY.push_back(pos);
  184.     }
  185.     m_vNormSizeY.resize(n_h, -1);
  187.     int n_cells = GetColumnsCount() * GetRowsCount();
  188.     m_vCells.resize(n_cells, NULL);
  189. }
  191. int     CSplitter::GetColumnsCount() const
  192. {
  193.     return m_vSplitPosX.size() + 1;
  194. }
  196. int     CSplitter::GetRowsCount() const
  197. {
  198.     return m_vSplitPosY.size() + 1;
  199. }
  201. bool    CSplitter::IsValidCell(int i_x, int i_y) const
  202. {
  203.     return i_x >= 0  &&  i_x <= (int) m_vSplitPosX.size()
  204.             &&  i_y >= 0  &&  i_y <= (int) m_vSplitPosY.size();
  205. }
  207. bool    CSplitter::InsertToCell(Fl_Widget* w, int i_x, int i_y)
  208. {
  209.     if(i_x >= 0  &&  i_x < GetColumnsCount()
  210.         && i_y >= 0  &&  i_y < GetRowsCount())   {
  211.         
  212.         int i_cell = x_GetCellIndex(i_x, i_y);
  214.         if(m_vCells[i_cell] == NULL) {// cell is  vacant
  215.             int ins_pos = 0; // insertion position
  216.             for( int i = 0;  i < i_cell; i++)   {
  217.                 if(m_vCells[i])
  218.                     ins_pos++;
  219.             }
  220.             w->hide();
  221.             
  222.             Fl_Group::insert(*w, ins_pos);
  223.             m_vCells[i_cell] = w;
  224.             x_ResizeToCell(i_x, i_y);
  225.             w->show();
  226.             return true;
  227.         }
  228.     }
  229.     return false;
  230. }    
  232. Fl_Widget*    CSplitter::RemoveFromCell(int i_x, int i_y)
  233. {
  234.     int i_cell = x_GetCellIndex(i_x, i_y);
  235.     Fl_Widget* w = m_vCells[i_cell];
  237.     if(w) {        
  238.         m_vCells[i_cell] = NULL;
  239.         Fl_Group::remove(w);        
  240.     }
  241.     redraw();
  242.     return w; 
  243. }
  245. bool    CSplitter::Remove(Fl_Widget* w)
  246. {
  247.     int i_x, i_y;
  248.     if(Find(w, i_x, i_y))    {
  249.         RemoveFromCell(i_x, i_y);
  250.         return true;
  251.     }
  252.     return false;
  253. }
  255. void    CSplitter::RemoveAll()
  256. {
  257.     for( size_t i = 0; i < m_vCells.size(); i++ )   {
  258.         Fl_Widget* w = m_vCells[i];
  259.         if(w) {        
  260.             m_vCells[i] = NULL;
  261.             Fl_Group::remove(w);        
  262.         }
  263.     }
  264.     redraw();
  265. }
  267. bool    CSplitter::Find(Fl_Widget* w, int& i_x, int& i_y)   const
  268. {
  269.     i_x = i_y = -1;
  270.     if(w)   {
  271.         for( int i = 0; i < (int) m_vCells.size();  i++ )   {
  272.             if(m_vCells[i] == w)    {
  273.                 i_x = x_GetColumn(i);
  274.                 i_y = x_GetRow(i);
  275.                 return true;
  276.             }
  277.         }
  278.     }
  279.     return false;
  280. }
  282. /// adds a child widget "w" to first vacant cell. If "w" already a child it is
  283. /// removed and added again to a new position. If there is no cells available
  284. /// new row/column is created
  285. void    CSplitter::add(Fl_Widget *widget)
  286. {
  287.     TCells::iterator it = std::find(m_vCells.begin(), m_vCells.end(), widget);
  288.     if(it != m_vCells.end())      { // already a child - remove
  289.         Fl_Group::remove(*widget);
  290.         *it = NULL;
  291.     }
  292.     
  293.     // look for first vacant cell 
  294.     it = std::find(m_vCells.begin(), m_vCells.end(), (Fl_Widget*) NULL);
  296.     if(it !=  m_vCells.end())   { // there is a vacant cell
  297.         int i_cell = it - m_vCells.begin();
  298.         Fl_Group::insert(*widget, i_cell);
  300.         m_vCells[i_cell] = widget;
  302.         int i_x = x_GetColumn(i_cell);
  303.         int i_y = x_GetRow(i_cell);
  304.         x_ResizeToCell(i_x, i_y);
  305.     } else  {
  306.         int old_n_cells = m_vCells.size();
  307.         if(m_Mode == eVertical) {
  308.             x_NewSplit(m_vSplitPosX, m_vNormSizeX, w());
  309.         }   else {
  310.             x_NewSplit(m_vSplitPosY, m_vNormSizeY, h());
  311.         }
  313.         Fl_Group::add(widget);
  315.         m_vCells.resize(GetRowsCount() * GetColumnsCount(), NULL);
  316.         m_vCells[old_n_cells] = widget; // old_n_cells specifies fisrt vacant position        
  317.         
  318.         for( int i = 0; i <= old_n_cells; i++   )   {
  319.             x_ResizeToCell(i);
  320.         }
  321.     }
  322. }
  324. void    CSplitter::add(Fl_Widget&  w)
  325. {
  326.     CSplitter::add(&w);
  327. }
  329. void    CSplitter::remove(Fl_Widget &w)
  330. {
  331.     TCells::iterator it = std::find(m_vCells.begin(), m_vCells.end(), &w);
  332.     if(it != m_vCells.end())    {
  333.         *it = NULL;
  334.         Fl_Group::remove(w);
  335.     }
  336. }
  338. void    CSplitter::draw()
  339. {
  340.     fl_push_clip(x(), y(), w(), h());
  342.     if (damage() & ~FL_DAMAGE_CHILD) { // redraw the entire thing:  
  343.         draw_box();
  345.         int n_cols = GetColumnsCount();
  346.         int n_rows = GetRowsCount();       
  348.         for( int i_x = 0;  i_x < n_cols;  i_x++ )    {
  349.             int left = x_GetLeft(i_x);    
  350.             int right = x_GetRight(i_x);    
  352.             for( int i_y = 0;  i_y < n_rows;  i_y++ )   {
  353.                 int top = x_GetTop(i_y);
  354.                 int bottom = x_GetBottom(i_y);
  355.                 
  356.                 // horizontal segment
  357.                 draw_box(FL_UP_BOX, left, bottom + 1, right - left + 1, m_SepSize, FL_GRAY);
  358.                 // vertical segment
  359.                 draw_box(FL_UP_BOX, right + 1, top, m_SepSize, bottom - top + 1, FL_GRAY);
  360.                 // intersection
  361.                 draw_box(FL_UP_BOX, right + 1, bottom + 1, m_SepSize, m_SepSize, FL_GRAY);
  362.             }        
  363.         }
  364.     }
  366.     draw_children();
  367.     
  368.     fl_pop_clip();
  369. }
  371. void    CSplitter::resize(int new_x, int new_y, int new_w, int new_h)
  372. {
  373.     bool b_size_changed = new_w != w()  || new_h != h();
  374.     bool b_pos_changed = new_x != x()  || new_y != y();
  375.     
  376.     if(b_size_changed)  {
  377.         x_DoResize(m_vSplitPosX, m_vNormSizeX, w(), new_w); // horizontal
  378.         x_DoResize(m_vSplitPosY, m_vNormSizeY, h(), new_h); // vertical
  379.     }
  381.     if(b_size_changed  ||  b_pos_changed)   {
  382.         Fl_Widget::resize(new_x, new_y, new_w, new_h);
  383.     
  384.         for(int i = 0; i < (int) m_vCells.size(); i++ )    {
  385.             if(m_vCells[i])
  386.                 x_ResizeToCell(i);
  387.         }    
  388.         redraw();
  389.     }
  390. }
  392. void    CSplitter::init_sizes() {   x_Deprecated();   }
  393. void    CSplitter::insert(Fl_Widget &w, int n)  {   x_Deprecated();   }
  394. void    CSplitter::begin()  {   x_Deprecated();   }
  395. void    CSplitter::end()    {   x_Deprecated();   }
  396. const Fl_Widget** CSplitter::array() const  
  397. {   
  398.     x_Deprecated();  return NULL;
  399. }
  400. Fl_Widget*        CSplitter::child(int n) const
  401. {
  402.     x_Deprecated();  return NULL;
  403. }
  404. int     CSplitter::children() const 
  405. {
  406.     x_Deprecated();  return -1;  
  407. }
  408. int     CSplitter::find(const Fl_Widget *w) const
  409. {
  410.     x_Deprecated();  return -1;  
  411. }
  412. int     CSplitter::find(const Fl_Widget &w) const
  413. {
  414.     x_Deprecated();  return -1;  
  415. }
  416. void    CSplitter::resizable(Fl_Widget *box)   {   x_Deprecated();   }
  417. void    CSplitter::resizable(Fl_Widget &box)   {   x_Deprecated();   }
  418. Fl_Widget*  CSplitter::resizable() const
  419. {
  420.     x_Deprecated();  return NULL;
  421. }
  423. Fl_Group&   CSplitter::add_resizable(Fl_Widget &box)
  424. {
  425.     x_Deprecated();  return *this;
  426. }
  428. Fl_Widget*   CSplitter::x_GetCell(int i_x, int i_y)
  429. {
  430.     bool b_valid = (i_x >= 0  &&  i_x <= (int) m_vSplitPosX.size())
  431.                     && (i_y >= 0  &&  i_y <= (int) m_vSplitPosY.size());
  432.     _ASSERT(b_valid);
  433.     if(b_valid) {
  434.         int index = i_x + i_y * GetColumnsCount();
  435.         return m_vCells[index];
  436.     }
  437.     return NULL;
  438. }
  440. int     CSplitter::x_GetCellIndex(int i_x, int i_y)
  441. {
  442.     bool b_valid = (i_x >= 0  &&  i_x <= (int) m_vSplitPosX.size())
  443.                     && (i_y >= 0  &&  i_y <= (int) m_vSplitPosY.size());
  444.     _ASSERT(b_valid);
  445.     return b_valid ? (i_x + i_y * GetColumnsCount()) : -1;
  446. }
  448. int     CSplitter::x_GetColumn(int i_cell) const
  449. {
  450.     _ASSERT(i_cell >= 0  &&  i_cell < (int) m_vCells.size());
  451.     int n_cols = m_vSplitPosX.size() + 1;
  452.     return i_cell % n_cols;
  453. }
  455. int     CSplitter::x_GetRow(int i_cell) const
  456. {
  457.     _ASSERT(i_cell >= 0  &&  i_cell < (int) m_vCells.size());
  458.     int n_cols = m_vSplitPosX.size() + 1;
  459.     return i_cell / n_cols;
  460. }
  462. int     CSplitter::x_GetLeft(int i_x)     const
  463. {
  464.     _ASSERT(i_x >= 0  &&  i_x <= (int) m_vSplitPosX.size());
  465.     int loc_x = (i_x == 0) ? 0 : (m_vSplitPosX[i_x - 1] + m_SepSize);
  466.     return x() + loc_x;
  467. }
  469. int     CSplitter::x_GetRight(int i_x)  const
  470. {
  471.     _ASSERT(i_x >= 0  &&  i_x <= (int) m_vSplitPosX.size());
  472.     int loc_next =  (i_x == (int) m_vSplitPosX.size()) ? w() : m_vSplitPosX[i_x];
  473.     return x() + loc_next - 1;
  474. }
  476. int     CSplitter::x_GetWidth(int i_x)  const
  477. {
  478.     _ASSERT(i_x >= 0  &&  i_x <= (int) m_vSplitPosX.size());
  479.     int top = (i_x == 0) ? 0 : m_vSplitPosX[i_x - 1] + m_SepSize;
  480.     int next =  (i_x == (int) m_vSplitPosX.size()) ? w() : m_vSplitPosX[i_x];
  481.     return next - top;
  482. }
  484. int     CSplitter::x_GetTop(int i_y)     const
  485. {
  486.     _ASSERT(i_y >= 0  &&  i_y <= (int) m_vSplitPosY.size());
  487.     int loc_y = (i_y == 0) ? 0 : (m_vSplitPosY[i_y - 1] + m_SepSize);
  488.     return y() + loc_y;
  489. }
  491. int     CSplitter::x_GetBottom(int i_y)  const
  492. {
  493.     _ASSERT(i_y >= 0  &&  i_y <= (int) m_vSplitPosY.size());
  494.     int loc_next =  (i_y == (int) m_vSplitPosY.size()) ? h() : m_vSplitPosY[i_y];
  495.     return y() + loc_next - 1;
  496. }
  498. int     CSplitter::x_GetHeight(int i_y)  const
  499. {
  500.     _ASSERT(i_y >= 0  &&  i_y <= (int) m_vSplitPosY.size());
  501.     int top = (i_y == 0) ? 0 : m_vSplitPosY[i_y - 1] + m_SepSize;
  502.     int next =  (i_y == (int) m_vSplitPosY.size()) ? h() : m_vSplitPosY[i_y];
  503.     return next - top;
  504. }
  506. // removes all child widgets and separators
  507. void    CSplitter::x_Clear()
  508. {
  509.     clear();
  510.     m_vSplitPosX.clear();
  511.     m_vSplitPosY.clear();
  512.     
  513.     m_vCells.resize(1, NULL);
  514.     
  515.     m_vNormSizeX.clear();
  516.     m_vNormSizeX.push_back(-1);
  517.     
  518.     m_vNormSizeY.clear();
  519.     m_vNormSizeY.push_back(-1);
  520. }
  523. void    CSplitter::x_ResizeToCell(int i_cell)
  524. {
  525.     int i_x = x_GetColumn(i_cell);
  526.     int i_y = x_GetRow(i_cell);
  527.     x_ResizeToCell(i_x, i_y);
  528. }
  530. void    CSplitter::x_ResizeToCell(int i_x, int i_y)
  531. {
  532.     Fl_Widget* w = x_GetCell(i_x, i_y);
  533.     if(w)   {
  534.         int left = x_GetLeft(i_x);
  535.         int width = x_GetWidth(i_x);
  536.         int top = x_GetTop(i_y);
  537.         int height = x_GetHeight(i_y);
  538.         
  539.         w->resize(left, top, width, height);
  540.     }    
  541. }
  544. int  CSplitter::handle(int event)
  545. {
  546.     m_Event.OnFLTKEvent(event);
  548.     int res = 0;
  549.     switch(event)   {
  550.     case FL_KEYDOWN:
  551.     case FL_KEYUP:  res = x_HandleKeyEvent(); break;
  552.     case FL_MOVE:   res = x_HandleMouseMove(); break;
  553.     case FL_PUSH:   res = x_HandleMousePush(); break;
  554.     case FL_DRAG: res = x_HandleMouseDrag(); break;
  555.     case FL_RELEASE: res = x_HandleMouseRelease(); break;
  556.     default: res = Fl_Group::handle(event);
  557.     }     
  558.     return res;
  559. }
  561. int    CSplitter::x_HandleKeyEvent()
  562. {
  563.     return 0;
  564. }
  566. int    CSplitter::x_HandleMouseMove()
  567. {
  568.     int i_sep_x = x_HitTestSeparator(Fl::event_x() - x(), m_vSplitPosX);
  569.     int i_sep_y = x_HitTestSeparator(Fl::event_y() - y(), m_vSplitPosY);
  571.     Fl_Cursor cursor = FL_CURSOR_DEFAULT;
  572.     if(i_sep_x == -1)  {
  573.         cursor = (i_sep_y == -1) ? FL_CURSOR_DEFAULT : FL_CURSOR_NS;
  574.     } else  {
  575.         cursor = (i_sep_y == -1) ? FL_CURSOR_WE : FL_CURSOR_MOVE ;
  576.     }
  577.     fl_cursor(cursor, FL_BLACK, FL_WHITE); 
  578.     
  579.     if(i_sep_x == -1  && i_sep_y == -1) {
  580.         return Fl_Group::handle(FL_MOVE);
  581.     } else return 1;
  582. }
  584. int    CSplitter::x_HandleMousePush()
  585. {
  586.     switch(m_Event.GetGUISignal()) {
  587.     case    CGUIEvent::ePush:   return true;
  588.     case    CGUIEvent::eSelectSignal:   {
  589.         m_MouseDownX = Fl::event_x();
  590.         m_MouseDownY = Fl::event_y();
  592.         int i_sep_x = x_HitTestSeparator(Fl::event_x() - x(), m_vSplitPosX);
  593.         int i_sep_y = x_HitTestSeparator(Fl::event_y() - y(), m_vSplitPosY);
  594.         
  595.         bool b_hit_x_sep = (i_sep_x != -1);
  596.         bool b_hit_y_sep = (i_sep_y != -1);
  598.         int n_clicks = Fl::event_clicks();
  600.         if(b_hit_x_sep  ||  b_hit_y_sep)    {
  601.             if(n_clicks == 0) { // single click
  602.                 m_iDragSepX = i_sep_x;
  603.                 m_iDragSepY = i_sep_y;
  605.                 m_StartPosX = (m_iDragSepX == -1) ? -1 : m_vSplitPosX[m_iDragSepX];
  606.                 m_StartPosY = (m_iDragSepY == -1) ? -1 : m_vSplitPosY[m_iDragSepY];
  607.             } else if(n_clicks == 1)    { // double click
  608.                 x_DistributeEvenly(b_hit_x_sep, b_hit_y_sep);
  610.                 return 1;
  611.             }
  612.             return 1;
  613.         }
  614.         return Fl_Group::handle(FL_PUSH);
  615.     }
  616.     default: break;
  617.     }; //switch
  618.     return Fl_Group::handle(FL_PUSH);
  619. }
  621. int    CSplitter::x_HandleMouseDrag()
  622. {
  623.     if(x_IsDragging()) {
  624.         x_DoDragSeparator(false);      
  625.         return 1;
  626.     }
  627.     return Fl_Group::handle(FL_DRAG);
  628. }
  630. int    CSplitter::x_HandleMouseRelease()
  631. {
  632.     bool b_handled = false;
  634.     if(x_IsDragging()) { // if dragging - do not share events with children
  635.         x_DoDragSeparator(true);
  637.         m_iDragSepX = m_iDragSepY = -1;
  638.         b_handled = true;
  639.     } else  {
  640.         int i_cell_x, i_cell_y, i_sep_x, i_sep_y;
  642.         x_HitTest(Fl::event_x() - x(), m_vSplitPosX, i_cell_x, i_sep_x);
  643.         x_HitTest(Fl::event_y() - y(), m_vSplitPosY, i_cell_y, i_sep_y);
  645.         if(m_Event.GetGUISignal() ==  CGUIEvent::ePopupSignal)   {
  646.             if(i_cell_x != -1  && i_cell_y != -1) { // hit the cell
  647.                 b_handled = Fl_Group::handle(FL_RELEASE) != 0; // let the children handle it
  648.             }
  649.             if(! b_handled) { // not on child or children haven't handled  
  650.                 fl_cursor(FL_CURSOR_DEFAULT, FL_BLACK, FL_WHITE); 
  651.                 x_OnShowPopupMenu();    
  652.                 b_handled = true;
  653.             }
  654.         } else Fl_Group::handle(FL_RELEASE); // default handling
  655.     }
  656.     return b_handled ? 1 : 0; 
  657. }
  659. void    CSplitter::x_DoDragSeparator(bool b_final)
  660. {
  661.     int start_x = 0, stop_x = -1;
  662.     int start_y = 0, stop_y = -1;
  664.     if(m_iDragSepX != -1)   {
  665.         int shift = Fl::event_x() - m_MouseDownX; // global shift
  666.         int new_pos = m_StartPosX + shift;
  667.         x_MoveSeparator(m_iDragSepX, new_pos, m_vSplitPosX, w(), start_x, stop_x);
  669.         if(b_final) {
  670.             m_vNormSizeX[m_iDragSepX] = -1;
  671.             m_vNormSizeX[m_iDragSepX + 1] = -1;
  672.         }
  673.     }
  674.     if(m_iDragSepY != -1)   {
  675.         int shift = Fl::event_y() - m_MouseDownY; // global shift
  676.         int new_pos = m_StartPosY + shift;
  677.         x_MoveSeparator(m_iDragSepY, new_pos, m_vSplitPosY, h(), start_y, stop_y);
  679.         if(b_final) {
  680.             m_vNormSizeY[m_iDragSepY] = -1;
  681.             m_vNormSizeY[m_iDragSepY + 1] = -1;
  682.         }
  683.     }
  684.     
  685.     x_UpdateRegion(start_x, stop_x, start_y, stop_y);      
  686. }
  688. // z is local coordinate in the dimension corresponding to vpos
  689. int     CSplitter::x_HitTestSeparator(int z, TPosVector& vpos)
  690. {
  691.     int n = vpos.size();
  692.     for( int i = 0; i < n; i++  )   {
  693.         int pos = vpos[i];
  694.         if(z >= pos  &&  z < pos + m_SepSize)
  695.             return i;
  696.     }
  697.     return -1;
  698. }
  700. // assuming that "z" is within splitter bounds
  701. void    CSplitter::x_HitTest(int z, TPosVector& vpos, int& i_cell, int& i_sep)
  702. {
  703.     i_sep = i_cell = -1;
  704.     int n = vpos.size();
  705.     for( int i = 0; i < n; i++  )   {
  706.         int pos = vpos[i];
  707.         if(z < pos) { // belongs to cell
  708.             i_cell = i;
  709.             return;
  710.         } else if(z < pos + m_SepSize)  { // belongs to separator
  711.             i_sep = i;
  712.             return;
  713.         }
  714.     }
  715.     i_cell = n;
  716.     return; // belongs to last cell
  717. }
  720. void    CSplitter::x_OnShowPopupMenu()
  721. {
  722. }
  724. void    CSplitter::x_DistributeEvenly(bool b_x, bool b_y)
  725. {
  726.     if(b_x) {
  727.         x_DoDistributeEvenly(m_vSplitPosX, w());
  728.         std::fill(m_vNormSizeX.begin(), m_vNormSizeX.end(), -1);
  729.     }
  731.     if(b_y) {
  732.         x_DoDistributeEvenly(m_vSplitPosY, h());
  733.         std::fill(m_vNormSizeY.begin(), m_vNormSizeY.end(), -1);
  734.     }
  736.     if(b_x  ||  b_y)    {
  737.         for( int i = 0; i < (int) m_vCells.size(); i++ )  {
  738.             int i_x = x_GetColumn(i);
  739.             int i_y = x_GetRow(i);
  740.             x_ResizeToCell(i_x, i_y);
  741.         }
  742.         redraw();
  743.     }
  744. }
  746. void    CSplitter::x_DoDistributeEvenly(TPosVector& vSplitPos, int size)
  747. {
  748.     int n = vSplitPos.size() + 1;
  749.     int space = max(0, size - m_SepSize * (n - 1));
  750.     int w = space / n; // space per row/column
  751.     int rest = space - w * n; // space that cannot be divided evenly
  752.     
  753.     int pos = w + (rest ? 1 : 0);
  755.     for( int i = 0; i < n - 1; i++ )   {
  756.         vSplitPos[i] = pos;
  757.         pos += w + m_SepSize;
  758.         if(i < rest) // for first "rest" children add 1 pixel
  759.             pos++;
  760.     }
  761. }
  763. void    CSplitter::x_DoResize(TPosVector& v_split_pos, TSizeVector& v_norm_sizes, int size, int new_size)
  764. {        
  765.     _ASSERT(v_split_pos.size() + 1 == v_norm_sizes.size());
  766.     
  767.     int n_split = v_split_pos.size();
  768.     int min_size = n_split * m_SepSize;
  770.     if(new_size < size) { // splitter is shrinking        
  771.         int limit = max(new_size, min_size); 
  772.     
  773.         for( int i = n_split; i >= 0; i--)   {         
  774.             int next_start = (i == n_split) ? size : v_split_pos[i];
  775.             if(next_start >= limit) { // shrink it
  776.                 int start = (i == 0) ? 0 : (v_split_pos[i - 1] + m_SepSize);        
  777.             
  778.                 if(visible()  &&  v_norm_sizes[i] < 0) { 
  779.                     // splitter is visible and cell is being resized for the fisrt time
  780.                     v_norm_sizes[i] = next_start - start; // save original size
  781.                 }
  782.                 if(i < n_split) {
  783.                     v_split_pos[i] = limit; // move separator
  784.                 }
  785.                 limit -= m_SepSize;            
  786.             }
  787.             else break;
  788.         } 
  789.     } else if(new_size > size)  { // splitter is growing
  790.         int grow_space = min(new_size - size, size - min_size); 
  791.         int shift = 0; // cumulative shift for split positions
  793.         for( int i = 0; i < n_split; i++)   {
  794.             if(grow_space > 0  &&  v_norm_sizes[i] > 0) {
  795.                 // cell needs to grow and there is space left
  796.                 int start = (i == 0) ? 0 : (v_split_pos[i - 1] + m_SepSize);        
  797.                 int next_start = + (i == n_split) ? size : v_split_pos[i];
  798.                 int sz = next_start - start; // current size
  799.                 int new_sz = min(v_norm_sizes[i], sz + grow_space);
  800.                 
  801.                 if(new_sz >= v_norm_sizes[i])   {
  802.                     v_norm_sizes[i] = -1; // does not want to grow anymore
  803.                 }
  804.                 int d_sz = new_sz - sz; // size increase
  805.                 shift += d_sz;
  806.                 grow_space -= d_sz;               
  807.             }
  808.             if(shift)   {
  809.                 v_split_pos[i] += shift;
  810.             }
  811.         }
  812.     }
  813. }
  815. void    CSplitter::x_MoveSeparator(int i_sep, int new_pos, 
  816.                                    TPosVector& vSplitPos, int size, 
  817.                                    int& start, int& stop)
  818. {
  819.     _ASSERT(i_sep >= 0  && i_sep < (int) vSplitPos.size());
  821.     start = 0;
  822.     stop = -1; // set empty range
  824.     int pos = vSplitPos[i_sep];
  825.     int d = new_pos - pos;
  826.         
  827.     if(d != 0)  {
  828.         int n_sep = vSplitPos.size();
  830.         if(d > 0)    { // movind down        
  831.             int bottom_lim = size - (n_sep - i_sep) * m_SepSize;
  832.             new_pos = min(new_pos, bottom_lim);
  834.             if(new_pos > pos)   { // there is space to move to    
  835.                 int  p = new_pos;
  836.                 int i = i_sep;
  837.                 // move current separator and , if necessary, separator below it
  838.                 for(; i < n_sep; i++)  { 
  839.                     if(p > vSplitPos[i])  {
  840.                         vSplitPos[i] = p;
  841.                         p += m_SepSize;
  842.                     } else break;                
  843.                 }
  844.                 // resize children
  845.                 start = i_sep;
  846.                 stop = min(i, n_sep);
  847.             }
  848.         } else if(d < 0)    { //moving up
  849.             int top_lim = i_sep * m_SepSize;
  850.             new_pos = max(new_pos, top_lim);
  852.             if(new_pos < pos)   { // there is space to move to
  853.                 int p = new_pos;
  854.                 int i = i_sep;
  855.                 
  856.                 // move current separator and , if necessary, separator below it
  857.                 for(; i >= 0; i--)  { 
  858.                     if(p < vSplitPos[i])  {
  859.                         vSplitPos[i] = p;
  860.                         p -= m_SepSize;
  861.                     } else break;                
  862.                 }
  863.                 // resize children
  864.                 start = max(0, i + 1);
  865.                 stop = i_sep + 1;
  866.             }
  867.         }
  868.     }
  869. }
  871. void    CSplitter::x_UpdateRegion(int start_x, int stop_x, int start_y, int stop_y)
  872. {
  873.     bool b_redraw = false;
  874.     for(int i_x = 0; i_x <= (int) m_vSplitPosX.size(); i_x++ ) {
  875.         for( int i_y = 0; i_y <= (int) m_vSplitPosY.size(); i_y++  )   {
  876.             // if cell belongs to one of the affected ranges - resize it
  877.             if( (i_x >= start_x  &&  i_x <= stop_x)  ||
  878.                 (i_y >= start_y  &&  i_y <= stop_y) )   { 
  879.                 b_redraw = true;
  880.                 x_ResizeToCell(i_x, i_y);
  881.             }
  882.         }
  883.     }
  884.     if(b_redraw)    {
  885.         redraw();
  886.     }
  887. }
  889. void    CSplitter::x_NewSplit(TPosVector& v_split_pos, TSizeVector& v_norm_size, int size)
  890. {        
  891.     int n_split = v_split_pos.size();
  892.     int sum_size = h() - n_split * m_SepSize;
  893.     int av_size = sum_size / (n_split + 1); // average cell size
  895.     // splitting...
  896.     v_split_pos.push_back(size);
  897.     v_norm_size.push_back(-1);
  898.     n_split++;
  900.     // calculate new sizes
  901.     double K = (double)(sum_size - m_SepSize) / (sum_size + av_size);        
  902.     TPosVector sizes(n_split);
  903.     for( int i = 0; i < n_split; i++ )  {
  904.         int start = (i == 0) ? 0 : v_split_pos[i - 1] + m_SepSize;
  905.         int size = v_split_pos[i] - start;
  906.         sizes[i] = (int)( K * size);        
  907.     }
  908.     
  909.     // moving split points
  910.     for( int pos = 0, i = 0; i < n_split; i++ )  {
  911.         pos += sizes[i];
  912.         v_split_pos[i] = pos;
  913.         pos += m_SepSize;
  914.     }
  915. }
  918. END_NCBI_SCOPE
  921. /*
  922.  * ===========================================================================
  923.  * $Log: splitter.cpp,v $
  924.  * Revision 1000.1  2004/06/01 21:09:10  gouriano
  925.  * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.7
  926.  *
  927.  * Revision 1.7  2004/05/21 22:27:53  gorelenk
  928.  * Added PCH ncbi_pch.hpp
  929.  *
  930.  * Revision 1.6  2004/05/13 17:22:54  yazhuk
  931.  * Clean-up
  932.  *
  933.  * Revision 1.5  2004/05/10 16:25:40  yazhuk
  934.  * Addressed GCC warnings
  935.  *
  936.  * Revision 1.4  2004/02/04 20:02:44  yazhuk
  937.  * Added Remove(), RemoveAll(), Find() and new overload for Create()
  938.  *
  939.  * Revision 1.3  2004/01/28 16:40:28  yazhuk
  940.  * Major refactoring, bug fixes, added new functions
  941.  *
  942.  * Revision 1.2  2004/01/23 00:00:29  ucko
  943.  * Properly capitalize FL directory for headers.
  944.  *
  945.  * Revision 1.1  2004/01/22 16:26:24  yazhuk
  946.  * Initial revision
  947.  *
  948.  * ===========================================================================
  949.  */