diff options
Diffstat (limited to 'tests/bullet/Extras/glui/glui_scrollbar.cpp')
| -rw-r--r-- | tests/bullet/Extras/glui/glui_scrollbar.cpp | 832 |
1 files changed, 832 insertions, 0 deletions
diff --git a/tests/bullet/Extras/glui/glui_scrollbar.cpp b/tests/bullet/Extras/glui/glui_scrollbar.cpp new file mode 100644 index 00000000..f0fb1370 --- /dev/null +++ b/tests/bullet/Extras/glui/glui_scrollbar.cpp @@ -0,0 +1,832 @@ +/**************************************************************************** + + GLUI User Interface Toolkit + --------------------------- + + glui_scrollbar.cpp - GLUI_Scrollbar class + + -------------------------------------------------- + + Copyright (c) 2004 John Kew, 1998 Paul Rademacher + + This program is freely distributable without licensing fees and is + provided without guarantee or warrantee expressed or implied. This + program is -not- in the public domain. + +*****************************************************************************/ + +#include "glui_internal_control.h" +#include <cmath> +#include <cassert> + +/*static int __debug=0; */ + +#define GLUI_SCROLL_GROWTH_STEPS 800 +#define GLUI_SCROLL_MIN_GROWTH_STEPS 100 +#define GLUI_SCROLL_CALLBACK_INTERVAL 1 /* Execute the user's callback every this many clicks */ + +enum { + GLUI_SCROLL_ARROW_UP, + GLUI_SCROLL_ARROW_DOWN, + GLUI_SCROLL_ARROW_LEFT, + GLUI_SCROLL_ARROW_RIGHT +}; + + +/****************************** GLUI_Scrollbar::GLUI_Scrollbar() **********/ +// Constructor, no live var +GLUI_Scrollbar::GLUI_Scrollbar( GLUI_Node *parent, + const char *name, + int horz_vert, + int data_type, + int id, GLUI_CB callback + /*,GLUI_Control *object + ,GLUI_InterObject_CB obj_cb*/ + ) +{ + common_construct(parent, name, horz_vert, data_type, NULL, id, callback/*, object, obj_cb*/); +} + +/****************************** GLUI_Scrollbar::GLUI_Scrollbar() **********/ +// Constructor, int live var +GLUI_Scrollbar::GLUI_Scrollbar( GLUI_Node *parent, const char *name, + int horz_vert, + int *live_var, + int id, GLUI_CB callback + /*,GLUI_Control *object + ,GLUI_InterObject_CB obj_cb*/ + ) +{ + common_construct(parent, name, horz_vert, GLUI_SCROLL_INT, live_var, id, callback/*, object, obj_cb*/); +} + +/****************************** GLUI_Scrollbar::GLUI_Scrollbar() **********/ +// Constructor, float live var +GLUI_Scrollbar::GLUI_Scrollbar( GLUI_Node *parent, const char *name, + int horz_vert, + float *live_var, + int id, GLUI_CB callback + /*,GLUI_Control *object + ,GLUI_InterObject_CB obj_cb*/ + ) +{ + common_construct(parent, name, horz_vert, GLUI_SCROLL_FLOAT, live_var, id, callback/*, object, obj_cb*/); +} + +/****************************** GLUI_Scrollbar::common_init() **********/ +void GLUI_Scrollbar::common_init(void) +{ + horizontal = true; + h = GLUI_SCROLL_ARROW_HEIGHT; + w = GLUI_TEXTBOX_WIDTH; + alignment = GLUI_ALIGN_CENTER; + x_off = 0; + y_off_top = 0; + y_off_bot = 0; + can_activate = true; + state = GLUI_SCROLL_STATE_NONE; + growth_exp = GLUI_SCROLL_DEFAULT_GROWTH_EXP; + callback_count = 0; + first_callback = true; + user_speed = 1.0; + float_min = 0.0; + float_max = 0.0; + int_min = 0; + int_max = 0; + associated_object = NULL; + last_update_time=0; + velocity_limit=50.0; /* Change value by at most 50 per second */ + box_length = 0; + box_start_position = 0; + box_end_position = 0; + track_length = 0; +} + +/****************************** GLUI_Scrollbar::common_construct() **********/ +void GLUI_Scrollbar::common_construct( + GLUI_Node *parent, + const char *name, + int horz_vert, + int data_type, + void *data, + int id, GLUI_CB callback + /*,GLUI_Control *object, + GLUI_InterObject_CB obj_cb*/ + ) +{ + common_init(); + + // make sure limits are wide enough to hold live value + if (data_type==GLUI_SCROLL_FLOAT) { + float lo = 0.0f, hi=1.0f; + if (data) { + float d = *(float*)(data); + lo = MIN(lo, d); + hi = MAX(hi, d); + } + this->set_float_limits(lo,hi); + this->set_float_val(lo); + this->live_type = GLUI_LIVE_FLOAT; + } else { + int lo = 0, hi=100; + if (data) { + int d = *(int*)(data); + lo = MIN(lo, d); + hi = MAX(hi, d); + } + this->set_int_limits(lo,hi); + this->set_int_val(0); + this->live_type = GLUI_LIVE_INT; + } + this->data_type = data_type; + this->set_ptr_val( data ); + this->set_name(name); + this->user_id = id; + this->callback = callback; + //this->associated_object = object; + //this->object_cb = obj_cb; + this->horizontal=(horz_vert==GLUI_SCROLL_HORIZONTAL); + if (this->horizontal) { + this->h = GLUI_SCROLL_ARROW_HEIGHT; + this->w = GLUI_TEXTBOX_WIDTH; + } else { + this->h = GLUI_TEXTBOX_HEIGHT; + this->w = GLUI_SCROLL_ARROW_WIDTH; + } + parent->add_control( this ); + this->init_live(); +} + +/****************************** GLUI_Scrollbar::mouse_down_handler() **********/ + +int GLUI_Scrollbar::mouse_down_handler( int local_x, int local_y ) +{ + last_update_time=GLUI_Time()-1.0; + this->state = find_arrow( local_x, local_y ); + GLUI_Master.glui_setIdleFuncIfNecessary(); + + /* printf( "spinner: mouse down : %d/%d arrow:%d\n", local_x, local_y, + find_arrow( local_x, local_y )); + */ + + if ( state != GLUI_SCROLL_STATE_UP AND state != GLUI_SCROLL_STATE_DOWN) + return true; + + reset_growth(); + + /*** ints and floats behave a bit differently. When you click on + an int spinner, you expect the value to immediately go up by 1, whereas + for a float it'll go up only by a fractional amount. Therefore, we + go ahead and increment by one for int spinners ***/ +#if 1 + if ( data_type == GLUI_SCROLL_INT ) { + // Allow for possibility of reversed limits + int lo = MIN(int_min,int_max); + int hi = MAX(int_min,int_max); + int increase = int_min < int_max ? 1 : -1; + int new_val = int_val; + if ( state == GLUI_SCROLL_STATE_UP ) { + new_val += increase; + } else if ( state == GLUI_SCROLL_STATE_DOWN ) { + new_val -= increase; + } + if (new_val >= lo && new_val <= hi && new_val!=int_val) { + set_int_val(new_val); + do_callbacks(); + } + } +#endif + do_click(); + redraw(); + + return false; +} + + +/******************************** GLUI_Scrollbar::mouse_up_handler() **********/ + +int GLUI_Scrollbar::mouse_up_handler( int local_x, int local_y, bool inside ) +{ + state = GLUI_SCROLL_STATE_NONE; + GLUI_Master.glui_setIdleFuncIfNecessary(); + + /* printf("spinner: mouse up : %d/%d inside: %d\n",local_x,local_y,inside); */ + + /*glutSetCursor( GLUT_CURSOR_INHERIT ); */ + glutSetCursor( GLUT_CURSOR_LEFT_ARROW ); + + redraw(); + + /* do_callbacks(); --- stub */ + /* if ( callback ) */ + /* callback( this->user_id ); */ + + return false; +} + + +/***************************** GLUI_Scrollbar::mouse_held_down_handler() ******/ + +int GLUI_Scrollbar::mouse_held_down_handler( int local_x, int local_y, + bool new_inside) +{ + int new_state; + if ( state == GLUI_SCROLL_STATE_NONE ) + return false; + + /* printf("spinner: mouse held: %d/%d inside: %d\n",local_x,local_y, + new_inside); + */ + + if ( state == GLUI_SCROLL_STATE_SCROLL) { /* dragging? */ + do_drag( local_x-x_abs, local_y-y_abs ); + } + else { /* not dragging */ + new_state = find_arrow( local_x, local_y ); + + if ( new_state == state ) { + /** Still in same arrow **/ + do_click(); + } + } + redraw(); + + return false; +} + + +/****************************** GLUI_Scrollbar::key_handler() **********/ + +int GLUI_Scrollbar::key_handler( unsigned char key,int modifiers ) +{ + return true; +} + + +/****************************** GLUI_Scrollbar::draw() **********/ + +void GLUI_Scrollbar::draw( int x, int y ) +{ + GLUI_DRAWINGSENTINAL_IDIOM + + if ( horizontal ) { + draw_scroll_arrow(GLUI_SCROLL_ARROW_LEFT, 0, 0); + draw_scroll_arrow(GLUI_SCROLL_ARROW_RIGHT, w-GLUI_SCROLL_ARROW_WIDTH, 0); + } else { + draw_scroll_arrow(GLUI_SCROLL_ARROW_UP, 0, 0); + draw_scroll_arrow(GLUI_SCROLL_ARROW_DOWN, 0, h-GLUI_SCROLL_ARROW_HEIGHT); + } + draw_scroll(); +} + + +/****************************** GLUI_Scrollbar::draw_scroll_arrow() **********/ + +void GLUI_Scrollbar::draw_scroll_arrow(int arrowtype, int x, int y) +{ + float offset=0; + float L=3.5f,HC=7.f,R=10.5f; + float T=4.5f,VC=8.f,B=11.5; + const float verts[][6]={ + { L,10.5f, R, 10.5f, HC, 6.5f }, // up arrow + { L,6.5f, R, 6.5f, HC,10.5f }, // down arrow + { R-2,T, R-2, B, L+1, VC }, // left arrow + { L+2,T, L+2, B, R-1, VC } // right arrow + }; + + const float *tri = NULL; + + switch (arrowtype) + { + case GLUI_SCROLL_ARROW_UP: + tri = verts[0]; + if (state & GLUI_SCROLL_STATE_UP) offset = 1; + break; + + case GLUI_SCROLL_ARROW_DOWN: + tri = verts[1]; + if (state & GLUI_SCROLL_STATE_DOWN) offset = 1; + break; + + case GLUI_SCROLL_ARROW_LEFT: + tri = verts[2]; + if (state & GLUI_SCROLL_STATE_DOWN) offset = 1; + break; + + case GLUI_SCROLL_ARROW_RIGHT: + tri = verts[3]; + if (state & GLUI_SCROLL_STATE_UP) offset = 1; + break; + + default: + return; /* tri is NULL */ + } + + glColor3ubv(&glui->bkgd_color.r); + glRecti(x,y,x+GLUI_SCROLL_ARROW_WIDTH,y+GLUI_SCROLL_ARROW_HEIGHT); + if (!offset) { + glui->draw_raised_box(x,y+1,GLUI_SCROLL_ARROW_WIDTH-1,GLUI_SCROLL_ARROW_HEIGHT-1); + } else { + glColor3ub(128,128,128); + glBegin(GL_LINE_LOOP); + int x2=x+GLUI_SCROLL_ARROW_WIDTH, y2=y+GLUI_SCROLL_ARROW_HEIGHT; + glVertex2i(x ,y); + glVertex2i(x2,y); + glVertex2i(x2,y2); + glVertex2i(x ,y2); + glEnd(); + } + + GLubyte black[]={0,0,0}; + GLubyte white[]={255,255,255}; + GLubyte gray[]={128,128,128}; + GLubyte *color=black; + if (!enabled) { + offset = 1; + color = white; + } + glTranslatef(x+offset,y+offset,0); + glColor3ubv(color); + glBegin(GL_TRIANGLES); + glVertex2fv(tri); glVertex2fv(tri+2), glVertex2fv(tri+4); + glEnd(); + glTranslatef(-(x+offset),-(y+offset),0); + + if (!enabled) { // once more! + glTranslatef(x,y,0); + glColor3ubv(gray); + glBegin(GL_TRIANGLES); + glVertex2fv(tri); glVertex2fv(tri+2), glVertex2fv(tri+4); + glEnd(); + glTranslatef(-x,-y,0); + } +} + + +void GLUI_Scrollbar::draw_scroll() { + update_scroll_parameters(); + + // Draw track using a checkerboard background + const unsigned char scroll_bg[] = { + 0xD4, 0xD0, 0xC8, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xD4, 0xD0, 0xC8 + }; + glColor3f( 1.0, 1.0, 1.0 ); + glPixelStorei( GL_UNPACK_ALIGNMENT, 1 ); + glEnable( GL_TEXTURE_2D); + glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE ); + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT ); + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT ); + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST ); + glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST ); + glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, 2, 2, 0, GL_RGB, GL_UNSIGNED_BYTE, + scroll_bg); + + float y0 = horizontal? 0 : GLUI_SCROLL_ARROW_HEIGHT; + float y1 = horizontal? h : h-GLUI_SCROLL_ARROW_HEIGHT; + float x0 = horizontal? GLUI_SCROLL_ARROW_WIDTH : 0; + float x1 = horizontal? w-GLUI_SCROLL_ARROW_WIDTH : w; + x0-=0.5; y0+=0.5; + x1-=0.5; y1+=0.5; + float dy = y1-y0; + float dx = x1-x0; + glBegin(GL_QUADS); + glTexCoord2f(0, 0); glVertex2f(x0,y0); + glTexCoord2f(dx*0.5f,0); glVertex2f(x1,y0); + glTexCoord2f(dx*0.5f,dy*0.5f); glVertex2f(x1,y1); + glTexCoord2f(0, dy*0.5f); glVertex2f(x0,y1); + glEnd(); + glDisable(GL_TEXTURE_2D); + + // Draw scroll box + int box = box_start_position; + if (horizontal) { + box += GLUI_SCROLL_ARROW_WIDTH; + draw_scroll_box(box,1,box_length,h); + } else { + box += GLUI_SCROLL_ARROW_HEIGHT+1; + draw_scroll_box(0,box,w,box_length); + } +} + +/****************************** GLUI_Scrollbar::draw_scroll_box() **********/ + +void GLUI_Scrollbar::draw_scroll_box(int x, int y, int w, int h) +{ + if (!enabled) return; + glColor3ubv(&glui->bkgd_color.r); + glRecti(x,y,x+w,y+h); + glui->draw_raised_box(x,y, w-1, h-1); + + if (active) { + glEnable( GL_LINE_STIPPLE ); + glLineStipple( 1, 0x5555 ); + glColor3f( 0., 0., 0. ); + glBegin(GL_LINE_LOOP); + int x1 = x+2, y1 = y+2, x2 = x+w-4, y2 = y+h-4; + glVertex2i(x1,y1); + glVertex2i(x2,y1); + glVertex2i(x2,y2); + glVertex2i(x1,y2); + glEnd(); + glDisable( GL_LINE_STIPPLE ); + } +} + + + +/**************************** update_scroll_parameters ***********/ + +void GLUI_Scrollbar::update_scroll_parameters() { + track_length = horizontal? + this->w-GLUI_SCROLL_ARROW_WIDTH*2 : + this->h-GLUI_SCROLL_ARROW_HEIGHT*2; + if (data_type==GLUI_SCROLL_INT) + { + if (int_max==int_min) + box_length=track_length; + else { + const int MIN_TAB = GLUI_SCROLL_BOX_STD_HEIGHT; + //box_length = int(track_length/float(visible_range)); + //if (box_length < MIN_TAB) + box_length = MIN_TAB; + } + float pixels_per_unit = (track_length-box_length)/float(int_max-int_min); + if (horizontal) + box_start_position = int((int_val-int_min)*pixels_per_unit); + else + box_start_position = int((int_max-int_val)*pixels_per_unit); + box_end_position = box_start_position+box_length; + } + else if (data_type==GLUI_SCROLL_FLOAT) + { + if (float_max==float_min) + box_length=track_length; + else { + box_length = GLUI_SCROLL_BOX_STD_HEIGHT; + } + float pixels_per_unit = (track_length-box_length)/float(float_max-float_min); + if (horizontal) + box_start_position = int((float_val-float_min)*pixels_per_unit); + else + box_start_position = int((float_max-float_val)*pixels_per_unit); + box_end_position = box_start_position+box_length; + } +} + + +/********************************* GLUI_Scrollbar::special_handler() **********/ + +int GLUI_Scrollbar::special_handler( int key,int modifiers ) +{ + if ( !horizontal && key == GLUT_KEY_UP ) { + mouse_down_handler( x_abs + w - GLUI_SCROLL_ARROW_WIDTH + 1, + y_abs + 1 ); + mouse_up_handler( x_abs + w - GLUI_SCROLL_ARROW_WIDTH + 1, + y_abs + 1, true ); + } + else if ( !horizontal && key == GLUT_KEY_DOWN ) { + mouse_down_handler(x_abs + w - GLUI_SCROLL_ARROW_WIDTH + 1, + y_abs+1+GLUI_SCROLL_ARROW_HEIGHT); + mouse_up_handler( x_abs + w - GLUI_SCROLL_ARROW_WIDTH + 1, + y_abs+1 +GLUI_SCROLL_ARROW_HEIGHT, + true ); + } + if ( horizontal && key == GLUT_KEY_LEFT ) { + mouse_down_handler( x_abs + 1,y_abs + 1 ); + mouse_up_handler( x_abs + 1, y_abs + 1, true ); + } + else if ( horizontal && key == GLUT_KEY_RIGHT ) { + mouse_down_handler(x_abs + w - GLUI_SCROLL_ARROW_WIDTH + 1, + y_abs+1); + mouse_up_handler( x_abs + w - GLUI_SCROLL_ARROW_WIDTH + 1, + y_abs+1, + true ); + } + else if ( key == GLUT_KEY_HOME ) { /** Set value to limit top - + or increment by 10 **/ + } + else if ( key == GLUT_KEY_END ) { + } + + return true; +} + + +/************************************ GLUI_Scrollbar::update_size() **********/ + +void GLUI_Scrollbar::update_size( void ) +{ + if (horizontal) { + h = GLUI_SCROLL_ARROW_HEIGHT; + if (associated_object) { + this->w = ((GLUI_Control *)associated_object)->w; + } + } + else { + w = GLUI_SCROLL_ARROW_WIDTH; + if (associated_object) { + this->h = ((GLUI_Control *)associated_object)->h; + } + } +} + + +/************************************ GLUI_Scrollbar::find_arrow() ************/ + +int GLUI_Scrollbar::find_arrow( int local_x, int local_y ) +{ + + local_x = local_x-x_abs; + local_y = local_y-y_abs; + + if (horizontal) + { + if ( local_y >= h-GLUI_SCROLL_ARROW_HEIGHT-3 && local_y <= h) + { + update_scroll_parameters(); + if ( local_x >= 0 AND local_x <= (GLUI_SCROLL_ARROW_WIDTH+box_start_position) ) + { + return GLUI_SCROLL_STATE_DOWN; + } + if ( local_x >= (GLUI_SCROLL_ARROW_WIDTH+box_end_position) + AND local_x <= (w+GLUI_SCROLL_ARROW_WIDTH) ) + { + return GLUI_SCROLL_STATE_UP; + } + return GLUI_SCROLL_STATE_SCROLL; + } + } + else + { + if ( local_x >= w-GLUI_SCROLL_ARROW_WIDTH-3 && local_x <= w) + { + update_scroll_parameters(); + if ( local_y >= 0 AND local_y <= (GLUI_SCROLL_ARROW_HEIGHT+box_start_position) ) + { + return GLUI_SCROLL_STATE_UP; + } + if ( local_y >= (GLUI_SCROLL_ARROW_HEIGHT+box_end_position) + AND local_y <= (h+GLUI_SCROLL_ARROW_HEIGHT) ) + { + return GLUI_SCROLL_STATE_DOWN; + } + return GLUI_SCROLL_STATE_SCROLL; + } + } + + return GLUI_SCROLL_STATE_NONE; +} + +/***************************************** GLUI_Scrollbar::do_click() **********/ + +void GLUI_Scrollbar::do_click( void ) +{ + int direction = 0; + + if ( state == GLUI_SCROLL_STATE_UP ) + direction = +1; + else if ( state == GLUI_SCROLL_STATE_DOWN ) + direction = -1; + + if (data_type==GLUI_SCROLL_INT&&int_min>int_max) direction*=-1; + if (data_type==GLUI_SCROLL_FLOAT&&float_min>float_max) direction*=-1; + + increase_growth(); + + float modifier_factor = 1.0; + float incr = growth * modifier_factor * user_speed ; + + double frame_time=GLUI_Time()-last_update_time; + double frame_limit=velocity_limit*frame_time; + if (incr>frame_limit) incr=frame_limit; /* don't scroll faster than limit */ + last_update_time=GLUI_Time(); + + float new_val = float_val; + + new_val += direction * incr; + if (1 || data_type==GLUI_SCROLL_FLOAT) set_float_val(new_val); + if (0 && data_type==GLUI_SCROLL_INT) set_int_val((int)new_val); + //printf("do_click: incr %f val=%f float_val=%f\n",incr,new_val,float_val); + + /*** Now update live variable and do callback. We don't want + to do the callback on each iteration of this function, just on every + i^th iteration, where i is given by GLUI_SCROLL_CALLBACK_INTERVAL ****/ + callback_count++; + if ( (callback_count % GLUI_SCROLL_CALLBACK_INTERVAL ) == 0 ) + do_callbacks(); + +} + + +/***************************************** GLUI_Scrollbar::do_drag() **********/ + +void GLUI_Scrollbar::do_drag( int x, int y ) +{ + int direction = 0; + float incr, modifier_factor; + /* int delta_x; */ + int new_int_val = int_val; + float new_float_val = float_val; + + int free_len = track_length-box_length; + if (free_len == 0) return; + + modifier_factor = 1.0; + if ( state == GLUI_SCROLL_STATE_SCROLL) { + update_scroll_parameters(); + + int hbox = box_length/2; + if (horizontal) { + int track_v = x-GLUI_SCROLL_ARROW_WIDTH; + new_int_val = int_min + (track_v-hbox)*(int_max-int_min)/free_len; + new_float_val = float_min + (track_v-hbox)*(float_max-float_min)/float(free_len); + } else { + int track_v = y-GLUI_SCROLL_ARROW_HEIGHT; + new_int_val = int_max - (track_v-hbox)*(int_max-int_min)/free_len; + new_float_val = float_max - (track_v-hbox)*(float_max-float_min)/float(free_len); + } + } + else { + if ( state == GLUI_SCROLL_STATE_UP ) + direction = +1; + else if ( state == GLUI_SCROLL_STATE_DOWN ) + direction = -1; + incr = growth * direction * modifier_factor * user_speed; + new_int_val += direction; + new_float_val += direction * (float_max-float_min)/free_len; + } + last_y = y; + last_x = x; + + /*** Now update live variable and do callback. We don't want + to do the callback on each iteration of this function, just on every + i^th iteration, where i is given by GLUI_SCROLL_CALLBACK_INTERVAL ****/ + if(data_type==GLUI_SCROLL_INT) + set_int_val(new_int_val); + else if (data_type==GLUI_SCROLL_FLOAT) + set_float_val(new_float_val); + + callback_count++; + if ( (callback_count % GLUI_SCROLL_CALLBACK_INTERVAL ) == 0 ) + do_callbacks(); +} + + +/***************************************** GLUI_Scrollbar::needs_idle() ******/ + +bool GLUI_Scrollbar::needs_idle( void ) const +{ + if (state == GLUI_SCROLL_STATE_UP OR state == GLUI_SCROLL_STATE_DOWN ) { + return true; + } + else { + return false; + } +} + +/***************************************** GLUI_Scrollbar::idle() **********/ + +void GLUI_Scrollbar::idle( void ) +{ + if ( NOT needs_idle() ) + return; + else + do_click(); +} + + +/************************************ GLUI_Scrollbar::do_callbacks() **********/ + +void GLUI_Scrollbar::do_callbacks( void ) +{ + + /* *******************************************/ + + if ( NOT first_callback ) { + if ( data_type == GLUI_SCROLL_INT AND int_val == last_int_val ) { + return; + } + if ( data_type == GLUI_SPINNER_FLOAT AND float_val == last_float_val ) { + return; + } + } + + if (associated_object == NULL) { + this->execute_callback(); + } + else { // Use internal Callbacks + if (object_cb) { + //object_cb(associated_object, int_val); + object_cb(this); + } + } + last_int_val = int_val; + last_float_val = float_val; + first_callback = false; +} + + +/********************************** GLUI_Scrollbar::set_float_val() ************/ + +void GLUI_Scrollbar::set_float_val( float new_val ) +{ + // Allow for the possibility that the limits are reversed + float hi = MAX(float_min,float_max); + float lo = MIN(float_min,float_max); + if (new_val > hi) + new_val = hi; + if (new_val < lo) + new_val = lo; + last_float_val = float_val; + float_val = new_val; + int_val = (int)new_val; + + redraw(); + + /*** Now update the live variable ***/ + output_live(true); +} + + +/********************************** GLUI_Scrollbar::set_int_val() ************/ + +void GLUI_Scrollbar::set_int_val( int new_val ) +{ + // Allow for the possibility that the limits are reversed + int hi = MAX(int_min,int_max); + int lo = MIN(int_min,int_max); + if (new_val > hi) + new_val = hi; + if (new_val < lo) + new_val = lo; + last_int_val = int_val; + float_val = int_val = new_val; + + redraw(); + + /*** Now update the live variable ***/ + output_live(true); +} + +/*********************************** GLUI_Scrollbar::set_float_limits() *********/ + +void GLUI_Scrollbar::set_float_limits( float low, float high, int limit_type ) +{ + if (limit_type != GLUI_LIMIT_CLAMP) { + // error! + } + float_min = low; + float_max = high; + // Allow for possiblitly of reversed limits + float lo = MIN(low,high); + float hi = MAX(low,high); + if (float_val<lo) set_float_val(lo); + if (float_val>hi) set_float_val(hi); +} + + +/*********************************** GLUI_Scrollbar::set_int_limits() *********/ + +void GLUI_Scrollbar::set_int_limits( int low, int high, int limit_type ) +{ + if (limit_type != GLUI_LIMIT_CLAMP) { + // error! + } + int_min = low; + int_max = high; + // Allow for possiblitly of reversed limits + int lo = MIN(low,high); + int hi = MAX(low,high); + if (int_val<lo) set_int_val(lo); + if (int_val>hi) set_int_val(hi); + float_min = low; + float_max = high; +} + + +/*********************************** GLUI_Scrollbar::reset_growth() *************/ + +void GLUI_Scrollbar::reset_growth( void ) +{ + growth = fabs(float_max - float_min) / float(GLUI_SCROLL_GROWTH_STEPS); + if (data_type == GLUI_SCROLL_INT && growth<1) growth=1; +} + + +/******************************* GLUI_Scrollbar::increase_growth() *************/ + +void GLUI_Scrollbar::increase_growth( void ) +{ + float range=0; + if (data_type==GLUI_SCROLL_FLOAT) + range = fabs(float_max-float_min); + else + range = fabs(float(int_max-int_min)); + if ( growth < (range / float(GLUI_SCROLL_MIN_GROWTH_STEPS)) ) + growth *= growth_exp; + return; +} + + + |