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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 游戏引擎 > 查看源码
glui_scrollbar.cpp
资源名称：Box2D_v2.1.2.zip　[点击查看]
上传用户：gb3593
上传日期：2022-01-07
资源大小：3028k
文件大小：24k
源码类别：

游戏引擎

开发平台：

Visual C++

glui_scrollbar.cpp：源码内容
  1. /****************************************************************************
  2.   
  3.   GLUI User Interface Toolkit
  4.   ---------------------------
  6.      glui_scrollbar.cpp - GLUI_Scrollbar class
  8.           --------------------------------------------------
  10.   Copyright (c) 2004 John Kew, 1998 Paul Rademacher
  12.   This program is freely distributable without licensing fees and is
  13.   provided without guarantee or warrantee expressed or implied. This
  14.   program is -not- in the public domain.
  16. *****************************************************************************/
  18. #include "glui_internal_control.h"
  19. #include <cmath>
  20. #include <cassert>
  22. /*static int __debug=0;              */
  24. #define  GLUI_SCROLL_GROWTH_STEPS         800
  25. #define  GLUI_SCROLL_MIN_GROWTH_STEPS     100
  26. #define  GLUI_SCROLL_CALLBACK_INTERVAL    1    /* Execute the user's callback every this many clicks */
  28. enum {
  29.   GLUI_SCROLL_ARROW_UP,
  30.   GLUI_SCROLL_ARROW_DOWN,
  31.   GLUI_SCROLL_ARROW_LEFT,
  32.   GLUI_SCROLL_ARROW_RIGHT
  33. };
  34.   
  36. /****************************** GLUI_Scrollbar::GLUI_Scrollbar() **********/
  37. // Constructor, no live var
  38. GLUI_Scrollbar::GLUI_Scrollbar( GLUI_Node *parent,
  39.                                 const char *name, 
  40.                                 int horz_vert,
  41.                                 int data_type,
  42.                                 int id, GLUI_CB callback
  43.                                 /*,GLUI_Control *object
  44.                                 ,GLUI_InterObject_CB obj_cb*/
  45.                                 )
  46. {
  47.   common_construct(parent, name, horz_vert, data_type, NULL, id, callback/*, object, obj_cb*/);
  48. }
  50. /****************************** GLUI_Scrollbar::GLUI_Scrollbar() **********/
  51. // Constructor, int live var
  52. GLUI_Scrollbar::GLUI_Scrollbar( GLUI_Node *parent, const char *name, 
  53.                                 int horz_vert,
  54.                                 int *live_var,
  55.                                 int id, GLUI_CB callback
  56.                                 /*,GLUI_Control *object
  57.                                 ,GLUI_InterObject_CB obj_cb*/
  58.                                 )
  59. {
  60.   common_construct(parent, name, horz_vert, GLUI_SCROLL_INT, live_var, id, callback/*, object, obj_cb*/);
  61. }
  63. /****************************** GLUI_Scrollbar::GLUI_Scrollbar() **********/
  64. // Constructor, float live var
  65. GLUI_Scrollbar::GLUI_Scrollbar( GLUI_Node *parent, const char *name,
  66.                                 int horz_vert,
  67.                                 float *live_var,
  68.                                 int id, GLUI_CB callback
  69.                                 /*,GLUI_Control *object
  70.                                 ,GLUI_InterObject_CB obj_cb*/
  71.                                 )
  72. {
  73.   common_construct(parent, name, horz_vert, GLUI_SCROLL_FLOAT, live_var, id, callback/*, object, obj_cb*/);
  74. }
  76. /****************************** GLUI_Scrollbar::common_init() **********/
  77. void GLUI_Scrollbar::common_init(void)
  78. {
  79.    horizontal = true;
  80.    h = GLUI_SCROLL_ARROW_HEIGHT;
  81.    w = GLUI_TEXTBOX_WIDTH;
  82.    alignment = GLUI_ALIGN_CENTER;
  83.    x_off = 0;
  84.    y_off_top = 0;
  85.    y_off_bot = 0;
  86.    can_activate = true;
  87.    state = GLUI_SCROLL_STATE_NONE;
  88.    growth_exp = GLUI_SCROLL_DEFAULT_GROWTH_EXP;
  89.    callback_count = 0;
  90.    first_callback = true;
  91.    user_speed = 1.0;
  92.    float_min = 0.0;
  93.    float_max = 0.0;
  94.    int_min = 0;
  95.    int_max = 0;
  96.    associated_object = NULL;
  97.    last_update_time=0;
  98.    velocity_limit=50.0; /* Change value by at most 50 per second */
  99.    box_length       = 0;
  100.    box_start_position = 0;
  101.    box_end_position   = 0;
  102.    track_length       = 0;
  103. }
  105. /****************************** GLUI_Scrollbar::common_construct() **********/
  106. void GLUI_Scrollbar::common_construct(
  107.   GLUI_Node *parent,
  108.   const char *name, 
  109.   int horz_vert,
  110.   int data_type,
  111.   void *data,
  112.   int id, GLUI_CB callback
  113.   /*,GLUI_Control *object,
  114.   GLUI_InterObject_CB obj_cb*/
  115.   )
  116. {
  117.   common_init();
  119.   // make sure limits are wide enough to hold live value
  120.   if (data_type==GLUI_SCROLL_FLOAT) {
  121.     float lo = 0.0f, hi=1.0f;
  122.     if (data) {
  123.       float d = *(float*)(data);
  124.       lo = MIN(lo, d);
  125.       hi = MAX(hi, d);
  126.     }
  127.     this->set_float_limits(lo,hi);
  128.     this->set_float_val(lo);
  129.     this->live_type = GLUI_LIVE_FLOAT;
  130.   } else {
  131.     int lo = 0, hi=100;
  132.     if (data) {
  133.       int d = *(int*)(data);
  134.       lo = MIN(lo, d);
  135.       hi = MAX(hi, d);
  136.     }
  137.     this->set_int_limits(lo,hi);
  138.     this->set_int_val(0);
  139.     this->live_type = GLUI_LIVE_INT;
  140.   }
  141.   this->data_type = data_type;
  142.   this->set_ptr_val( data );
  143.   this->set_name(name);
  144.   this->user_id = id;
  145.   this->callback    = callback;
  146.   //this->associated_object = object;
  147.   //this->object_cb = obj_cb;
  148.   this->horizontal=(horz_vert==GLUI_SCROLL_HORIZONTAL);
  149.   if (this->horizontal) {
  150.     this->h = GLUI_SCROLL_ARROW_HEIGHT;
  151.     this->w = GLUI_TEXTBOX_WIDTH;
  152.   } else {
  153.     this->h = GLUI_TEXTBOX_HEIGHT;
  154.     this->w = GLUI_SCROLL_ARROW_WIDTH;
  155.   }
  156.   parent->add_control( this );
  157.   this->init_live();
  158. }
  159.  
  160. /****************************** GLUI_Scrollbar::mouse_down_handler() **********/
  162. int    GLUI_Scrollbar::mouse_down_handler( int local_x, int local_y )
  163. {
  164.   last_update_time=GLUI_Time()-1.0;
  165.   this->state = find_arrow( local_x, local_y );
  166.   GLUI_Master.glui_setIdleFuncIfNecessary();
  168.   /*  printf( "spinner: mouse down  : %d/%d   arrow:%dn", local_x, local_y,
  169.       find_arrow( local_x, local_y ));
  170.       */
  172.   if ( state != GLUI_SCROLL_STATE_UP AND state != GLUI_SCROLL_STATE_DOWN)
  173.     return true;
  175.   reset_growth();
  177.   /*** ints and floats behave a bit differently.  When you click on
  178.     an int spinner, you expect the value to immediately go up by 1, whereas
  179.     for a float it'll go up only by a fractional amount.  Therefore, we
  180.     go ahead and increment by one for int spinners ***/
  181. #if 1
  182.   if ( data_type == GLUI_SCROLL_INT ) {
  183.     // Allow for possibility of reversed limits
  184.     int lo = MIN(int_min,int_max);
  185.     int hi = MAX(int_min,int_max);
  186.     int increase = int_min < int_max ? 1 : -1;
  187.     int new_val = int_val;
  188.     if ( state == GLUI_SCROLL_STATE_UP ) {
  189.       new_val += increase;
  190.     } else if ( state == GLUI_SCROLL_STATE_DOWN ) {
  191.       new_val -= increase;
  192.     }
  193.     if (new_val >= lo && new_val <= hi && new_val!=int_val) {
  194.       set_int_val(new_val);
  195.       do_callbacks();
  196.     }
  197.   }
  198. #endif
  199.   do_click();  
  200.   redraw();
  201.   
  202.   return false;
  203. }
  206. /******************************** GLUI_Scrollbar::mouse_up_handler() **********/
  208. int    GLUI_Scrollbar::mouse_up_handler( int local_x, int local_y, bool inside )
  209. {
  210.   state = GLUI_SCROLL_STATE_NONE;
  211.   GLUI_Master.glui_setIdleFuncIfNecessary();
  213.   /*  printf("spinner: mouse up  : %d/%d    inside: %dn",local_x,local_y,inside);              */
  215.   /*glutSetCursor( GLUT_CURSOR_INHERIT );              */
  216.   glutSetCursor( GLUT_CURSOR_LEFT_ARROW );
  218.   redraw();
  220.   /*  do_callbacks(); --- stub               */
  221.   /*  if ( callback )               */
  222.   /*  callback( this->user_id );              */
  223.   
  224.   return false;
  225. }
  228. /***************************** GLUI_Scrollbar::mouse_held_down_handler() ******/
  230. int    GLUI_Scrollbar::mouse_held_down_handler( int local_x, int local_y,
  231.                                                 bool new_inside)
  232. {
  233.   int new_state;
  234.   if ( state == GLUI_SCROLL_STATE_NONE )
  235.     return false;
  236.   
  237.   /*  printf("spinner: mouse held: %d/%d    inside: %dn",local_x,local_y,
  238.       new_inside);
  239.   */
  241.   if ( state == GLUI_SCROLL_STATE_SCROLL) {   /* dragging? */
  242.     do_drag( local_x-x_abs, local_y-y_abs );
  243.   }
  244.   else {                                      /* not dragging */
  245.     new_state = find_arrow( local_x, local_y );
  247.     if ( new_state == state ) {
  248.       /** Still in same arrow **/
  249.       do_click();
  250.     }
  251.   }
  252.   redraw();
  254.   return false;
  255. }
  258. /****************************** GLUI_Scrollbar::key_handler() **********/
  260. int    GLUI_Scrollbar::key_handler( unsigned char key,int modifiers )
  261. {
  262.   return true;
  263. }
  266. /****************************** GLUI_Scrollbar::draw() **********/
  268. void    GLUI_Scrollbar::draw( int x, int y )
  269. {
  270.   GLUI_DRAWINGSENTINAL_IDIOM
  272.   if ( horizontal ) {
  273.     draw_scroll_arrow(GLUI_SCROLL_ARROW_LEFT,  0, 0);
  274.     draw_scroll_arrow(GLUI_SCROLL_ARROW_RIGHT, w-GLUI_SCROLL_ARROW_WIDTH, 0);
  275.   } else {
  276.     draw_scroll_arrow(GLUI_SCROLL_ARROW_UP,  0, 0);
  277.     draw_scroll_arrow(GLUI_SCROLL_ARROW_DOWN, 0, h-GLUI_SCROLL_ARROW_HEIGHT);
  278.   }
  279.   draw_scroll();
  280. }
  283. /****************************** GLUI_Scrollbar::draw_scroll_arrow() **********/
  285. void GLUI_Scrollbar::draw_scroll_arrow(int arrowtype, int x, int y)
  286. {
  287.   float offset=0;
  288.   float L=3.5f,HC=7.f,R=10.5f;
  289.   float T=4.5f,VC=8.f,B=11.5;
  290.   const float verts[][6]={
  291.     { L,10.5f,     R, 10.5f,      HC, 6.5f }, // up arrow
  292.     { L,6.5f,      R, 6.5f,       HC,10.5f }, // down arrow
  293.     { R-2,T,       R-2, B,        L+1,  VC   }, // left arrow
  294.     { L+2,T,       L+2, B,        R-1,  VC   }  // right arrow
  295.   };
  297.   const float *tri = NULL;
  299.   switch (arrowtype)
  300.   {
  301.     case GLUI_SCROLL_ARROW_UP:
  302.       tri = verts[0];
  303.       if (state & GLUI_SCROLL_STATE_UP) offset = 1;
  304.       break;
  306.     case GLUI_SCROLL_ARROW_DOWN:
  307.       tri = verts[1];
  308.       if (state & GLUI_SCROLL_STATE_DOWN) offset = 1;
  309.       break;
  311.     case GLUI_SCROLL_ARROW_LEFT:
  312.       tri = verts[2];
  313.       if (state & GLUI_SCROLL_STATE_DOWN) offset = 1;
  314.       break;
  316.     case GLUI_SCROLL_ARROW_RIGHT:
  317.       tri = verts[3];
  318.       if (state & GLUI_SCROLL_STATE_UP) offset = 1;
  319.       break;
  321.     default:
  322.       return; /* tri is NULL */
  323.   }
  325.   glColor3ubv(&glui->bkgd_color.r);
  326.   glRecti(x,y,x+GLUI_SCROLL_ARROW_WIDTH,y+GLUI_SCROLL_ARROW_HEIGHT);
  327.   if (!offset) {
  328.     glui->draw_raised_box(x,y+1,GLUI_SCROLL_ARROW_WIDTH-1,GLUI_SCROLL_ARROW_HEIGHT-1);
  329.   } else {
  330.     glColor3ub(128,128,128);
  331.     glBegin(GL_LINE_LOOP);
  332.     int x2=x+GLUI_SCROLL_ARROW_WIDTH, y2=y+GLUI_SCROLL_ARROW_HEIGHT;
  333.     glVertex2i(x ,y); 
  334.     glVertex2i(x2,y);
  335.     glVertex2i(x2,y2); 
  336.     glVertex2i(x ,y2);
  337.     glEnd();
  338.   }
  339.   
  340.   GLubyte black[]={0,0,0};
  341.   GLubyte white[]={255,255,255};
  342.   GLubyte  gray[]={128,128,128};
  343.   GLubyte *color=black;
  344.   if (!enabled) {
  345.     offset = 1;
  346.     color = white;
  347.   }
  348.   glTranslatef(x+offset,y+offset,0);
  349.   glColor3ubv(color);
  350.   glBegin(GL_TRIANGLES);
  351.   glVertex2fv(tri); glVertex2fv(tri+2), glVertex2fv(tri+4);
  352.   glEnd();
  353.   glTranslatef(-(x+offset),-(y+offset),0);
  354.   
  355.   if (!enabled) { // once more!
  356.     glTranslatef(x,y,0);
  357.     glColor3ubv(gray);
  358.     glBegin(GL_TRIANGLES);
  359.     glVertex2fv(tri); glVertex2fv(tri+2), glVertex2fv(tri+4);
  360.     glEnd();
  361.     glTranslatef(-x,-y,0);
  362.   }
  363. }
  366. void GLUI_Scrollbar::draw_scroll() {
  367.   update_scroll_parameters();
  369.   // Draw track using a checkerboard background
  370.   const unsigned char scroll_bg[] = {
  371.     0xD4, 0xD0, 0xC8, 0xFF, 0xFF, 0xFF,
  372.     0xFF, 0xFF, 0xFF, 0xD4, 0xD0, 0xC8
  373.   };
  374.   glColor3f( 1.0, 1.0, 1.0 );
  375.   glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
  376.   glEnable( GL_TEXTURE_2D);
  377.   glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
  378.   glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT );
  379.   glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT );
  380.   glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
  381.   glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
  382.   glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, 2, 2, 0, GL_RGB, GL_UNSIGNED_BYTE,
  383.      scroll_bg);
  384.   
  385.   float y0 = horizontal? 0 : GLUI_SCROLL_ARROW_HEIGHT;
  386.   float y1 = horizontal? h : h-GLUI_SCROLL_ARROW_HEIGHT;
  387.   float x0 = horizontal? GLUI_SCROLL_ARROW_WIDTH   : 0;
  388.   float x1 = horizontal? w-GLUI_SCROLL_ARROW_WIDTH : w;
  389.   x0-=0.5; y0+=0.5;
  390.   x1-=0.5; y1+=0.5;
  391.   float dy = y1-y0;
  392.   float dx = x1-x0;
  393.   glBegin(GL_QUADS);
  394.   glTexCoord2f(0,     0);        glVertex2f(x0,y0);
  395.   glTexCoord2f(dx*0.5f,0);       glVertex2f(x1,y0);
  396.   glTexCoord2f(dx*0.5f,dy*0.5f); glVertex2f(x1,y1);
  397.   glTexCoord2f(0,      dy*0.5f); glVertex2f(x0,y1);
  398.   glEnd();
  399.   glDisable(GL_TEXTURE_2D);
  401.   // Draw scroll box
  402.   int box = box_start_position;
  403.   if (horizontal) {
  404.     box += GLUI_SCROLL_ARROW_WIDTH;
  405.     draw_scroll_box(box,1,box_length,h);
  406.   } else {
  407.     box += GLUI_SCROLL_ARROW_HEIGHT+1;
  408.     draw_scroll_box(0,box,w,box_length);
  409.   }
  410. }
  412. /****************************** GLUI_Scrollbar::draw_scroll_box() **********/
  414. void GLUI_Scrollbar::draw_scroll_box(int x, int y, int w, int h)
  415. {
  416.   if (!enabled) return;
  417.   glColor3ubv(&glui->bkgd_color.r);
  418.   glRecti(x,y,x+w,y+h);
  419.   glui->draw_raised_box(x,y, w-1, h-1);
  420.   
  421.   if (active) {
  422.     glEnable( GL_LINE_STIPPLE );
  423.     glLineStipple( 1, 0x5555 );
  424.     glColor3f( 0., 0., 0. );
  425.     glBegin(GL_LINE_LOOP);
  426.     int x1 = x+2, y1 = y+2, x2 = x+w-4, y2 = y+h-4;
  427.     glVertex2i(x1,y1);
  428.     glVertex2i(x2,y1);
  429.     glVertex2i(x2,y2);
  430.     glVertex2i(x1,y2);
  431.     glEnd();
  432.     glDisable( GL_LINE_STIPPLE );
  433.   }
  434. }
  438. /**************************** update_scroll_parameters ***********/
  440. void GLUI_Scrollbar::update_scroll_parameters() {
  441.   track_length = horizontal? 
  442.     this->w-GLUI_SCROLL_ARROW_WIDTH*2 :
  443.     this->h-GLUI_SCROLL_ARROW_HEIGHT*2;
  444.   if (data_type==GLUI_SCROLL_INT) 
  445.   {
  446.     if (int_max==int_min) 
  447.       box_length=track_length;
  448.     else {
  449.       const int MIN_TAB = GLUI_SCROLL_BOX_STD_HEIGHT;
  450.       //box_length = int(track_length/float(visible_range));
  451.       //if (box_length < MIN_TAB)
  452.         box_length = MIN_TAB;
  453.     }
  454.     float pixels_per_unit = (track_length-box_length)/float(int_max-int_min);
  455.     if (horizontal)
  456.       box_start_position = int((int_val-int_min)*pixels_per_unit);
  457.     else 
  458.       box_start_position = int((int_max-int_val)*pixels_per_unit);
  459.     box_end_position = box_start_position+box_length;
  460.   }
  461.   else if (data_type==GLUI_SCROLL_FLOAT) 
  462.   {
  463.     if (float_max==float_min) 
  464.       box_length=track_length;
  465.     else {
  466.       box_length = GLUI_SCROLL_BOX_STD_HEIGHT;
  467.     }
  468.     float pixels_per_unit = (track_length-box_length)/float(float_max-float_min);
  469.     if (horizontal)
  470.       box_start_position = int((float_val-float_min)*pixels_per_unit);
  471.     else 
  472.       box_start_position = int((float_max-float_val)*pixels_per_unit);
  473.     box_end_position = box_start_position+box_length;
  474.   }
  475. }
  478. /********************************* GLUI_Scrollbar::special_handler() **********/
  480. int    GLUI_Scrollbar::special_handler( int key,int modifiers )
  481. {
  482.   if ( !horizontal && key == GLUT_KEY_UP ) {
  483.     mouse_down_handler( x_abs + w - GLUI_SCROLL_ARROW_WIDTH + 1,
  484.       y_abs + 1 );
  485.     mouse_up_handler( x_abs + w - GLUI_SCROLL_ARROW_WIDTH + 1,
  486.       y_abs + 1, true );
  487.   }
  488.   else if ( !horizontal && key == GLUT_KEY_DOWN ) {
  489.     mouse_down_handler(x_abs + w - GLUI_SCROLL_ARROW_WIDTH + 1,
  490.       y_abs+1+GLUI_SCROLL_ARROW_HEIGHT);
  491.     mouse_up_handler( x_abs + w - GLUI_SCROLL_ARROW_WIDTH + 1,
  492.       y_abs+1 +GLUI_SCROLL_ARROW_HEIGHT,
  493.       true );
  494.   }
  495.   if ( horizontal && key == GLUT_KEY_LEFT ) {
  496.     mouse_down_handler( x_abs + 1,y_abs + 1 );
  497.     mouse_up_handler( x_abs + 1,   y_abs + 1, true );
  498.   }
  499.   else if ( horizontal && key == GLUT_KEY_RIGHT ) {
  500.     mouse_down_handler(x_abs + w - GLUI_SCROLL_ARROW_WIDTH + 1,
  501.       y_abs+1);
  502.     mouse_up_handler( x_abs + w - GLUI_SCROLL_ARROW_WIDTH + 1,
  503.       y_abs+1,
  504.       true );
  505.   }
  506.   else if ( key == GLUT_KEY_HOME ) {  /** Set value to limit top - 
  507.                                           or increment by 10 **/
  508.   }
  509.   else if ( key == GLUT_KEY_END ) {  
  510.   }
  512.   return true;
  513. }
  516. /************************************ GLUI_Scrollbar::update_size() **********/
  518. void   GLUI_Scrollbar::update_size( void )
  519. {
  520.   if (horizontal) {
  521.     h = GLUI_SCROLL_ARROW_HEIGHT;
  522.     if (associated_object) {
  523.       this->w = ((GLUI_Control *)associated_object)->w;
  524.     }
  525.   }
  526.   else {
  527.     w = GLUI_SCROLL_ARROW_WIDTH;
  528.     if (associated_object) {
  529.       this->h = ((GLUI_Control *)associated_object)->h;
  530.     }
  531.   }
  532. }
  533.  
  535. /************************************ GLUI_Scrollbar::find_arrow() ************/
  537. int    GLUI_Scrollbar::find_arrow( int local_x, int local_y )
  538. {
  540.   local_x = local_x-x_abs; 
  541.   local_y = local_y-y_abs;
  543.   if (horizontal) 
  544.   {
  545.     if ( local_y >=  h-GLUI_SCROLL_ARROW_HEIGHT-3 && local_y <= h) 
  546.     {
  547.       update_scroll_parameters();
  548.       if ( local_x >= 0 AND local_x <= (GLUI_SCROLL_ARROW_WIDTH+box_start_position) )
  549.       {
  550.         return GLUI_SCROLL_STATE_DOWN;
  551.       }
  552.       if ( local_x >= (GLUI_SCROLL_ARROW_WIDTH+box_end_position)
  553.            AND local_x <= (w+GLUI_SCROLL_ARROW_WIDTH) ) 
  554.       {
  555.         return GLUI_SCROLL_STATE_UP;
  556.       }
  557.       return GLUI_SCROLL_STATE_SCROLL;
  558.     }
  559.   }
  560.   else 
  561.   {
  562.     if ( local_x >=  w-GLUI_SCROLL_ARROW_WIDTH-3 && local_x <= w) 
  563.     {
  564.       update_scroll_parameters();
  565.       if ( local_y >= 0 AND local_y <= (GLUI_SCROLL_ARROW_HEIGHT+box_start_position) )
  566.       {
  567.         return GLUI_SCROLL_STATE_UP;
  568.       }
  569.       if ( local_y >= (GLUI_SCROLL_ARROW_HEIGHT+box_end_position)
  570.            AND local_y <= (h+GLUI_SCROLL_ARROW_HEIGHT) )
  571.       {
  572.         return GLUI_SCROLL_STATE_DOWN;
  573.       }
  574.       return GLUI_SCROLL_STATE_SCROLL;
  575.     }
  576.   }
  578.   return GLUI_SCROLL_STATE_NONE;
  579. }
  581. /***************************************** GLUI_Scrollbar::do_click() **********/
  583. void    GLUI_Scrollbar::do_click( void )
  584. {
  585.   int    direction = 0;
  587.   if ( state == GLUI_SCROLL_STATE_UP )
  588.     direction = +1;
  589.   else if ( state == GLUI_SCROLL_STATE_DOWN )
  590.     direction = -1;
  592.   if (data_type==GLUI_SCROLL_INT&&int_min>int_max) direction*=-1;
  593.   if (data_type==GLUI_SCROLL_FLOAT&&float_min>float_max) direction*=-1;
  595.   increase_growth();
  597.   float modifier_factor = 1.0;
  598.   float incr = growth * modifier_factor * user_speed ;
  599.   
  600.   double frame_time=GLUI_Time()-last_update_time;
  601.   double frame_limit=velocity_limit*frame_time;
  602.   if (incr>frame_limit) incr=frame_limit; /* don't scroll faster than limit */
  603.   last_update_time=GLUI_Time();
  605.   float new_val = float_val;
  607.   new_val += direction * incr;
  608.   if (1 || data_type==GLUI_SCROLL_FLOAT) set_float_val(new_val);
  609.   if (0 && data_type==GLUI_SCROLL_INT) set_int_val((int)new_val);
  610.   //printf("do_click: incr %f  val=%f  float_val=%fn",incr,new_val,float_val);
  612.   /*** Now update live variable and do callback.  We don't want
  613.     to do the callback on each iteration of this function, just on every 
  614.     i^th iteration, where i is given by GLUI_SCROLL_CALLBACK_INTERVAL ****/
  615.   callback_count++;
  616.   if ( (callback_count % GLUI_SCROLL_CALLBACK_INTERVAL ) == 0 )
  617.     do_callbacks();
  619. }
  622. /***************************************** GLUI_Scrollbar::do_drag() **********/
  624. void    GLUI_Scrollbar::do_drag( int x, int y )
  625. {
  626.   int   direction = 0;
  627.   float incr, modifier_factor;
  628.   /* int delta_x;              */
  629.   int new_int_val = int_val;
  630.   float new_float_val = float_val;
  632.   int free_len = track_length-box_length;
  633.   if (free_len == 0) return;
  635.   modifier_factor = 1.0;
  636.   if ( state == GLUI_SCROLL_STATE_SCROLL) {
  637.     update_scroll_parameters();
  639.     int hbox = box_length/2;
  640.     if (horizontal) {
  641.       int track_v = x-GLUI_SCROLL_ARROW_WIDTH;
  642.       new_int_val = int_min + (track_v-hbox)*(int_max-int_min)/free_len;
  643.       new_float_val = float_min + (track_v-hbox)*(float_max-float_min)/float(free_len); 
  644.     } else {
  645.       int track_v = y-GLUI_SCROLL_ARROW_HEIGHT;
  646.       new_int_val = int_max - (track_v-hbox)*(int_max-int_min)/free_len;
  647.       new_float_val = float_max - (track_v-hbox)*(float_max-float_min)/float(free_len); 
  648.     }
  649.   }
  650.   else {
  651.     if ( state == GLUI_SCROLL_STATE_UP )
  652.       direction = +1;
  653.     else if ( state == GLUI_SCROLL_STATE_DOWN )
  654.       direction = -1;
  655.     incr = growth * direction * modifier_factor * user_speed;
  656.     new_int_val += direction;
  657.     new_float_val += direction * (float_max-float_min)/free_len;
  658.   }
  659.   last_y = y;
  660.   last_x = x;
  662.   /*** Now update live variable and do callback.  We don't want
  663.     to do the callback on each iteration of this function, just on every 
  664.     i^th iteration, where i is given by GLUI_SCROLL_CALLBACK_INTERVAL ****/
  665.   if(data_type==GLUI_SCROLL_INT)
  666.     set_int_val(new_int_val);
  667.   else if (data_type==GLUI_SCROLL_FLOAT)
  668.     set_float_val(new_float_val);
  670.   callback_count++;
  671.   if ( (callback_count % GLUI_SCROLL_CALLBACK_INTERVAL ) == 0 )
  672.     do_callbacks();
  673. }
  676. /***************************************** GLUI_Scrollbar::needs_idle() ******/
  678. bool GLUI_Scrollbar::needs_idle( void ) const
  679. {
  680.   if  (state == GLUI_SCROLL_STATE_UP OR state == GLUI_SCROLL_STATE_DOWN ) {
  681.     return true;
  682.   }
  683.   else {
  684.     return false;
  685.   }
  686. }
  688. /***************************************** GLUI_Scrollbar::idle() **********/
  690. void    GLUI_Scrollbar::idle( void )
  691. {
  692.   if ( NOT needs_idle() )
  693.     return;
  694.   else
  695.     do_click();
  696. }
  699. /************************************ GLUI_Scrollbar::do_callbacks() **********/
  701. void    GLUI_Scrollbar::do_callbacks( void )
  702. {
  704.   /*    *******************************************/
  706.   if ( NOT first_callback ) {
  707.     if ( data_type == GLUI_SCROLL_INT AND int_val == last_int_val ) {
  708.       return;
  709.     }
  710.     if ( data_type == GLUI_SPINNER_FLOAT AND float_val == last_float_val ) {
  711.       return;
  712.     }
  713.   }
  715.   if (associated_object == NULL) {
  716.     this->execute_callback();
  717.   }
  718.   else  {                      // Use internal Callbacks
  719.     if (object_cb) {
  720.       //object_cb(associated_object, int_val);
  721.       object_cb(this);
  722.     }
  723.   }
  724.   last_int_val   = int_val;
  725.   last_float_val = float_val;
  726.   first_callback = false;
  727. }
  730. /********************************** GLUI_Scrollbar::set_float_val() ************/
  732. void   GLUI_Scrollbar::set_float_val( float new_val )
  733. {
  734.   // Allow for the possibility that the limits are reversed
  735.   float hi = MAX(float_min,float_max);
  736.   float lo = MIN(float_min,float_max);
  737.   if (new_val > hi)
  738.     new_val = hi;
  739.   if (new_val < lo)
  740.     new_val = lo;
  741.   last_float_val = float_val;
  742.   float_val = new_val;
  743.   int_val = (int)new_val;
  745.   redraw();
  747.   /*** Now update the live variable ***/
  748.   output_live(true);
  749. }
  752. /********************************** GLUI_Scrollbar::set_int_val() ************/
  754. void   GLUI_Scrollbar::set_int_val( int new_val )
  755. {
  756.   // Allow for the possibility that the limits are reversed
  757.   int hi = MAX(int_min,int_max);
  758.   int lo = MIN(int_min,int_max);
  759.   if (new_val > hi)
  760.     new_val = hi;
  761.   if (new_val < lo)
  762.     new_val = lo;
  763.   last_int_val = int_val;
  764.   float_val = int_val = new_val;
  766.   redraw();
  768.   /*** Now update the live variable ***/
  769.   output_live(true);
  770. }
  772. /*********************************** GLUI_Scrollbar::set_float_limits() *********/
  774. void   GLUI_Scrollbar::set_float_limits( float low, float high, int limit_type )
  775. {
  776.   if (limit_type != GLUI_LIMIT_CLAMP) {
  777.     // error!
  778.   }
  779.   float_min = low;
  780.   float_max = high;
  781.   // Allow for possiblitly of reversed limits
  782.   float lo = MIN(low,high);
  783.   float hi = MAX(low,high);
  784.   if (float_val<lo) set_float_val(lo);
  785.   if (float_val>hi) set_float_val(hi);
  786. }
  787.  
  789. /*********************************** GLUI_Scrollbar::set_int_limits() *********/
  791. void   GLUI_Scrollbar::set_int_limits( int low, int high, int limit_type )
  792. {
  793.   if (limit_type != GLUI_LIMIT_CLAMP) {
  794.     // error!
  795.   }
  796.   int_min = low;
  797.   int_max = high;    
  798.   // Allow for possiblitly of reversed limits
  799.   int lo = MIN(low,high);
  800.   int hi = MAX(low,high);
  801.   if (int_val<lo) set_int_val(lo);
  802.   if (int_val>hi) set_int_val(hi);
  803.   float_min = low;
  804.   float_max = high;
  805. }
  806.  
  808. /*********************************** GLUI_Scrollbar::reset_growth() *************/
  810. void    GLUI_Scrollbar::reset_growth( void )
  811. {
  812.   growth = fabs(float_max - float_min) / float(GLUI_SCROLL_GROWTH_STEPS);
  813.   if (data_type == GLUI_SCROLL_INT && growth<1) growth=1;
  814. }
  817. /******************************* GLUI_Scrollbar::increase_growth() *************/
  819. void    GLUI_Scrollbar::increase_growth( void )
  820. {
  821.   float range=0;
  822.   if (data_type==GLUI_SCROLL_FLOAT)
  823.     range = fabs(float_max-float_min);
  824.   else 
  825.     range = fabs(float(int_max-int_min));
  826.   if ( growth < (range / float(GLUI_SCROLL_MIN_GROWTH_STEPS)) )
  827.     growth *= growth_exp;
  828.   return;
  829. }