glui_radio.cpp
上传用户:gb3593
上传日期:2022-01-07
资源大小:3028k
文件大小:9k
源码类别:

游戏引擎

开发平台:

Visual C++

  1. /****************************************************************************
  2.   
  3.   GLUI User Interface Toolkit
  4.   ---------------------------
  5.      glui_radio.cpp - GLUI_RadioGroup and GLUI_RadioButton control classes
  6.           --------------------------------------------------
  7.   Copyright (c) 1998 Paul Rademacher
  8.   WWW:    http://sourceforge.net/projects/glui/
  9.   Forums: http://sourceforge.net/forum/?group_id=92496
  10.   This library is free software; you can redistribute it and/or
  11.   modify it under the terms of the GNU Lesser General Public
  12.   License as published by the Free Software Foundation; either
  13.   version 2.1 of the License, or (at your option) any later version.
  14.   This library is distributed in the hope that it will be useful,
  15.   but WITHOUT ANY WARRANTY; without even the implied warranty of
  16.   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17.   Lesser General Public License for more details.
  18.   You should have received a copy of the GNU Lesser General Public
  19.   License along with this library; if not, write to the Free Software
  20.   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21. *****************************************************************************/
  22. #include "glui_internal_control.h"
  23. #include <cassert>
  24. /****************************** GLUI_RadioGroup::GLUI_RadioGroup() **********/
  25. GLUI_RadioGroup::GLUI_RadioGroup(GLUI_Node *parent,
  26.                                  int *value_ptr,
  27.                                  int id, GLUI_CB cb)
  28. {
  29.   common_init();
  30.   GLUI_String      buf;
  31.   set_ptr_val( value_ptr );
  32.   if ( value_ptr ) {
  33.     int_val = *value_ptr;  /** Can't call set_int_val(), b/c that 
  34.                                function will try to call the 
  35.                                callback, etc */
  36.     /** Actually, maybe not **/
  37.     last_live_int = *value_ptr;
  38.   }
  39.   user_id    = id;
  40.   glui_format_str( buf, "RadioGroup: %p", this );
  41.   set_name( buf.c_str() );
  42.   callback   = cb;
  43.   parent->add_control( this );
  44.   init_live();
  45. }
  46. /****************************** GLUI_RadioGroup::draw() **********/
  47. void    GLUI_RadioGroup::draw( int x, int y )
  48. {
  49.   if ( NOT can_draw() )
  50.     return;
  51.   draw_group(false);
  52. }
  53. /********************* GLUI_RadioGroup::draw_group(int translate) **********/
  54. void    GLUI_RadioGroup::draw_group( int translate )
  55. {
  56.   GLUI_DRAWINGSENTINAL_IDIOM
  57.   GLUI_RadioButton *button;
  58.   this->int_val = int_val;
  59.   glMatrixMode(GL_MODELVIEW );
  60.   button = (GLUI_RadioButton*) first_child();
  61.   while( button != NULL ) {
  62.     glPushMatrix();
  63.     if (translate) {
  64.       button->translate_to_origin();
  65.     }
  66.     else {
  67.       glTranslatef(button->x_abs-x_abs,
  68.                    button->y_abs-y_abs,0.0);
  69.     }
  70.     if ( button->int_val ) 
  71.       button->draw_checked();
  72.     else 
  73.       button->draw_unchecked();
  74.     
  75.     glPopMatrix();
  76.     button = (GLUI_RadioButton*) button->next();
  77.   }
  78. }
  79. /****************************** GLUI_RadioGroup::set_name() **********/
  80. void    GLUI_RadioGroup::set_name( const char *text )
  81. {
  82.   name = text;
  83.   if ( glui )
  84.     glui->refresh();
  85. }
  86. /********************************* GLUI_RadioGroup::set_selected() **********/
  87. void    GLUI_RadioGroup::set_selected( int int_val )
  88. {
  89.   GLUI_RadioButton *button;
  90.   this->int_val = int_val;
  91.   button = (GLUI_RadioButton*) first_child();
  92.   while( button != NULL ) {
  93.     if ( int_val == -1 ) {       /*** All buttons in group are deselected ***/
  94.       button->set_int_val(0);
  95.     }
  96.     else if ( int_val == button->user_id ) { /*** This is selected button ***/
  97.       button->set_int_val(1);
  98.     }
  99.     else {                               /*** This is NOT selected button ***/
  100.       button->set_int_val(0);
  101.     }
  102.     button = (GLUI_RadioButton*) button->next();
  103.   }
  104.   redraw();
  105. }
  106. /************************ GLUI_RadioButton::GLUI_RadioButton() **********/
  107. GLUI_RadioButton::GLUI_RadioButton( GLUI_RadioGroup *grp, const char *name )
  108. {
  109.   common_init();
  110.   set_int_val( 0 );
  111.   /** A radio button's user id is always its ordinal number (zero-indexed)
  112.       within the group */
  113.   user_id    = grp->num_buttons;
  114.   set_name( name );
  115.   group = grp;
  116.   
  117.   group->num_buttons++;   /* Increments radiogroup's button count */
  118.   group->add_control( this );
  119.   /*** Now update button states ***/
  120.   group->set_int_val( group->int_val ); /* This tells the group to
  121.                                            reset itself to its
  122.                                            current value, thereby
  123.                                            updating all its buttons */
  124. }
  125. /************************ GLUI_RadioButton::mouse_down_handler() **********/
  126. int    GLUI_RadioButton::mouse_down_handler( int local_x, int local_y )
  127. {
  128.   if ( NOT group )
  129.     return false;
  130.   orig_value = group->int_val;
  131.   
  132.   currently_inside = true;
  133.   group->set_selected( this->user_id );
  134.   redraw();
  135.   
  136.   return false;
  137. }
  138. /********************** GLUI_RadioButton::mouse_held_down_handler() ******/
  139. int    GLUI_RadioButton::mouse_held_down_handler( int local_x, int local_y,
  140.   bool inside)
  141. {
  142.   if (inside != currently_inside) {
  143.      if (inside) group->set_selected( this->user_id );
  144.      else group->set_selected( orig_value );
  145.      currently_inside = inside;
  146.      redraw();
  147.   }
  148.   
  149.   return false;
  150. }
  151. /*************************** GLUI_RadioButton::mouse_up_handler() **********/
  152. int    GLUI_RadioButton::mouse_up_handler( int local_x, int local_y, 
  153.    bool inside )
  154. {
  155.   if ( NOT group )
  156.     return false;
  157.   if ( NOT inside ) {
  158.     group->set_selected( orig_value );
  159.     redraw();
  160.   }
  161.   else {
  162.     /** Now we update the radio button group.  We tell the group
  163.       handler to set the currently-selected item to this button, which
  164.       is reference by its user_id/ordinal number within group **/
  165.       
  166.     group->set_selected( this->user_id );
  167.     redraw();
  168.     /*** Now update the linked variable, and call the callback,
  169.       but ONLY if the value of the radio group actually changed ***/
  170.     if ( group->int_val != orig_value ) {
  171.       group->output_live(true); /** Output live and update gfx ***/
  172.       
  173.       group->execute_callback();
  174.     }
  175.   }
  176.   return false;
  177. }
  178. /****************************** GLUI_RadioButton::draw() **********/
  179. void    GLUI_RadioButton::draw( int x, int y )
  180. {
  181.   GLUI_DRAWINGSENTINAL_IDIOM
  182.   if ( NOT group OR NOT can_draw() )
  183.     return;
  184.   /*** See if we're the currently-selected button.  If so, draw ***/
  185.   if ( group->int_val == this->user_id ) {
  186.     if ( enabled )
  187.       glui->std_bitmaps.draw( GLUI_STDBITMAP_RADIOBUTTON_ON, 0, 0 );
  188.     else
  189.       glui->std_bitmaps.draw( GLUI_STDBITMAP_RADIOBUTTON_ON_DIS, 0, 0 );
  190.   }
  191.   else {
  192.     if ( enabled ) 
  193.       glui->std_bitmaps.draw( GLUI_STDBITMAP_RADIOBUTTON_OFF, 0, 0 );
  194.     else
  195.       glui->std_bitmaps.draw( GLUI_STDBITMAP_RADIOBUTTON_OFF_DIS, 0, 0 );
  196.   }
  197.   draw_active_area();
  198.   draw_name( text_x_offset, 10 );
  199. }
  200. /************************************ GLUI_RadioButton::draw_checked() ******/
  201. void   GLUI_RadioButton::draw_checked( void )
  202. {
  203.   GLUI_DRAWINGSENTINAL_IDIOM
  204.   if ( enabled )
  205.     glui->std_bitmaps.draw( GLUI_STDBITMAP_RADIOBUTTON_ON, 0, 0 );
  206.   else
  207.     glui->std_bitmaps.draw( GLUI_STDBITMAP_RADIOBUTTON_ON_DIS, 0, 0 );    
  208.   draw_active_area();
  209. }
  210. /*********************************** GLUI_RadioButton::draw_unchecked() ******/
  211. void   GLUI_RadioButton::draw_unchecked( void )
  212. {
  213.   GLUI_DRAWINGSENTINAL_IDIOM
  214.   
  215.   if ( enabled )
  216.     glui->std_bitmaps.draw( GLUI_STDBITMAP_RADIOBUTTON_OFF, 0, 0 );
  217.   else
  218.     glui->std_bitmaps.draw( GLUI_STDBITMAP_RADIOBUTTON_OFF_DIS, 0, 0 );
  219.   draw_active_area();
  220. }
  221. /**************************************** GLUI_RadioButton::draw_O() ********/
  222. void   GLUI_RadioButton::draw_O( void )
  223. {
  224.   GLUI_DRAWINGSENTINAL_IDIOM
  225.   int i, j;
  226.   glBegin( GL_POINTS );
  227.   for(i=3; i<=GLUI_RADIOBUTTON_SIZE-3; i++ )
  228.     for(j=3; j<=GLUI_RADIOBUTTON_SIZE-3; j++ )
  229.       glVertex2i(i,j);
  230.   glEnd();
  231. }
  232. /******************************** GLUI_RadioButton::update_size() **********/
  233. void   GLUI_RadioButton::update_size( void )
  234. {
  235.   int text_size;
  236.   if ( NOT glui )
  237.     return;
  238.   text_size = _glutBitmapWidthString( glui->font, name.c_str() );
  239.   /*  if ( w < text_x_offset + text_size + 6 )              */
  240.   w = text_x_offset + text_size + 6 ;
  241. }
  242. /************************* GLUI_RadioButton::draw_active_area() **************/
  243. void    GLUI_RadioButton::draw_active_area( void )
  244. {
  245.   GLUI_DRAWINGSENTINAL_IDIOM
  246.   int text_width, left, right;
  247.   text_width = _glutBitmapWidthString( glui->font, name.c_str() );
  248.   left       = text_x_offset-3;
  249.   right      = left + 7 + text_width;
  250.   if ( active ) {
  251.     glEnable( GL_LINE_STIPPLE );
  252.     glLineStipple( 1, 0x5555 );
  253.     glColor3f( 0., 0., 0. );
  254.   } else {
  255.     glColor3ub( glui->bkgd_color.r, glui->bkgd_color.g, glui->bkgd_color.b );
  256.   }
  257.   glBegin( GL_LINE_LOOP );
  258.   glVertex2i(left,0);     glVertex2i( right,0);
  259.   glVertex2i(right,h+1);   glVertex2i( left,h+1);
  260.   glEnd();
  261.   
  262.   glDisable( GL_LINE_STIPPLE );
  263. }
  264. /********************************* GLUI_RadioGroup::set_int_val() **********/
  265. void    GLUI_RadioGroup::set_int_val( int new_val )
  266. {
  267.   if ( new_val == int_val )
  268.     return;
  269.   set_selected( new_val );
  270.   redraw();  
  271.   output_live(true);
  272.      
  273. }