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

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

生物技术

开发平台：

C/C++

Flu_Wrap_Group.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: Flu_Wrap_Group.cpp,v $
  4.  * PRODUCTION Revision 1000.1  2004/06/01 21:06:11  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.2
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*
  11.  * These files were imported into NCBI's CVS directly from FLU version 2.9.1.
  12.  * Modifications to the source are listed below.
  13.  *
  14.  * ==========================================================================
  15.  * $Log: Flu_Wrap_Group.cpp,v $
  16.  * Revision 1000.1  2004/06/01 21:06:11  gouriano
  17.  * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.2
  18.  *
  19.  * Revision 1.2  2004/05/21 22:27:51  gorelenk
  20.  * Added PCH ncbi_pch.hpp
  21.  *
  22.  * Revision 1.1  2004/03/11 13:51:40  dicuccio
  23.  * Imported FLU version 2.9.1.  Altered export specifiers to match NCBI layout.
  24.  * Altered include paths to match NCBI toolkit layout.
  25.  *
  26.  * ==========================================================================
  27.  */
  28. // $Id: Flu_Wrap_Group.cpp,v 1000.1 2004/06/01 21:06:11 gouriano Exp $
  30. /***************************************************************
  31.  *                FLU - FLTK Utility Widgets 
  32.  *  Copyright (C) 2002 Ohio Supercomputer Center, Ohio State University
  33.  *
  34.  * This file and its content is protected by a software license.
  35.  * You should have received a copy of this license with this file.
  36.  * If not, please contact the Ohio Supercomputer Center immediately:
  37.  * Attn: Jason Bryan Re: FLU 1224 Kinnear Rd, Columbus, Ohio 43212
  38.  * 
  39.  ***************************************************************/
  43. #include <ncbi_pch.hpp>
  44. #include <gui/widgets/FLU/Flu_Wrap_Group.h>
  45. #include <string.h>
  46. #include <stdio.h>
  48. #define MAX( x, y ) ( (x)>(y) ? (x) : (y) )
  50. #define SCROLL_SIZE 15
  52. Flu_Wrap_Group :: Scrollbar :: Scrollbar( int x, int y, int w, int h, const char *l )
  53.   : Fl_Scrollbar( x, y, w, h, l )
  54. {
  55. }
  57. int Flu_Wrap_Group :: Scrollbar :: handle( int event )
  58. {
  59.   if( event == FL_MOUSEWHEEL )
  60.     {
  61.       handle_drag( clamp( value() + linesize() * Fl::e_dy ) );
  62.       return 1;
  63.     }
  64.   else
  65.     return Fl_Scrollbar::handle( event );
  66. }
  68. Flu_Wrap_Group :: Flu_Wrap_Group( int x, int y, int w, int h, const char *l )
  69.   : Fl_Group( x, y, w, h, l ), scrollbar( x+w-SCROLL_SIZE, y, SCROLL_SIZE, h ), group( x, y, w-SCROLL_SIZE, h )
  70. {
  71.   offset( 0, 0 );
  72.   spacing( 0, 0 );
  73.   _type = FL_VERTICAL;
  74.   scrollTo = NULL;
  76.   Fl_Group::add( &scrollbar );
  77.   scrollbar.callback( _scrollCB, this );
  78.   scrollbar.linesize( 10 );
  79.   scrollbar.range( 0, 100 );
  80.   scrollbar.show();
  82.   Fl_Group::add( &group );
  83.   Fl_Group::resizable( group );
  84.   Fl_Group::end();
  85.   group.begin();
  86. }
  88. void Flu_Wrap_Group :: resize( int x, int y, int w, int h )
  89. {
  90.   group.resizable( NULL );
  91.   Fl_Group::resize( x, y, w, h );
  92.   if( type() == FL_VERTICAL )
  93.     {
  94.       scrollbar.resize( x+w-SCROLL_SIZE-Fl::box_dx(box()), y+Fl::box_dy(box()), SCROLL_SIZE, h-Fl::box_dh(box()) );
  95.       group.resize( x, y, w-SCROLL_SIZE-Fl::box_dx(box()), h );
  96.     }
  97.   else
  98.     {
  99.       scrollbar.resize( x+Fl::box_dx(box()), y+h-SCROLL_SIZE-Fl::box_dy(box()), w-Fl::box_dw(box()), SCROLL_SIZE );
  100.       group.resize( x, y, w, h-SCROLL_SIZE-Fl::box_dh(box()) );
  101.     }
  102.   Fl_Group::init_sizes();
  103.   redraw();
  104. }
  106. void Flu_Wrap_Group :: scroll_to( const Fl_Widget *w )
  107. {
  108.   scrollTo = w;
  109.   redraw();
  110. }
  112. void Flu_Wrap_Group :: scroll_to_beginning()
  113. {
  114.   ((Fl_Valuator*)&scrollbar)->value( scrollbar.minimum() );
  115. }
  117. void Flu_Wrap_Group :: scroll_to_end()
  118. {
  119.   ((Fl_Valuator*)&scrollbar)->value( scrollbar.maximum() );
  120. }
  122. void Flu_Wrap_Group :: type( int t )
  123. {
  124.   _type = t;
  125.   resize( x(), y(), w(), h() );
  126. }
  128. Fl_Widget* Flu_Wrap_Group :: next( Fl_Widget* w )
  129. {
  130.   for( int i = 0; i < group.children()-1; i++ )
  131.     {
  132.       if( w == group.child(i) )
  133. return group.child(i+1);
  134.     }
  135.   return NULL;
  136. }
  138. Fl_Widget* Flu_Wrap_Group :: previous( Fl_Widget* w )
  139. {
  140.   for( int i = 1; i < group.children(); i++ )
  141.     {
  142.       if( w == group.child(i) )
  143. return group.child(i-1);
  144.     }
  145.   return NULL;
  146. }
  148. Fl_Widget* Flu_Wrap_Group :: above( Fl_Widget* w )
  149. {
  150.   for( int i = 0; i < group.children(); i++ )
  151.     {
  152.       if( w == group.child(i) )
  153. {
  154.   int measure[2];
  155.   measure[0] = w->x() + w->w()/2;
  156.   measure[1] = w->y() - _spacing[1];
  157.   int index = layout( scrollbar.visible(), false, measure );
  158.   if( index >= 0 )
  159.     return group.child(index);
  160.   else
  161.     return group.child(0);
  162. }
  163.     }
  164.   return NULL;
  165. }
  167. Fl_Widget* Flu_Wrap_Group :: below( Fl_Widget* w )
  168. {
  169.   for( int i = 0; i < group.children(); i++ )
  170.     {
  171.       if( w == group.child(i) )
  172. {
  173.   int measure[2];
  174.   measure[0] = w->x() + w->w()/2;
  175.   measure[1] = w->y() + w->h() + _spacing[1];
  176.   int index = layout( scrollbar.visible(), false, measure );
  177.   if( index >= 0 )
  178.     return group.child(index);
  179.   else
  180.     return group.child(group.children()-1);
  181. }
  182.     }
  183.   return NULL;
  184. }
  186. Fl_Widget* Flu_Wrap_Group :: left( Fl_Widget* w )
  187. {
  188.   for( int i = 0; i < group.children(); i++ )
  189.     {
  190.       if( w == group.child(i) )
  191. {
  192.   int measure[2];
  193.   measure[0] = w->x() - _spacing[0];
  194.   measure[1] = w->y() + w->h()/2;
  195.   int index = layout( scrollbar.visible(), false, measure );
  196.   if( index >= 0 )
  197.     return group.child(index);
  198.   else
  199.     return group.child(0);
  200. }
  201.     }
  202.   return NULL;
  203. }
  205. Fl_Widget* Flu_Wrap_Group :: right( Fl_Widget* w )
  206. {
  207.   for( int i = 0; i < group.children(); i++ )
  208.     {
  209.       if( w == group.child(i) )
  210. {
  211.   int measure[2];
  212.   measure[0] = w->x() + w->w() + _spacing[0] + 1;
  213.   measure[1] = w->y() + w->h()/2;
  214.   int index = layout( scrollbar.visible(), false, measure );
  215.   if( index >= 0 )
  216.     return group.child(index);
  217.   else
  218.     return group.child(group.children()-1);
  219. }
  220.     }
  221.   return NULL;
  222. }
  224. int Flu_Wrap_Group :: layout( bool sbVisible, bool doScrollTo, int *measure )
  225. {
  226.   int xx = x()+Fl::box_dx(box()), yy = y()+Fl::box_dy(box()),
  227.     ww = w()-Fl::box_dw(box()), hh = h()-Fl::box_dh(box());
  229.   if( type() == FL_VERTICAL )
  230.     {
  231.       int i, X, Y, maxH, H, col, row, maxW, scrollY;
  232.       Fl_Widget *c;
  234.       scrollbar.type( FL_VERTICAL );
  236.     BEGIN_H:
  238.       X = xx+_offset[0];
  239.       Y = yy+_offset[1] - (sbVisible ? scrollbar.value() : 0);
  240.       maxH = _offset[1];
  241.       H = 0;
  242.       col = 0;
  243.       row = 0;
  244.       scrollY = 0;
  245.       maxW = xx + ww - (sbVisible ? scrollbar.w() : 0);
  247.       for( i = 0; i < group.children(); i++ )
  248. {
  249.   c = group.child(i);
  250.   if( !c->visible() )
  251.     continue;
  252.   H = MAX( H, c->h() );
  253.   if( col == 0 )
  254.     maxH += H + _spacing[1];
  255.   if( ( X + c->w() ) > maxW )
  256.     {
  257.       Y += H + _spacing[1];
  258.       scrollY += H + _spacing[1];
  259.       if( i == group.children()-1 )
  260. maxH += H + _spacing[1];
  262.       if( measure )
  263. {
  264.   if( xx+_offset[0] <= measure[0] && measure[0] <= xx+c->w()+_offset[0]+_spacing[0] &&
  265.       Y <= measure[1] && measure[1] <= Y+c->h()+_spacing[1] )
  266.     return i;
  267. }
  268.       else
  269. c->position( xx+_offset[0], Y );
  271.       col = 0;
  272.       row++;
  273.       H = 0;
  274.       X = xx+c->w() + _offset[0] + _spacing[0];
  275.     }
  276.   else
  277.     {
  278.       if( measure )
  279. {
  280.   if( X <= measure[0] && measure[0] <= X+c->w()+_spacing[0] &&
  281.       Y <= measure[1] && measure[1] <= Y+c->h()+_spacing[1] )
  282.     return i;
  283. }
  284.       else
  285. c->position( X, Y );
  286.       X += c->w() + _spacing[0];
  287.       col++;
  288.     }
  290.   if( doScrollTo && (c == scrollTo) )
  291.     {
  292.       if( scrollY > scrollbar.maximum() )
  293. scrollY = (int)scrollbar.maximum();
  294.       ((Fl_Valuator*)&scrollbar)->value( scrollY );
  295.       scrollTo = NULL;
  296.       goto BEGIN_H;
  297.     }
  299.   // if we exceed the height and the scrollbar is not visible,
  300.   // then it will soon become visible so we don't need to process anymore
  301.   if( !measure && !sbVisible && maxH > hh )
  302.     return 1;
  303. }
  305.       if( measure )
  306. return -1;
  307.       else if( maxH > hh )
  308. {
  309.   scrollbar.range( 0, maxH-hh );
  310.   scrollbar.slider_size( MAX( float(scrollbar.h()-(maxH-hh))/float(scrollbar.h()), 0.08f ) );
  311.   return 1;
  312. }
  313.       else
  314. return 0;
  315.     }
  316.   else
  317.     {
  318.       int i, X, Y, W, maxW, maxH, col, row, scrollX;
  319.       Fl_Widget *c;
  321.       scrollbar.type( FL_HORIZONTAL );
  323.     BEGIN_W:
  325.       X = xx+_offset[0] - (sbVisible ? scrollbar.value() : 0);
  326.       Y = yy+_offset[1];
  327.       maxW = _offset[0];
  328.       W = 0;
  329.       col = 0;
  330.       row = 0;
  331.       scrollX = 0;
  332.       maxH = yy + hh - (sbVisible ? scrollbar.h() : 0);
  334.       for( i = 0; i < group.children(); i++ )
  335. {
  336.   c = group.child(i);
  337.   if( !c->visible() )
  338.     continue;
  340.   W = MAX( W, c->w() );
  342.   if( row == 0 )
  343.     maxW += W + _spacing[0];
  345.   if( ( Y + c->h() ) > maxH )
  346.     {
  347.       X += W + _spacing[0];
  348.       scrollX += W + _spacing[0];
  349.       if( i == group.children()-1 )
  350. maxW += W + _spacing[0];
  352.       if( measure )
  353. {
  354.   if( X <= measure[0] && measure[0] <= X+c->w()+_spacing[0] &&
  355.       yy+_offset[1] <= measure[1] && measure[1] <= yy+c->h()+_offset[1]+_spacing[1] )
  356.     return i;
  357. }
  358.       else
  359. c->position( X, yy+_offset[1] );
  361.       row = 0;
  362.       col++;
  363.       W = 0;
  364.       Y = yy+c->h() + _offset[1] + _spacing[1];
  365.     }
  366.   else
  367.     {
  368.       if( measure )
  369. {
  370.   if( X <= measure[0] && measure[0] <= X+c->w()+_spacing[0] &&
  371.       Y <= measure[1] && measure[1] <= Y+c->h()+_spacing[1] )
  372.     return i;
  373. }
  374.       else
  375. c->position( X, Y );
  376.       Y += c->h() + _spacing[1];
  377.       row++;
  378.     }
  380.   if( doScrollTo && (c == scrollTo) )
  381.     {
  382.       if( scrollX > scrollbar.maximum() )
  383. scrollX = (int)scrollbar.maximum();
  384.       ((Fl_Valuator*)&scrollbar)->value( scrollX );
  385.       scrollTo = NULL;
  386.       goto BEGIN_W;
  387.     }
  389.   // if we exceed the width and the scrollbar is not visible,
  390.   // then it will soon become visible so we don't need to process anymore
  391.   if( !measure && !sbVisible && maxW > ww )
  392.     return 1;
  393. }
  395.       if( measure )
  396. return -1;
  397.       else if( maxW > ww )
  398. {
  399.   scrollbar.range( 0, maxW-ww );
  400.   scrollbar.slider_size( MAX( float(scrollbar.w()-(maxW-ww))/float(scrollbar.w()), 0.08f ) );
  401.   return 1;
  402. }
  403.       else
  404. return 0;
  405.     }
  406. }
  408. void Flu_Wrap_Group :: draw()
  409. {
  410.   // we first try to fit all children assuming no scrollbar. if they do not all fit, 
  411.   // we have to turn the scrollbar on and try again
  412.   if( layout( false, false ) )
  413.     {
  414.       scrollbar.show();
  415.       layout( true, false );
  416.     }
  417.   else
  418.     scrollbar.hide();
  420.   // hack to look right when resizing smaller
  421.   if( scrollbar.value() > scrollbar.maximum() )
  422.     {
  423.       ((Fl_Valuator*)&scrollbar)->value( scrollbar.maximum() );
  424.       layout( scrollbar.visible(), scrollTo!=NULL );
  425.     }
  426.   else if( scrollTo )
  427.     layout( scrollbar.visible(), true );
  429.   scrollTo = NULL;
  431.   if( damage() & ~FL_DAMAGE_CHILD)
  432.     {
  433.       draw_box();
  434.       draw_label();
  435.     }
  436.   fl_push_clip( x()+Fl::box_dx(box()), y()+Fl::box_dy(box()),
  437. w()-Fl::box_dw(box()), h()-Fl::box_dh(box()) );
  438.   draw_children();
  439.   fl_pop_clip();
  440. }