josch/3dpcp
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
3dpcp/3rdparty/glui/glui.h

1702 lines
54 KiB
C
Raw Normal View History

initial commit
2012-09-16 12:33:11 +00:00
/****************************************************************************
GLUI User Interface Toolkit
---------------------------
glui.h - Main header for GLUI User Interface Toolkit
--------------------------------------------------
Copyright (c) 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.
*****************************************************************************/
#ifndef _GLUI_H_
#define _GLUI_H_
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#ifdef __APPLE__
#include <GLUT/glut.h>
#else
#include <GL/glut.h>
#endif
#define GLUI_VERSION 2.01f /********** Current version **********/
#ifdef WIN32
#pragma comment(lib, "glui32.lib") // Link against GLUI library
#endif
class Arcball;
/********** Do some basic defines *******/
#ifndef false
#define true 1
#define false 0
#endif
#ifndef Byte
#define Byte unsigned char
#endif
#ifndef _RGBC_
class RGBc {
public:
Byte r, g, b;
void set(Byte r,Byte g,Byte b) {this->r=r;this->g=g;this->b=b;};
RGBc( void ) {};
RGBc( Byte r, Byte g, Byte b ) { set( r, g, b ); };
};
#define _RGBC_
#endif
/********** List of GLUT callbacks ********/
enum GLUI_Glut_CB_Types {
GLUI_GLUT_RESHAPE,
GLUI_GLUT_KEYBOARD,
GLUI_GLUT_DISPLAY,
GLUI_GLUT_MOUSE,
GLUI_GLUT_MOTION,
GLUI_GLUT_SPECIAL,
GLUI_GLUT_PASSIVE_MOTION,
GLUI_GLUT_ENTRY,
GLUI_GLUT_VISIBILITY
};
/********** List of control types **********/
enum GLUI_Control_Types {
GLUI_CONTROL_CHECKBOX =1,
GLUI_CONTROL_BUTTON,
GLUI_CONTROL_RADIOBUTTON,
GLUI_CONTROL_RADIOGROUP,
GLUI_CONTROL_SLIDER,
GLUI_CONTROL_STATICTEXT,
GLUI_CONTROL_EDITTEXT,
GLUI_CONTROL_BITMAP,
GLUI_CONTROL_PANEL,
GLUI_CONTROL_SPINNER,
GLUI_CONTROL_SEPARATOR,
GLUI_CONTROL_COLUMN,
GLUI_CONTROL_LISTBOX,
GLUI_CONTROL_MOUSE_INTERACTION,
GLUI_CONTROL_ROTATION,
GLUI_CONTROL_TRANSLATION,
GLUI_CONTROL_ROLLOUT
};
/********* Constants for window placement **********/
#define GLUI_XOFF 6
#define GLUI_YOFF 6
#define GLUI_ITEMSPACING 3
#define GLUI_CHECKBOX_SIZE 13
#define GLUI_RADIOBUTTON_SIZE 13
#define GLUI_BUTTON_SIZE 20
#define GLUI_STATICTEXT_SIZE 13
#define GLUI_SEPARATOR_HEIGHT 8
#define GLUI_DEFAULT_CONTROL_WIDTH 100
#define GLUI_DEFAULT_CONTROL_HEIGHT 13
#define GLUI_EDITTEXT_BOXINNERMARGINX 3
#define GLUI_EDITTEXT_HEIGHT 20
#define GLUI_EDITTEXT_WIDTH 130
#define GLUI_EDITTEXT_MIN_INT_WIDTH 35
#define GLUI_EDITTEXT_MIN_TEXT_WIDTH 50
#define GLUI_PANEL_NAME_DROP 8
#define GLUI_PANEL_EMBOSS_TOP 4
/* #define GLUI_ROTATION_WIDTH 60*/
/* #define GLUI_ROTATION_HEIGHT 78 */
#define GLUI_ROTATION_WIDTH 50
#define GLUI_ROTATION_HEIGHT (GLUI_ROTATION_WIDTH+18)
#define GLUI_MOUSE_INTERACTION_WIDTH 50
#define GLUI_MOUSE_INTERACTION_HEIGHT (GLUI_MOUSE_INTERACTION_WIDTH)+18
/** Different panel control types **/
#define GLUI_PANEL_NONE 0
#define GLUI_PANEL_EMBOSSED 1
#define GLUI_PANEL_RAISED 2
/** Max # of els in control's float_array **/
#define GLUI_DEF_MAX_ARRAY 30
/********* The control's 'active' behavior *********/
#define GLUI_CONTROL_ACTIVE_MOUSEDOWN 1
#define GLUI_CONTROL_ACTIVE_PERMANENT 2
/********* Control alignment types **********/
#define GLUI_ALIGN_CENTER 1
#define GLUI_ALIGN_RIGHT 2
#define GLUI_ALIGN_LEFT 3
/********** Limit types - how to limit spinner values *********/
#define GLUI_LIMIT_NONE 0
#define GLUI_LIMIT_CLAMP 1
#define GLUI_LIMIT_WRAP 2
/********** Translation control types ********************/
#define GLUI_TRANSLATION_XY 0
#define GLUI_TRANSLATION_Z 1
#define GLUI_TRANSLATION_X 2
#define GLUI_TRANSLATION_Y 3
#define GLUI_TRANSLATION_LOCK_NONE 0
#define GLUI_TRANSLATION_LOCK_X 1
#define GLUI_TRANSLATION_LOCK_Y 2
/********** How was a control activated? *****************/
#define GLUI_ACTIVATE_MOUSE 1
#define GLUI_ACTIVATE_TAB 2
/********** What type of live variable does a control have? **********/
#define GLUI_LIVE_NONE 0
#define GLUI_LIVE_INT 1
#define GLUI_LIVE_FLOAT 2
#define GLUI_LIVE_TEXT 3
#define GLUI_LIVE_DOUBLE 4
#define GLUI_LIVE_FLOAT_ARRAY 5
/********** Translation codes **********/
enum TranslationCodes {
GLUI_TRANSLATION_MOUSE_NONE=0,
GLUI_TRANSLATION_MOUSE_UP,
GLUI_TRANSLATION_MOUSE_DOWN,
GLUI_TRANSLATION_MOUSE_LEFT,
GLUI_TRANSLATION_MOUSE_RIGHT,
GLUI_TRANSLATION_MOUSE_UP_LEFT,
GLUI_TRANSLATION_MOUSE_UP_RIGHT,
GLUI_TRANSLATION_MOUSE_DOWN_LEFT,
GLUI_TRANSLATION_MOUSE_DOWN_RIGHT
};
/************ A string type for us to use **********/
/* typedef char GLUI_String[300]; */
class GLUI_String
{
public:
char string[300];
char &operator[]( int i ) {
return string[i];
}
operator char*() { return (char*) &string[0]; };
/* operator void*() { return (void*) &string[0]; }; */
GLUI_String( void ) {
string[0] = '\0';
}
GLUI_String( char *text ) {
strcpy( string, text );
}
};
/********* Pre-declare the various classes *********/
class GLUI;
class GLUI_Control;
class GLUI_Listbox;
class GLUI_Rotation;
class GLUI_Translation;
class GLUI_Mouse_Interaction;
class GLUI_Checkbox;
class GLUI_Slider;
class GLUI_Button;
class GLUI_StaticText;
class GLUI_Bitmap;
class GLUI_EditText;
class GLUI_Node;
class GLUI_Main;
class GLUI_Panel;
class GLUI_Spinner;
class GLUI_RadioButton;
class GLUI_RadioGroup;
class GLUI_Separator;
class GLUI_Column;
class GLUI_Master;
class GLUI_Glut_Window;
class GLUI_Rollout;
/*** Flags for GLUI class constructor ***/
#define GLUI_SUBWINDOW ((long)(1<< 1))
#define GLUI_SUBWINDOW_TOP ((long)(1<< 2))
#define GLUI_SUBWINDOW_BOTTOM ((long)(1<< 3))
#define GLUI_SUBWINDOW_LEFT ((long)(1<< 4))
#define GLUI_SUBWINDOW_RIGHT ((long)(1<< 5))
/*** Codes for different type of edittext boxes and spinners ***/
#define GLUI_EDITTEXT_TEXT 1
#define GLUI_EDITTEXT_INT 2
#define GLUI_EDITTEXT_FLOAT 3
#define GLUI_SPINNER_INT GLUI_EDITTEXT_INT
#define GLUI_SPINNER_FLOAT GLUI_EDITTEXT_FLOAT
/*** Definition of callbacks ***/
typedef void (*GLUI_Update_CB) (int id);
typedef void (*Int1_CB) (int);
typedef void (*Int2_CB) (int, int);
typedef void (*Int3_CB) (int, int, int);
typedef void (*Int4_CB) (int, int, int, int);
/************************************************************/
/* */
/* Base class, for hierarchical relationships */
/* */
/************************************************************/
class GLUI_Node {
protected:
GLUI_Node *parent_node;
GLUI_Node *child_head;
GLUI_Node *child_tail;
GLUI_Node *next_sibling;
GLUI_Node *prev_sibling;
public:
GLUI_Node *first_sibling( void );
GLUI_Node *last_sibling( void );
GLUI_Node *prev( void );
GLUI_Node *next( void );
GLUI_Node *first_child( void ) { return child_head; };
GLUI_Node *last_child( void ) { return child_tail; };
GLUI_Node *parent(void) { return parent_node; };
void link_this_to_parent_last( GLUI_Node *parent );
void link_this_to_parent_first( GLUI_Node *parent );
void link_this_to_sibling_next( GLUI_Node *sibling );
void link_this_to_sibling_prev( GLUI_Node *sibling );
void unlink( void );
void dump( FILE *out, char *name ) {
fprintf( out, "GLUI_node: %s\n", name );
fprintf( out, " parent: %p child_head: %p child_tail: %p\n",
parent_node, child_head, child_tail );
fprintf( out, " next: %p prev: %p\n", next_sibling, prev_sibling );
}
GLUI_Node( void ) {
parent_node= child_head = child_tail = next_sibling = prev_sibling = NULL;
};
friend class GLUI_Rollout;
friend class GLUI_Main;
};
/************************************************************/
/* */
/* Standard Bitmap stuff */
/* */
/************************************************************/
enum GLUI_StdBitmaps_Codes {
GLUI_STDBITMAP_CHECKBOX_OFF=0,
GLUI_STDBITMAP_CHECKBOX_ON,
GLUI_STDBITMAP_RADIOBUTTON_OFF,
GLUI_STDBITMAP_RADIOBUTTON_ON,
GLUI_STDBITMAP_UP_ARROW,
GLUI_STDBITMAP_DOWN_ARROW,
GLUI_STDBITMAP_LEFT_ARROW,
GLUI_STDBITMAP_RIGHT_ARROW,
GLUI_STDBITMAP_SPINNER_UP_OFF,
GLUI_STDBITMAP_SPINNER_UP_ON,
GLUI_STDBITMAP_SPINNER_DOWN_OFF,
GLUI_STDBITMAP_SPINNER_DOWN_ON,
GLUI_STDBITMAP_CHECKBOX_OFF_DIS, /*** Disactivated control bitmaps ***/
GLUI_STDBITMAP_CHECKBOX_ON_DIS,
GLUI_STDBITMAP_RADIOBUTTON_OFF_DIS,
GLUI_STDBITMAP_RADIOBUTTON_ON_DIS,
GLUI_STDBITMAP_SPINNER_UP_DIS,
GLUI_STDBITMAP_SPINNER_DOWN_DIS,
GLUI_STDBITMAP_LISTBOX_UP,
GLUI_STDBITMAP_LISTBOX_DOWN,
GLUI_STDBITMAP_LISTBOX_UP_DIS,
/***
GLUI_STDBITMAP_SLIDER_TAB,
***/
GLUI_STDBITMAP_NUM_ITEMS
};
/************ Image Bitmap arrays **********/
extern int glui_img_checkbox_0[];
extern int glui_img_checkbox_1[];
extern int glui_img_radiobutton_0[];
extern int glui_img_radiobutton_1[];
extern int glui_img_uparrow[];
extern int glui_img_downarrow[];
extern int glui_img_leftarrow[];
extern int glui_img_rightarrow[];
extern int glui_img_spinup_0[];
extern int glui_img_spinup_1[];
extern int glui_img_spindown_0[];
extern int glui_img_spindown_1[];
extern int glui_img_checkbox_0_dis[];
extern int glui_img_checkbox_1_dis[];
extern int glui_img_radiobutton_0_dis[];
extern int glui_img_radiobutton_1_dis[];
extern int glui_img_spinup_dis[];
extern int glui_img_spindown_dis[];
extern int glui_img_listbox_up[];
extern int glui_img_listbox_down[];
extern int glui_img_listbox_up_dis[];
extern int *bitmap_arrays[];
/************************************************************/
/* */
/* Class GLUI_Bitmap */
/* */
/************************************************************/
class GLUI_Bitmap
{
public:
unsigned char *pixels;
int w, h;
void load_from_array( int *array );
GLUI_Bitmap( void ) {
pixels = NULL;
w = 0;
h = 0;
}
};
/************************************************************/
/* */
/* Class GLUI_StdBitmap */
/* */
/************************************************************/
class GLUI_StdBitmaps
{
public:
GLUI_Bitmap bitmaps[ GLUI_STDBITMAP_NUM_ITEMS ];
void draw( int bitmap_num, int x, int y );
GLUI_StdBitmaps( void ) {
int i;
for( i=0; i<GLUI_STDBITMAP_NUM_ITEMS; i++ ) {
bitmaps[i].load_from_array( bitmap_arrays[i] );
}
}
};
/************************************************************/
/* */
/* Master GLUI Class */
/* */
/************************************************************/
class GLUI_Master_Object {
private:
GLUI_Node glut_windows;
void (*glut_idle_CB)(void);
void add_cb_to_glut_window(int window,int cb_type,void *cb);
public:
GLUI_Node gluis;
GLUI_Control *active_control, *curr_left_button_glut_menu;
GLUI *active_control_glui;
int glui_id_counter;
GLUI_Glut_Window *find_glut_window( int window_id );
void set_glutIdleFunc(void (*f)(void));
/**************
void (*glut_keyboard_CB)(unsigned char, int, int);
void (*glut_reshape_CB)(int, int);
void (*glut_special_CB)(int, int, int);
void (*glut_mouse_CB)(int,int,int,int);
void (*glut_passive_motion_CB)(int,int);
void (*glut_visibility_CB)(int);
void (*glut_motion_CB)(int,int);
void (*glut_display_CB)(void);
void (*glut_entry_CB)(int);
**********/
void set_left_button_glut_menu_control( GLUI_Control *control );
/********** GLUT callthroughs **********/
/* These are the glut callbacks that we do not handle */
void set_glutReshapeFunc(void (*f)(int width, int height));
void set_glutKeyboardFunc(void (*f)(unsigned char key, int x, int y));
void set_glutSpecialFunc(void (*f)(int key, int x, int y));
void set_glutMouseFunc(void (*f)(int, int, int, int ));
void set_glutDisplayFunc(void (*f)(void)) {glutDisplayFunc(f);};
void set_glutTimerFunc(unsigned int millis, void (*f)(int value), int value)
{ ::glutTimerFunc(millis,f,value);};
void set_glutOverlayDisplayFunc(void(*f)(void)){glutOverlayDisplayFunc(f);};
void set_glutSpaceballMotionFunc(Int3_CB f) {glutSpaceballMotionFunc(f);};
void set_glutSpaceballRotateFunc(Int3_CB f) {glutSpaceballRotateFunc(f);};
void set_glutSpaceballButtonFunc(Int2_CB f) {glutSpaceballButtonFunc(f);};
void set_glutTabletMotionFunc(Int2_CB f) {glutTabletMotionFunc(f);};
void set_glutTabletButtonFunc(Int4_CB f) {glutTabletButtonFunc(f);};
/* void set_glutWindowStatusFunc(Int1_CB f) {glutWindowStatusFunc(f);}; */
void set_glutMenuStatusFunc(Int3_CB f) {glutMenuStatusFunc(f);};
void set_glutMenuStateFunc(Int1_CB f) {glutMenuStateFunc(f);};
void set_glutButtonBoxFunc(Int2_CB f) {glutButtonBoxFunc(f);};
void set_glutDialsFunc(Int2_CB f) {glutDialsFunc(f);};
GLUI *create_glui( char *name, long flags=0, int x=-1, int y=-1 );
GLUI *create_glui_subwindow( int parent_window, long flags=0 );
GLUI *find_glui_by_window_id( int window_id );
void get_viewport_area( int *x, int *y, int *w, int *h );
void auto_set_viewport( void );
void close_all( void );
void sync_live_all( void );
void reshape( void );
float get_version( void ) { return GLUI_VERSION; };
friend void glui_idle_func(void);
GLUI_Master_Object( void ) {
glut_idle_CB = NULL;
glui_id_counter = 1;
}
};
extern GLUI_Master_Object GLUI_Master;
/************************************************************/
/* */
/* Class for managing a GLUT window */
/* */
/************************************************************/
class GLUI_Glut_Window : public GLUI_Node {
public:
int glut_window_id;
/*********** Pointers to GLUT callthrough functions *****/
void (*glut_keyboard_CB)(unsigned char, int, int);
void (*glut_special_CB)(int, int, int);
void (*glut_reshape_CB)(int, int);
void (*glut_passive_motion_CB)(int,int);
void (*glut_mouse_CB)(int,int,int,int);
void (*glut_visibility_CB)(int);
void (*glut_motion_CB)(int,int);
void (*glut_display_CB)(void);
void (*glut_entry_CB)(int);
GLUI_Glut_Window( void ) {
glut_display_CB = NULL;
glut_reshape_CB = NULL;
glut_keyboard_CB = NULL;
glut_special_CB = NULL;
glut_mouse_CB = NULL;
glut_motion_CB = NULL;
glut_passive_motion_CB = NULL;
glut_entry_CB = NULL;
glut_visibility_CB = NULL;
glut_window_id = 0;
};
};
/************************************************************/
/* */
/* Main GLUI class (not user-level) */
/* */
/************************************************************/
class GLUI_Main : public GLUI_Node {
protected:
/*** Variables ***/
int main_gfx_window_id;
int mouse_button_down;
int glut_window_id;
int top_level_glut_window_id;
GLUI_Control *active_control;
GLUI_Control *mouse_over_control;
GLUI_Panel *main_panel;
int curr_cursor;
int w, h;
long flags;
int closing;
int parent_window;
int glui_id;
/********** Friend classes *************/
friend class GLUI_Control;
friend class GLUI_Rotation;
friend class GLUI_Translation;
friend class GLUI;
friend class GLUI_Master_Object;
/********** Misc functions *************/
GLUI_Control *find_control( int x, int y );
GLUI_Control *find_next_control( GLUI_Control *control );
GLUI_Control *find_next_control_rec( GLUI_Control *control );
GLUI_Control *find_next_control_( GLUI_Control *control );
GLUI_Control *find_prev_control( GLUI_Control *control );
void create_standalone_window( char *name, int x=-1, int y=-1 );
void create_subwindow( int parent,int window_alignment );
void setup_default_glut_callbacks( void );
void mouse(int button, int state, int x, int y);
void keyboard(unsigned char key, int x, int y);
void special(int key, int x, int y);
void passive_motion(int x, int y);
void reshape( int w, int h );
void visibility(int state);
void motion(int x, int y);
void entry(int state);
void display( void );
void idle(void);
void (*glut_mouse_CB)(int, int, int, int);
void (*glut_keyboard_CB)(unsigned char, int, int);
void (*glut_special_CB)(int, int, int);
void (*glut_reshape_CB)(int, int);
/*********** Friend functions and classes **********/
friend void glui_mouse_func(int button, int state, int x, int y);
friend void glui_keyboard_func(unsigned char key, int x, int y);
friend void glui_special_func(int key, int x, int y);
friend void glui_passive_motion_func(int x, int y);
friend void glui_reshape_func( int w, int h );
friend void glui_visibility_func(int state);
friend void glui_motion_func(int x, int y);
friend void glui_entry_func(int state);
friend void glui_display_func( void );
friend void glui_idle_func(void);
friend void glui_parent_window_reshape_func( int w, int h );
friend void glui_parent_window_keyboard_func( unsigned char, int, int );
friend void glui_parent_window_special_func( int, int, int );
friend void glui_parent_window_mouse_func( int, int, int, int );
/*********** Controls ************/
GLUI_Control *controls;
int num_controls;
int add_control( GLUI_Node *parent, GLUI_Control *control );
/********** Constructors and Destructors ***********/
GLUI_Main( void );
public:
GLUI_StdBitmaps std_bitmaps;
GLUI_String window_name;
RGBc bkgd_color;
float bkgd_color_f[3];
void *font;
int curr_modifiers;
void adjust_glut_xy( int &x, int &y ) { y = h-y; };
void activate_control( GLUI_Control *control, int how );
void align_controls( GLUI_Control *control );
void restore_draw_buffer( int buffer_state );
void disactivate_current_control( void );
void draw_raised_box( int x, int y, int w, int h );
void draw_lowered_box( int x, int y, int w, int h );
int set_front_draw_buffer( void );
void post_update_main_gfx( void );
void pack_controls( void );
void close_internal( void );
void check_subwindow_position( void );
void set_ortho_projection( void );
void set_viewport( void );
void refresh( void );
void set_glutMouseFunc(void (*f)(int button, int state, int x, int y));
};
/************************************************************/
/* */
/* GLUI_Control: base class for all controls */
/* */
/************************************************************/
class GLUI_Control : public GLUI_Node {
public:
int w, h; /* dimensions of control */
int x_abs, y_abs;
int x_off, y_off_top, y_off_bot; /* INNER margins, by which
child controls are indented */
int contain_x, contain_y;
int contain_w, contain_h;
/* if this is a container control (e.g.,
radiogroup or panel) this indicated dimensions
of inner area in which controls reside */
int active, active_type, can_activate;
int spacebar_mouse_click;
long user_id, type;
int is_container; /* Is this a container class (e.g., panel) */
int alignment;
GLUI_Update_CB callback;
void *ptr_val; /* A pointer value */
float float_val; /* A float value */
int enabled; /* Is this control grayed out? */
int int_val; /* An integer value */
float float_array_val[GLUI_DEF_MAX_ARRAY];
int state;
GLUI_String name; /* The name of this control */
GLUI_String text;
GLUI *glui;
void *font;
int live_type, live_inited;
int last_live_int; /* last value that live var known to have */
float last_live_float;
GLUI_String last_live_text;
float last_live_float_array[GLUI_DEF_MAX_ARRAY];
int float_array_size;
int collapsible, is_open;
GLUI_Node collapsed_node;
int hidden; /* Collapsed controls (and children) are hidden */
/*** Get/Set values ***/
virtual void set_name( char *string );
virtual void set_int_val( int new_int ) { int_val = new_int; output_live(true); };
virtual void set_float_val( float new_float ) { float_val = new_float; output_live(true); };
virtual void set_ptr_val( void *new_ptr ) { ptr_val = new_ptr; output_live(true); };
virtual void set_float_array_val( float *array_ptr );
virtual float get_float_val( void ) { return float_val; };
virtual int get_int_val( void ) { return int_val; };
virtual void get_float_array_val( float *array_ptr );
virtual int mouse_down_handler( int local_x, int local_y )
{ return false; };
virtual int mouse_up_handler( int local_x, int local_y, int inside )
{ return false; };
virtual int mouse_held_down_handler( int local_x, int local_y, int inside)
{ return false; };
virtual int key_handler( unsigned char key, int modifiers )
{ return false; };
virtual int special_handler( int key,int modifiers )
{ return false; };
virtual void update_size( void ) { };
virtual void idle( void ) { };
virtual int mouse_over( int state, int x, int y ) { return false; };
virtual void enable( void );
virtual void disable( void );
virtual void activate( int how ) { active = true; };
virtual void disactivate( void ) { active = false; };
void hide_internal( int recurse );
void unhide_internal( int recurse );
int can_draw( void ) { return (glui != NULL && hidden == false); };
virtual void align( void );
void pack( int x, int y ); /* Recalculate positions and offsets */
void pack_old( int x, int y );
void draw_recursive( int x, int y );
int set_to_glut_window( void );
void restore_window( int orig );
void translate_and_draw_front( void );
void translate_to_origin( void )
{glTranslatef((float)x_abs+.5,(float)y_abs+.5,0.0);};
virtual void draw( int x, int y )=0;
void set_font( void *new_font );
void *get_font( void );
int string_width( char *text );
int char_width( char c );
void draw_name( int x, int y );
void draw_box_inwards_outline( int x_min, int x_max,
int y_min, int y_max );
void draw_box( int x_min, int x_max, int y_min, int y_max,
float r, float g, float b );
void draw_bkgd_box( int x_min, int x_max, int y_min, int y_max );
void draw_emboss_box( int x_min, int x_max,int y_min,int y_max);
void draw_string( char *text );
void draw_char( char c );
void draw_active_box( int x_min, int x_max, int y_min, int y_max );
void set_to_bkgd_color( void );
void set_w( int new_w );
void set_h( int new_w );
void set_alignment( int new_align );
void sync_live( int recurse, int draw ); /* Reads live variable */
void init_live( void );
void output_live( int update_main_gfx ); /** Writes live variable **/
virtual void set_text( char *t ) {};
void execute_callback( void );
void get_this_column_dims( int *col_x, int *col_y,
int *col_w, int *col_h,
int *col_x_off, int *col_y_off );
virtual int needs_idle( void );
GLUI_Control(void) {
x_off = GLUI_XOFF;
y_off_top = GLUI_YOFF;
y_off_bot = GLUI_YOFF;
x_abs = GLUI_XOFF;
y_abs = GLUI_YOFF;
state = 0;
active = false;
enabled = true;
int_val = 0;
last_live_int = 0;
float_array_size = 0;
sprintf( (char*)name, "Control: %p", this );
float_val = 0.0;
last_live_float = 0.0;
ptr_val = NULL;
glui = NULL;
w = GLUI_DEFAULT_CONTROL_WIDTH;
h = GLUI_DEFAULT_CONTROL_HEIGHT;
font = NULL;
active_type = GLUI_CONTROL_ACTIVE_MOUSEDOWN;
alignment = GLUI_ALIGN_LEFT;
is_container = false;
can_activate = true; /* By default, you can activate a control */
spacebar_mouse_click = true; /* Does spacebar simulate a mouse click? */
live_type = GLUI_LIVE_NONE;
strcpy( (char*)text, "" );
strcpy( (char*)last_live_text, "" );
live_inited = false;
collapsible = false;
is_open = true;
hidden = false;
int i;
for( i=0; i<GLUI_DEF_MAX_ARRAY; i++ )
float_array_val[i] = last_live_float_array[i] = 0.0;
};
virtual ~GLUI_Control();
};
/************************************************************/
/* */
/* Button class (container) */
/* */
/************************************************************/
class GLUI_Button : public GLUI_Control
{
public:
int currently_inside;
int mouse_down_handler( int local_x, int local_y );
int mouse_up_handler( int local_x, int local_y, int same );
int mouse_held_down_handler( int local_x, int local_y, int inside );
int key_handler( unsigned char key,int modifiers );
void draw( int x, int y );
void draw_pressed( void );
void draw_unpressed( void );
void draw_text( int sunken );
void update_size( void );
GLUI_Button( void ) {
sprintf( name, "Button: %p", this );
type = GLUI_CONTROL_BUTTON;
h = GLUI_BUTTON_SIZE;
w = 100;
alignment = GLUI_ALIGN_CENTER;
can_activate = true;
};
virtual ~GLUI_Button() {};
};
/************************************************************/
/* */
/* Checkbox class (container) */
/* */
/************************************************************/
class GLUI_Checkbox : public GLUI_Control
{
public:
int orig_value, currently_inside;
int text_x_offset;
int mouse_down_handler( int local_x, int local_y );
int mouse_up_handler( int local_x, int local_y, int inside );
int mouse_held_down_handler( int local_x, int local_y, int inside );
int key_handler( unsigned char key,int modifiers );
void update_size( void );
void draw( int x, int y );
void draw_active_area( void );
void draw_checked( void );
void draw_unchecked( void );
void draw_X( void );
void draw_empty_box( void );
void set_int_val( int new_val );
GLUI_Checkbox( void ) {
sprintf( name, "Checkbox: %p", this );
type = GLUI_CONTROL_CHECKBOX;
w = 100;
h = GLUI_CHECKBOX_SIZE;
orig_value = -1;
text_x_offset = 18;
can_activate = true;
live_type = GLUI_LIVE_INT; /* This control has an 'int' live var */
};
virtual ~GLUI_Checkbox() {};
};
/************************************************************/
/* */
/* Column class */
/* */
/************************************************************/
class GLUI_Column : public GLUI_Control
{
public:
void draw( int x, int y );
GLUI_Column( void ) {
type = GLUI_CONTROL_COLUMN;
w = 0;
h = 0;
int_val = 0;
can_activate = false;
};
virtual ~GLUI_Column() {};
};
/************************************************************/
/* */
/* Panel class (container) */
/* */
/************************************************************/
class GLUI_Panel : public GLUI_Control
{
public:
void draw( int x, int y );
void set_name( char *text );
void set_type( int new_type );
void update_size( void );
GLUI_Panel( void ) {
type = GLUI_CONTROL_PANEL;
w = 300;
h = GLUI_DEFAULT_CONTROL_HEIGHT + 7;
int_val = GLUI_PANEL_EMBOSSED;
alignment = GLUI_ALIGN_CENTER;
is_container = true;
can_activate = false;
strcpy( name, "" );
};
virtual ~GLUI_Panel() {};
};
/************************************************************/
/* */
/* Panel class (container) */
/* */
/************************************************************/
class GLUI_Rollout : public GLUI_Panel
{
/* private: */
/* GLUI_Panel panel; */
public:
int currently_inside, initially_inside;
GLUI_Button button;
void draw( int x, int y );
void draw_pressed( void );
void draw_unpressed( void );
int mouse_down_handler( int local_x, int local_y );
int mouse_up_handler( int local_x, int local_y, int inside );
int mouse_held_down_handler( int local_x, int local_y, int inside );
void open( void );
void close( void );
/* void set_name( char *text ) { panel.set_name( text ); }; */
void update_size( void );
GLUI_Rollout( void ) {
currently_inside = false;
initially_inside = false;
can_activate = true;
is_container = true;
type = GLUI_CONTROL_ROLLOUT;
h = GLUI_DEFAULT_CONTROL_HEIGHT + 7;
w = GLUI_DEFAULT_CONTROL_WIDTH;
y_off_top = 21;
collapsible = true;
strcpy( name, "" );
};
virtual ~GLUI_Rollout() {};
};
/************************************************************/
/* */
/* User-Level GLUI class */
/* */
/************************************************************/
class GLUI : public GLUI_Main {
private:
public:
void add_column( int draw_bar = true );
void add_column_to_panel( GLUI_Panel *panel, int draw_bar = true );
void add_separator( void );
void add_separator_to_panel( GLUI_Panel *panel );
GLUI_RadioGroup
*add_radiogroup( int *live_var=NULL,
int user_id=-1,GLUI_Update_CB callback=NULL);
GLUI_RadioGroup
*add_radiogroup_to_panel( GLUI_Panel *panel,
int *live_var=NULL,
int user_id=-1, GLUI_Update_CB callback=NULL );
GLUI_RadioButton
*add_radiobutton_to_group( GLUI_RadioGroup *group,
char *name );
GLUI_Listbox *add_listbox( char *name, int *live_var=NULL,
int id=-1, GLUI_Update_CB callback=NULL );
GLUI_Listbox *add_listbox_to_panel( GLUI_Panel *panel,
char *name, int *live_var=NULL,
int id=-1, GLUI_Update_CB callback=NULL);
GLUI_Rotation *add_rotation( char *name, float *live_var=NULL,
int id=-1, GLUI_Update_CB callback=NULL );
GLUI_Rotation *add_rotation_to_panel( GLUI_Panel *panel,
char *name, float *live_var=NULL,
int id=-1, GLUI_Update_CB callback=NULL);
GLUI_Translation *add_translation( char *name,
int trans_type, float *live_var=NULL,
int id=-1, GLUI_Update_CB callback=NULL );
GLUI_Translation *add_translation_to_panel(
GLUI_Panel *panel, char *name,
int trans_type, float *live_var=NULL,
int id=-1, GLUI_Update_CB callback=NULL);
GLUI_Checkbox *add_checkbox( char *name,
int *live_var=NULL,
int id=-1, GLUI_Update_CB callback=NULL);
GLUI_Checkbox *add_checkbox_to_panel( GLUI_Panel *panel, char *name,
int *live_var=NULL, int id=-1,
GLUI_Update_CB callback=NULL);
GLUI_Button *add_button( char *name, int id=-1,
GLUI_Update_CB callback=NULL);
GLUI_Button *add_button_to_panel( GLUI_Panel *panel, char *name,
int id=-1, GLUI_Update_CB callback=NULL );
GLUI_StaticText *add_statictext( char *name );
GLUI_StaticText *add_statictext_to_panel( GLUI_Panel *panel, char *name );
GLUI_EditText *add_edittext( char *name,
int data_type=GLUI_EDITTEXT_TEXT,
void *live_var=NULL,
int id=-1, GLUI_Update_CB callback=NULL );
GLUI_EditText *add_edittext_to_panel( GLUI_Panel *panel,
char *name,
int data_type=GLUI_EDITTEXT_TEXT,
void *live_var=NULL, int id=-1,
GLUI_Update_CB callback=NULL );
GLUI_Spinner *add_spinner( char *name,
int data_type=GLUI_SPINNER_INT,
void *live_var=NULL,
int id=-1, GLUI_Update_CB callback=NULL );
GLUI_Spinner *add_spinner_to_panel( GLUI_Panel *panel,
char *name,
int data_type=GLUI_SPINNER_INT,
void *live_var=NULL,
int id=-1,
GLUI_Update_CB callback=NULL );
GLUI_Panel *add_panel( char *name, int type=GLUI_PANEL_EMBOSSED );
GLUI_Panel *add_panel_to_panel( GLUI_Panel *panel, char *name,
int type=GLUI_PANEL_EMBOSSED );
GLUI_Rollout *add_rollout( char *name, int open=true );
GLUI_Rollout *add_rollout_to_panel( GLUI_Panel *panel, char *name, int open=true );
void set_main_gfx_window( int window_id );
int get_glut_window_id( void ) { return glut_window_id; };
void enable( void ) { main_panel->enable(); };
void disable( void );
void sync_live( void );
void close( void );
void show( void );
void hide( void );
/***** GLUT callback setup functions *****/
/*
void set_glutDisplayFunc(void (*f)(void));
void set_glutReshapeFunc(void (*f)(int width, int height));
void set_glutKeyboardFunc(void (*f)(unsigned char key, int x, int y));
void set_glutSpecialFunc(void (*f)(int key, int x, int y));
void set_glutMouseFunc(void (*f)(int button, int state, int x, int y));
void set_glutMotionFunc(void (*f)(int x, int y));
void set_glutPassiveMotionFunc(void (*f)(int x, int y));
void set_glutEntryFunc(void (*f)(int state));
void set_glutVisibilityFunc(void (*f)(int state));
void set_glutInit( int *argcp, char **argv );
void set_glutInitWindowSize(int width, int height);
void set_glutInitWindowPosition(int x, int y);
void set_glutInitDisplayMode(unsigned int mode);
int set_glutCreateWindow(char *name);
*/
/***** Constructors and desctructors *****/
int init( char *name, long flags, int x, int y, int parent_window );
};
/************************************************************/
/* */
/* EditText class */
/* */
/************************************************************/
class GLUI_EditText : public GLUI_Control
{
public:
int has_limits;
int data_type;
GLUI_String orig_text;
int insertion_pt;
int title_x_offset;
int text_x_offset;
int substring_start; /*substring that gets displayed in box*/
int substring_end;
int sel_start, sel_end; /* current selection */
int num_periods;
int last_insertion_pt;
float float_low, float_high;
int int_low, int_high;
GLUI_Spinner *spinner;
int debug;
int draw_text_only;
int mouse_down_handler( int local_x, int local_y );
int mouse_up_handler( int local_x, int local_y, int same );
int mouse_held_down_handler( int local_x, int local_y, int inside );
int key_handler( unsigned char key,int modifiers );
int special_handler( int key,int modifiers );
void activate( int how );
void disactivate( void );
void draw( int x, int y );
int mouse_over( int state, int x, int y );
int find_word_break( int start, int direction );
int substring_width( int start, int end );
void clear_substring( int start, int end );
int find_insertion_pt( int x, int y );
int update_substring_bounds( void );
void update_and_draw_text( void );
void draw_text( int x, int y );
void draw_insertion_pt( void );
void set_numeric_text( void );
void update_x_offsets( void );
void update_size( void );
void set_float_limits( float low,float high,int limit_type=GLUI_LIMIT_CLAMP);
void set_int_limits( int low, int high, int limit_type=GLUI_LIMIT_CLAMP );
void set_float_val( float new_val );
void set_int_val( int new_val );
void set_text( char *text );
char *get_text( void ) { return text; };
void dump( FILE *out, char *text );
GLUI_EditText( void ) {
type = GLUI_CONTROL_EDITTEXT;
h = GLUI_EDITTEXT_HEIGHT;
w = GLUI_EDITTEXT_WIDTH;
title_x_offset = 0;
text_x_offset = 55;
insertion_pt = -1;
last_insertion_pt = -1;
name[0] = '\0';
substring_start = 0;
data_type = GLUI_EDITTEXT_TEXT;
substring_end = 2;
num_periods = 0;
has_limits = GLUI_LIMIT_NONE;
sel_start = 0;
sel_end = 0;
active_type = GLUI_CONTROL_ACTIVE_PERMANENT;
can_activate = true;
spacebar_mouse_click = false;
spinner = NULL;
debug = false;
draw_text_only = false;
};
};
/************************************************************/
/* */
/* RadioGroup class (container) */
/* */
/************************************************************/
class GLUI_RadioGroup : public GLUI_Control
{
public:
int num_buttons;
void draw( int x, int y );
void set_name( char *text );
void set_int_val( int int_val );
void set_selected( int int_val );
void draw_group( int translate );
GLUI_RadioGroup( void ) {
type = GLUI_CONTROL_RADIOGROUP;
x_off = 0;
y_off_top = 0;
y_off_bot = 0;
is_container = true;
w = 300;
h = 300;
num_buttons = 0;
name[0] = '\0';
can_activate = false;
live_type = GLUI_LIVE_INT;
};
};
/************************************************************/
/* */
/* RadioButton class (container) */
/* */
/************************************************************/
class GLUI_RadioButton : public GLUI_Control
{
public:
int orig_value, currently_inside;
int text_x_offset;
int mouse_down_handler( int local_x, int local_y );
int mouse_up_handler( int local_x, int local_y, int inside );
int mouse_held_down_handler( int local_x, int local_y, int inside );
void draw( int x, int y );
void update_size( void );
void draw_active_area( void );
void draw_checked( void );
void draw_unchecked( void );
void draw_O( void );
GLUI_RadioGroup *group;
GLUI_RadioButton( void ) {
sprintf( name, "RadioButton: %p", this );
type = GLUI_CONTROL_RADIOBUTTON;
h = GLUI_RADIOBUTTON_SIZE;
group = NULL;
orig_value = -1;
text_x_offset = 18;
can_activate = true;
};
};
/************************************************************/
/* */
/* Separator class (container) */
/* */
/************************************************************/
class GLUI_Separator : public GLUI_Control
{
public:
void draw( int x, int y );
GLUI_Separator( void ) {
type = GLUI_CONTROL_SEPARATOR;
w = 100;
h = GLUI_SEPARATOR_HEIGHT;
can_activate = false;
};
};
#define GLUI_SPINNER_ARROW_WIDTH 12
#define GLUI_SPINNER_ARROW_HEIGHT 8
#define GLUI_SPINNER_ARROW_Y 2
#define GLUI_SPINNER_STATE_NONE 0
#define GLUI_SPINNER_STATE_UP 1
#define GLUI_SPINNER_STATE_DOWN 2
#define GLUI_SPINNER_STATE_BOTH 3
#define GLUI_SPINNER_DEFAULT_GROWTH_EXP 1.05f
/************************************************************/
/* */
/* Spinner class (container) */
/* */
/************************************************************/
class GLUI_Spinner : public GLUI_Control
{
public:
int currently_inside;
int state;
float growth, growth_exp;
int last_x, last_y;
int data_type;
int callback_count;
int last_int_val;
float last_float_val;
int first_callback;
float user_speed;
GLUI_EditText *edittext;
int mouse_down_handler( int local_x, int local_y );
int mouse_up_handler( int local_x, int local_y, int same );
int mouse_held_down_handler( int local_x, int local_y, int inside );
int key_handler( unsigned char key,int modifiers );
int special_handler( int key,int modifiers );
void draw( int x, int y );
void draw_pressed( void );
void draw_unpressed( void );
void draw_text( int sunken );
void update_size( void );
void set_float_limits( float low,float high,int limit_type=GLUI_LIMIT_CLAMP);
void set_int_limits( int low, int high,int limit_type=GLUI_LIMIT_CLAMP);
int find_arrow( int local_x, int local_y );
void do_drag( int x, int y );
void do_callbacks( void );
void draw_arrows( void );
void do_click( void );
void idle( void );
int needs_idle( void );
char *get_text( void );
void set_float_val( float new_val );
void set_int_val( int new_val );
float get_float_val( void );
int get_int_val( void );
void increase_growth( void );
void reset_growth( void );
void set_speed( float speed ) { user_speed = speed; };
GLUI_Spinner( void ) {
sprintf( name, "Spinner: %p", this );
type = GLUI_CONTROL_SPINNER;
h = GLUI_EDITTEXT_HEIGHT;
w = GLUI_EDITTEXT_WIDTH;
x_off = 0;
y_off_top = 0;
y_off_bot = 0;
can_activate = true;
state = GLUI_SPINNER_STATE_NONE;
edittext = NULL;
growth_exp = GLUI_SPINNER_DEFAULT_GROWTH_EXP;
callback_count = 0;
first_callback = true;
user_speed = 1.0;
};
};
/************************************************************/
/* */
/* StaticText class */
/* */
/************************************************************/
class GLUI_StaticText : public GLUI_Control
{
public:
void set_text( char *text );
void draw( int x, int y );
void draw_text( void );
void update_size( void );
void erase_text( void );
GLUI_StaticText( void ) {
type = GLUI_CONTROL_STATICTEXT;
h = GLUI_STATICTEXT_SIZE;
name[0] = '\0';
can_activate = false;
};
};
/************************************************************/
/* */
/* Listbox class */
/* */
/************************************************************/
class GLUI_Listbox_Item : public GLUI_Node
{
public:
GLUI_String text;
int id;
};
class GLUI_Listbox : public GLUI_Control
{
public:
GLUI_String curr_text;
GLUI_Listbox_Item items_list;
int depressed;
int orig_value, currently_inside;
int text_x_offset, title_x_offset;
int glut_menu_id;
int mouse_down_handler( int local_x, int local_y );
int mouse_up_handler( int local_x, int local_y, int inside );
int mouse_held_down_handler( int local_x, int local_y, int inside );
int key_handler( unsigned char key,int modifiers );
int special_handler( int key,int modifiers );
void update_size( void );
void draw( int x, int y );
int mouse_over( int state, int x, int y );
void draw_active_area( void );
void set_int_val( int new_val );
void dump( FILE *output );
int add_item( int id, char *text );
int delete_item( char *text );
int delete_item( int id );
int sort_items( void );
int do_selection( int item );
void increase_width( void );
GLUI_Listbox_Item *get_item_ptr( char *text );
GLUI_Listbox_Item *get_item_ptr( int id );
GLUI_Listbox( void ) {
sprintf( name, "Listbox: %p", this );
type = GLUI_CONTROL_LISTBOX;
w = GLUI_EDITTEXT_WIDTH;
h = GLUI_EDITTEXT_HEIGHT;
orig_value = -1;
title_x_offset = 0;
text_x_offset = 55;
can_activate = true;
curr_text[0] = '\0';
live_type = GLUI_LIVE_INT; /* This has an integer live var */
depressed = false;
glut_menu_id = -1;
};
~GLUI_Listbox();
};
/************************************************************/
/* */
/* Mouse_Interaction class */
/* */
/************************************************************/
class GLUI_Mouse_Interaction : public GLUI_Control
{
public:
/*int get_main_area_size( void ) { return MIN( h-18, */
int draw_active_area_only;
int mouse_down_handler( int local_x, int local_y );
int mouse_up_handler( int local_x, int local_y, int inside );
int mouse_held_down_handler( int local_x, int local_y, int inside );
int special_handler( int key, int modifiers );
void update_size( void );
void draw( int x, int y );
void draw_active_area( void );
/*** The following methods (starting with "iaction_") need to
be overloaded ***/
virtual int iaction_mouse_down_handler( int local_x, int local_y ) = 0;
virtual int iaction_mouse_up_handler( int local_x, int local_y, int inside )=0;
virtual int iaction_mouse_held_down_handler( int local_x, int local_y, int inside )=0;
virtual int iaction_special_handler( int key, int modifiers )=0;
virtual void iaction_draw_active_area_persp( void )=0;
virtual void iaction_draw_active_area_ortho( void )=0;
virtual void iaction_dump( FILE *output )=0;
virtual void iaction_init( void ) = 0;
GLUI_Mouse_Interaction( void ) {
sprintf( name, "Mouse_Interaction: %p", this );
type = GLUI_CONTROL_MOUSE_INTERACTION;
w = GLUI_MOUSE_INTERACTION_WIDTH;
h = GLUI_MOUSE_INTERACTION_HEIGHT;
can_activate = true;
live_type = GLUI_LIVE_NONE;
alignment = GLUI_ALIGN_CENTER;
draw_active_area_only = false;
};
};
/************************************************************/
/* */
/* Rotation class */
/* */
/************************************************************/
class GLUI_Rotation : public GLUI_Mouse_Interaction
{
public:
Arcball *ball;
GLUquadricObj *quadObj;
int can_spin, spinning;
float damping;
int iaction_mouse_down_handler( int local_x, int local_y );
int iaction_mouse_up_handler( int local_x, int local_y, int inside );
int iaction_mouse_held_down_handler( int local_x, int local_y, int inside );
int iaction_special_handler( int key, int modifiers );
void iaction_init( void ) { init_ball(); };
void iaction_draw_active_area_persp( void );
void iaction_draw_active_area_ortho( void );
void iaction_dump( FILE *output );
/* void update_size( void ); */
/* void draw( int x, int y ); */
/* int mouse_over( int state, int x, int y ); */
void setup_texture( void );
void setup_lights( void );
void draw_ball( float radius );
void init_ball( void );
void reset( void );
int needs_idle( void );
void idle( void );
void copy_float_array_to_ball( void );
void copy_ball_to_float_array( void );
void set_spin( float damp_factor );
GLUI_Rotation(void);
};
/************************************************************/
/* */
/* Translation class */
/* */
/************************************************************/
class GLUI_Translation : public GLUI_Mouse_Interaction
{
public:
int trans_type; /* Is this an XY or a Z controller? */
int down_x, down_y;
float scale_factor;
GLUquadricObj *quadObj;
int trans_mouse_code;
float orig_x, orig_y, orig_z;
int locked;
int iaction_mouse_down_handler( int local_x, int local_y );
int iaction_mouse_up_handler( int local_x, int local_y, int inside );
int iaction_mouse_held_down_handler( int local_x, int local_y, int inside );
int iaction_special_handler( int key, int modifiers );
void iaction_init( void ) { };
void iaction_draw_active_area_persp( void );
void iaction_draw_active_area_ortho( void );
void iaction_dump( FILE *output );
void set_speed( float s ) { scale_factor = s; };
void setup_texture( void );
void setup_lights( void );
void draw_2d_arrow( int radius, int filled, int orientation );
void draw_2d_x_arrows( int radius );
void draw_2d_y_arrows( int radius );
void draw_2d_z_arrows( int radius );
void draw_2d_xy_arrows( int radius );
int get_mouse_code( int x, int y );
/* Float array is either a single float (for single-axis controls),
or two floats for X and Y (if an XY controller) */
float get_z( void ) { return float_array_val[0]; }
float get_x( void ) { return float_array_val[0]; }
float get_y( void ) {
if ( trans_type == GLUI_TRANSLATION_XY ) return float_array_val[1];
else return float_array_val[0];
}
void set_z( float val );
void set_x( float val );
void set_y( float val );
void set_one_val( float val, int index );
GLUI_Translation( void ) {
locked = GLUI_TRANSLATION_LOCK_NONE;
sprintf( name, "Translation: %p", this );
type = GLUI_CONTROL_TRANSLATION;
w = GLUI_MOUSE_INTERACTION_WIDTH;
h = GLUI_MOUSE_INTERACTION_HEIGHT;
can_activate = true;
live_type = GLUI_LIVE_FLOAT_ARRAY;
float_array_size = 0;
alignment = GLUI_ALIGN_CENTER;
trans_type = GLUI_TRANSLATION_XY;
scale_factor = 1.0;
quadObj = NULL;
trans_mouse_code = GLUI_TRANSLATION_MOUSE_NONE;
};
};
/********** Misc functions *********************/
int _glutBitmapWidthString( void *font, char *s );
void _glutBitmapString( void *font, const char *s );
/********** Our own callbacks for glut *********/
/* These are the callbacks that we pass to glut. They take
some action if necessary, then (possibly) call the user-level
glut callbacks.
*/
void glui_display_func( void );
void glui_reshape_func( int w, int h );
void glui_keyboard_func(unsigned char key, int x, int y);
void glui_special_func(int key, int x, int y);
void glui_mouse_func(int button, int state, int x, int y);
void glui_motion_func(int x, int y);
void glui_passive_motion_func(int x, int y);
void glui_entry_func(int state);
void glui_visibility_func(int state);
void glui_idle_func(void);
void glui_parent_window_reshape_func( int w, int h );
void glui_parent_window_keyboard_func(unsigned char key, int x, int y);
void glui_parent_window_mouse_func(int, int, int, int );
void glui_parent_window_special_func(int key, int x, int y);
#endif
Reference in a new issue Copy permalink