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

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

游戏引擎

开发平台：

Visual C++

glui.h：源码内容
  1. /****************************************************************************
  3.   GLUI User Interface Toolkit (LGPL)
  4.   ----------------------------------
  6.      glui.h - Main (and only) external header for 
  7.         GLUI User Interface Toolkit
  9.           --------------------------------------------------
  11.   Copyright (c) 1998 Paul Rademacher
  13.   WWW:    http://sourceforge.net/projects/glui/
  14.   Forums: http://sourceforge.net/forum/?group_id=92496
  16.   This library is free software; you can redistribute it and/or
  17.   modify it under the terms of the GNU Lesser General Public
  18.   License as published by the Free Software Foundation; either
  19.   version 2.1 of the License, or (at your option) any later version.
  21.   This library is distributed in the hope that it will be useful,
  22.   but WITHOUT ANY WARRANTY; without even the implied warranty of
  23.   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  24.   Lesser General Public License for more details.
  26.   You should have received a copy of the GNU Lesser General Public
  27.   License along with this library; if not, write to the Free Software
  28.   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  30. *****************************************************************************/
  32. #ifndef GLUI_GLUI_H
  33. #define GLUI_GLUI_H
  35. #if defined(GLUI_FREEGLUT)
  37.   // FreeGLUT does not yet work perfectly with GLUI
  38.   //  - use at your own risk.
  39.   #include <GL/freeglut.h>
  41. #elif defined(GLUI_OPENGLUT)
  43.   // OpenGLUT does not yet work properly with GLUI
  44.   //  - use at your own risk.
  45.   
  46.   #include <GL/openglut.h>
  48. #else 
  50.   #ifdef __APPLE__
  51.   #include <GLUT/glut.h>
  52.   #else
  53. #include "../../freeglut/GL/glut.h"
  54.   //#include <GL/glut.h>
  55.   #endif
  57. #endif
  59. #include <cstdlib>
  60. #include <cstdio>
  61. #include <cstring>
  62. #include <string>
  63. #include <vector>
  65. #define GLUI_VERSION 2.3f    /********** Current version **********/
  67. #if defined(_WIN32)
  68. #if !defined(GLUI_NO_LIB_PRAGMA)
  69. //#pragma comment(lib, "glui32.lib")  // Link automatically with GLUI library
  70. #endif
  71. #endif
  73. /********** Do some basic defines *******/
  75. #ifndef Byte
  76. #define Byte unsigned char
  77. #endif
  79. #ifndef _RGBC_
  80. class RGBc {
  81. public:
  82.   Byte r, g, b;
  83.     
  84.   void set(Byte r,Byte g,Byte b) {this->r=r;this->g=g;this->b=b;}
  85.     
  86.   RGBc( void ) {}
  87.   RGBc( Byte r, Byte g, Byte b ) { set( r, g, b ); }
  88. };
  89. #define _RGBC_
  90. #endif
  92. /********** List of GLUT callbacks ********/
  94. enum GLUI_Glut_CB_Types 
  95. { 
  96.     GLUI_GLUT_RESHAPE,
  97.     GLUI_GLUT_KEYBOARD,
  98.     GLUI_GLUT_DISPLAY,
  99.     GLUI_GLUT_MOUSE,
  100.     GLUI_GLUT_MOTION,
  101.     GLUI_GLUT_SPECIAL,
  102.     GLUI_GLUT_PASSIVE_MOTION,  
  103.     GLUI_GLUT_ENTRY,
  104.     GLUI_GLUT_VISIBILITY  
  105. };
  107. /********* Constants for window placement **********/
  109. #define GLUI_XOFF                       6
  110. #define GLUI_YOFF                       6
  111. #define GLUI_ITEMSPACING                3
  112. #define GLUI_CHECKBOX_SIZE             13
  113. #define GLUI_RADIOBUTTON_SIZE          13
  114. #define GLUI_BUTTON_SIZE               20
  115. #define GLUI_STATICTEXT_SIZE           13
  116. #define GLUI_SEPARATOR_HEIGHT           8
  117. #define GLUI_DEFAULT_CONTROL_WIDTH    100
  118. #define GLUI_DEFAULT_CONTROL_HEIGHT    13 
  119. #define GLUI_EDITTEXT_BOXINNERMARGINX   3
  120. #define GLUI_EDITTEXT_HEIGHT           20
  121. #define GLUI_EDITTEXT_WIDTH           130
  122. #define GLUI_EDITTEXT_MIN_INT_WIDTH    35
  123. #define GLUI_EDITTEXT_MIN_TEXT_WIDTH   50
  124. #define GLUI_PANEL_NAME_DROP            8
  125. #define GLUI_PANEL_EMBOSS_TOP           4
  126. /* #define GLUI_ROTATION_WIDTH         60 */
  127. /* #define GLUI_ROTATION_HEIGHT        78 */
  128. #define GLUI_ROTATION_WIDTH            50
  129. #define GLUI_ROTATION_HEIGHT           (GLUI_ROTATION_WIDTH+18)
  130. #define GLUI_MOUSE_INTERACTION_WIDTH   50
  131. #define GLUI_MOUSE_INTERACTION_HEIGHT  (GLUI_MOUSE_INTERACTION_WIDTH)+18
  133. /** Different panel control types **/
  134. #define GLUI_PANEL_NONE      0
  135. #define GLUI_PANEL_EMBOSSED  1
  136. #define GLUI_PANEL_RAISED    2
  138. /**  Max # of els in control's float_array  **/
  139. #define GLUI_DEF_MAX_ARRAY  30
  141. /********* The control's 'active' behavior *********/
  142. #define GLUI_CONTROL_ACTIVE_MOUSEDOWN       1
  143. #define GLUI_CONTROL_ACTIVE_PERMANENT       2
  145. /********* Control alignment types **********/
  146. #define GLUI_ALIGN_CENTER   1
  147. #define GLUI_ALIGN_RIGHT    2
  148. #define GLUI_ALIGN_LEFT     3
  150. /********** Limit types - how to limit spinner values *********/
  151. #define GLUI_LIMIT_NONE    0
  152. #define GLUI_LIMIT_CLAMP   1
  153. #define GLUI_LIMIT_WRAP    2
  155. /********** Translation control types ********************/
  156. #define GLUI_TRANSLATION_XY 0
  157. #define GLUI_TRANSLATION_Z  1
  158. #define GLUI_TRANSLATION_X  2
  159. #define GLUI_TRANSLATION_Y  3
  161. #define GLUI_TRANSLATION_LOCK_NONE 0
  162. #define GLUI_TRANSLATION_LOCK_X    1
  163. #define GLUI_TRANSLATION_LOCK_Y    2
  165. /********** How was a control activated? *****************/
  166. #define GLUI_ACTIVATE_MOUSE 1
  167. #define GLUI_ACTIVATE_TAB   2
  169. /********** What type of live variable does a control have? **********/
  170. #define GLUI_LIVE_NONE          0
  171. #define GLUI_LIVE_INT           1
  172. #define GLUI_LIVE_FLOAT         2
  173. #define GLUI_LIVE_TEXT          3
  174. #define GLUI_LIVE_STRING        6
  175. #define GLUI_LIVE_DOUBLE        4
  176. #define GLUI_LIVE_FLOAT_ARRAY   5
  178. /************* Textbox and List Defaults - JVK ******************/
  179. #define GLUI_TEXTBOX_HEIGHT          130
  180. #define GLUI_TEXTBOX_WIDTH           130
  181. #define GLUI_LIST_HEIGHT             130
  182. #define GLUI_LIST_WIDTH              130
  183. #define GLUI_DOUBLE_CLICK              1
  184. #define GLUI_SINGLE_CLICK              0
  185. #define GLUI_TAB_WIDTH                50 /* In pixels */
  186. #define GLUI_TEXTBOX_BOXINNERMARGINX   3
  187. #define GLUI_TEXTBOX_MIN_TEXT_WIDTH   50
  188. #define GLUI_LIST_BOXINNERMARGINX      3
  189. #define GLUI_LIST_MIN_TEXT_WIDTH      50
  191. /*********************** TreePanel Defaults - JVK *****************************/
  192. #define GLUI_TREEPANEL_DEFAULTS               0 // bar, standard bar color
  193. #define GLUI_TREEPANEL_ALTERNATE_COLOR        1 // Alternate between 8 different bar colors
  194. #define GLUI_TREEPANEL_ENABLE_BAR             2 // enable the bar
  195. #define GLUI_TREEPANEL_DISABLE_BAR            4 // disable the bar
  196. #define GLUI_TREEPANEL_DISABLE_DEEPEST_BAR    8 // disable only the deepest bar
  197. #define GLUI_TREEPANEL_CONNECT_CHILDREN_ONLY 16 // disable only the bar of the last child of each root
  198. #define GLUI_TREEPANEL_DISPLAY_HIERARCHY     32 // display some sort of hierachy in the tree node title
  199. #define GLUI_TREEPANEL_HIERARCHY_NUMERICDOT  64 // display hierarchy in 1.3.2 (etc... ) format
  200. #define GLUI_TREEPANEL_HIERARCHY_LEVEL_ONLY 128 // display hierarchy as only the level depth
  201.  
  202. /******************* GLUI Scrollbar Defaults - JVK ***************************/
  203. #define  GLUI_SCROLL_ARROW_WIDTH     16
  204. #define  GLUI_SCROLL_ARROW_HEIGHT    16
  205. #define  GLUI_SCROLL_BOX_MIN_HEIGHT   5
  206. #define  GLUI_SCROLL_BOX_STD_HEIGHT  16
  207. #define  GLUI_SCROLL_STATE_NONE       0
  208. #define  GLUI_SCROLL_STATE_UP         1
  209. #define  GLUI_SCROLL_STATE_DOWN       2
  210. #define  GLUI_SCROLL_STATE_BOTH       3
  211. #define  GLUI_SCROLL_STATE_SCROLL     4
  212. #define  GLUI_SCROLL_DEFAULT_GROWTH_EXP   1.05f
  213. #define  GLUI_SCROLL_VERTICAL         0
  214. #define  GLUI_SCROLL_HORIZONTAL       1
  217. /** Size of the character width hash table for faster lookups. 
  218.   Make sure to keep this a power of two to avoid the slow divide.
  219.   This is also a speed/memory tradeoff; 128 is enough for low ASCII.
  220. */
  221. #define CHAR_WIDTH_HASH_SIZE 128
  223. /**********  Translation codes  **********/
  225. enum TranslationCodes  
  226. {
  227.     GLUI_TRANSLATION_MOUSE_NONE = 0,
  228.     GLUI_TRANSLATION_MOUSE_UP,
  229.     GLUI_TRANSLATION_MOUSE_DOWN,
  230.     GLUI_TRANSLATION_MOUSE_LEFT,
  231.     GLUI_TRANSLATION_MOUSE_RIGHT,
  232.     GLUI_TRANSLATION_MOUSE_UP_LEFT,
  233.     GLUI_TRANSLATION_MOUSE_UP_RIGHT,
  234.     GLUI_TRANSLATION_MOUSE_DOWN_LEFT,
  235.     GLUI_TRANSLATION_MOUSE_DOWN_RIGHT
  236. };
  238. /************ A string type for us to use **********/
  240. typedef std::string GLUI_String;
  241. GLUI_String& glui_format_str(GLUI_String &str, const char* fmt, ...);
  243. /********* Pre-declare classes as needed *********/
  245. class GLUI;
  246. class GLUI_Control;
  247. class GLUI_Listbox;
  248. class GLUI_StaticText;
  249. class GLUI_EditText;
  250. class GLUI_Panel;
  251. class GLUI_Spinner;
  252. class GLUI_RadioButton;
  253. class GLUI_RadioGroup;
  254. class GLUI_Glut_Window;
  255. class GLUI_TreePanel;
  256. class GLUI_Scrollbar;
  257. class GLUI_List;
  259. class Arcball;
  261. /*** Flags for GLUI class constructor ***/
  262. #define  GLUI_SUBWINDOW          ((long)(1<<1))
  263. #define  GLUI_SUBWINDOW_TOP      ((long)(1<<2))
  264. #define  GLUI_SUBWINDOW_BOTTOM   ((long)(1<<3))
  265. #define  GLUI_SUBWINDOW_LEFT     ((long)(1<<4))
  266. #define  GLUI_SUBWINDOW_RIGHT    ((long)(1<<5))
  268. /*** Codes for different type of edittext boxes and spinners ***/
  269. #define GLUI_EDITTEXT_TEXT             1
  270. #define GLUI_EDITTEXT_INT              2
  271. #define GLUI_EDITTEXT_FLOAT            3
  272. #define GLUI_SPINNER_INT               GLUI_EDITTEXT_INT
  273. #define GLUI_SPINNER_FLOAT             GLUI_EDITTEXT_FLOAT
  274. #define GLUI_SCROLL_INT                GLUI_EDITTEXT_INT
  275. #define GLUI_SCROLL_FLOAT              GLUI_EDITTEXT_FLOAT
  276. // This is only for deprecated interface
  277. #define GLUI_EDITTEXT_STRING           4
  279. /*** Definition of callbacks ***/
  280. typedef void (*GLUI_Update_CB) (int id);
  281. typedef void (*GLUI_Control_CB)(GLUI_Control *);
  282. typedef void (*Int1_CB)        (int);
  283. typedef void (*Int2_CB)        (int, int);
  284. typedef void (*Int3_CB)        (int, int, int);
  285. typedef void (*Int4_CB)        (int, int, int, int);
  287. /************************************************************/
  288. /**
  289.  Callback Adapter Class                            
  290.     Allows us to support different types of callbacks;
  291.     like a GLUI_Update_CB function pointer--which takes an int;
  292.     and a GLUI_Control_CB function pointer--which takes a GUI_Control object.
  293. */
  294. class GLUI_CB
  295. {
  296. public:
  297.   GLUI_CB() : idCB(0),objCB(0) {}
  298.   GLUI_CB(GLUI_Update_CB cb) : idCB(cb),objCB(0) {}
  299.   GLUI_CB(GLUI_Control_CB cb) : idCB(0),objCB(cb) {}
  300.   // (Compiler generated copy constructor)
  302.   /** This control just activated.  Fire our callback.*/
  303.   void operator()(GLUI_Control *ctrl) const;
  304.   bool operator!() const { return !idCB && !objCB; }
  305.   operator bool() const { return !(!(*this)); }
  306. private:
  307.   GLUI_Update_CB idCB;
  308.   GLUI_Control_CB objCB;
  309. };
  311. /************************************************************/
  312. /*                                                          */
  313. /*          Base class, for hierarchical relationships      */
  314. /*                                                          */
  315. /************************************************************/
  317. class GLUI_Control;
  319. /**
  320.  GLUI_Node is a node in a sort of tree of GLUI controls.
  321.  Each GLUI_Node has a list of siblings (in a circular list)
  322.  and a linked list of children.
  323.  
  324.  Everything onscreen is a GLUI_Node--windows, buttons, etc.
  325.  The nodes are traversed for event processing, sizing, redraws, etc.
  326. */
  327. class GLUI_Node 
  328. {
  329.     friend class GLUI_Tree;     /* JVK */
  330.     friend class GLUI_Rollout;
  331.     friend class GLUI_Main;
  333. public:
  334.     GLUI_Node();
  335.     virtual ~GLUI_Node() {}
  337.     GLUI_Node *first_sibling();
  338.     GLUI_Node *last_sibling();
  339.     GLUI_Node *prev();
  340.     GLUI_Node *next();
  342.     GLUI_Node *first_child()   { return child_head; }
  343.     GLUI_Node *last_child()    { return child_tail; }
  344.     GLUI_Node *parent()        { return parent_node; }
  346.     /** Link in a new child control */
  347.     virtual int  add_control( GLUI_Control *control );
  349.     void link_this_to_parent_last (GLUI_Node *parent  );
  350.     void link_this_to_parent_first(GLUI_Node *parent  );
  351.     void link_this_to_sibling_next(GLUI_Node *sibling );
  352.     void link_this_to_sibling_prev(GLUI_Node *sibling );
  353.     void unlink();
  355.     void dump( FILE *out, const char *name );
  357. protected:
  358.     static void add_child_to_control(GLUI_Node *parent,GLUI_Control *child);
  359.     GLUI_Node *parent_node;
  360.     GLUI_Node *child_head;
  361.     GLUI_Node *child_tail;
  362.     GLUI_Node *next_sibling;
  363.     GLUI_Node *prev_sibling;
  364. };
  367. /************************************************************/
  368. /*                                                          */
  369. /*                  Standard Bitmap stuff                   */
  370. /*                                                          */
  371. /************************************************************/
  373. enum GLUI_StdBitmaps_Codes 
  374. {
  375.     GLUI_STDBITMAP_CHECKBOX_OFF = 0,
  376.     GLUI_STDBITMAP_CHECKBOX_ON,
  377.     GLUI_STDBITMAP_RADIOBUTTON_OFF,
  378.     GLUI_STDBITMAP_RADIOBUTTON_ON,
  379.     GLUI_STDBITMAP_UP_ARROW,
  380.     GLUI_STDBITMAP_DOWN_ARROW,
  381.     GLUI_STDBITMAP_LEFT_ARROW,
  382.     GLUI_STDBITMAP_RIGHT_ARROW,
  383.     GLUI_STDBITMAP_SPINNER_UP_OFF,
  384.     GLUI_STDBITMAP_SPINNER_UP_ON,
  385.     GLUI_STDBITMAP_SPINNER_DOWN_OFF,
  386.     GLUI_STDBITMAP_SPINNER_DOWN_ON,
  387.     GLUI_STDBITMAP_CHECKBOX_OFF_DIS,    /*** Disactivated control bitmaps ***/
  388.     GLUI_STDBITMAP_CHECKBOX_ON_DIS,
  389.     GLUI_STDBITMAP_RADIOBUTTON_OFF_DIS,
  390.     GLUI_STDBITMAP_RADIOBUTTON_ON_DIS,
  391.     GLUI_STDBITMAP_SPINNER_UP_DIS,
  392.     GLUI_STDBITMAP_SPINNER_DOWN_DIS,
  393.     GLUI_STDBITMAP_LISTBOX_UP,
  394.     GLUI_STDBITMAP_LISTBOX_DOWN,
  395.     GLUI_STDBITMAP_LISTBOX_UP_DIS,
  396.     GLUI_STDBITMAP_NUM_ITEMS
  397. };
  399. /************************************************************/
  400. /*                                                          */
  401. /*                  Class GLUI_Bitmap                       */
  402. /*                                                          */
  403. /************************************************************/
  405. /**
  406.  GLUI_Bitmap is a simple 2D texture map.  It's used
  407.  to represent small textures like checkboxes, arrows, etc.
  408.  via the GLUI_StdBitmaps class.
  409. */
  410. class GLUI_Bitmap 
  411. {
  412.     friend class GLUI_StdBitmaps;
  414. public:
  415.     GLUI_Bitmap();
  416.     ~GLUI_Bitmap();
  418.     /** Create bitmap from greyscale byte image */
  419.     void init_grey(unsigned char *array);
  420.     
  421.     /** Create bitmap from color int image */
  422.     void init(int *array);
  424. private:
  425.     /** RGB pixel data */
  426.     unsigned char *pixels;
  427.     int            w, h;
  428. };
  431. /************************************************************/
  432. /*                                                          */
  433. /*                  Class GLUI_StdBitmap                    */
  434. /*                                                          */
  435. /************************************************************/
  437. /**
  438.  Keeps an array of GLUI_Bitmap objects to represent all the 
  439.  images used in the UI: checkboxes, arrows, etc.
  440. */
  441. class GLUI_StdBitmaps
  442. {
  443. public:
  444.     GLUI_StdBitmaps(); 
  445.     ~GLUI_StdBitmaps();
  447.     /** Return the width (in pixels) of the n'th standard bitmap. */
  448.     int  width (int n) const;
  449.     /** Return the height (in pixels) of the n'th standard bitmap. */
  450.     int  height(int n) const;
  452.     /** Draw the n'th standard bitmap (one of the enums
  453.        listed in GLUI_StdBitmaps_Codes) at pixel corner (x,y). 
  454.     */
  455.     void draw(int n, int x, int y) const;
  457. private:
  458.     GLUI_Bitmap bitmaps[GLUI_STDBITMAP_NUM_ITEMS];
  459. };
  461. /************************************************************/
  462. /*                                                          */
  463. /*                     Master GLUI Class                    */
  464. /*                                                          */
  465. /************************************************************/
  467. /**
  468.  The master manages our interaction with GLUT.
  469.  There's only one GLUI_Master_Object.
  470. */
  471. class GLUI_Master_Object 
  472. {
  474.     friend void glui_idle_func();
  475.   
  476. public:
  478.     GLUI_Master_Object();
  479.     ~GLUI_Master_Object();
  481.     GLUI_Node     gluis;
  482.     GLUI_Control *active_control, *curr_left_button_glut_menu;
  483.     GLUI         *active_control_glui;
  484.     int           glui_id_counter;
  486.     GLUI_Glut_Window   *find_glut_window( int window_id );
  488.     void           set_glutIdleFunc(void (*f)(void));
  490.     /**************
  491.     void (*glut_keyboard_CB)(unsigned char, int, int);
  492.     void (*glut_reshape_CB)(int, int);
  493.     void (*glut_special_CB)(int, int, int);
  494.     void (*glut_mouse_CB)(int,int,int,int);
  496.     void (*glut_passive_motion_CB)(int,int);
  497.     void (*glut_visibility_CB)(int);
  498.     void (*glut_motion_CB)(int,int);
  499.     void (*glut_display_CB)(void);
  500.     void (*glut_entry_CB)(int);
  501.     **********/
  503.     void  set_left_button_glut_menu_control( GLUI_Control *control );
  505.     /********** GLUT callthroughs **********/
  506.     /* These are the glut callbacks that we do not handle */
  508.     void set_glutReshapeFunc (void (*f)(int width, int height));
  509.     void set_glutKeyboardFunc(void (*f)(unsigned char key, int x, int y));
  510.     void set_glutSpecialFunc (void (*f)(int key, int x, int y));
  511.     void set_glutMouseFunc   (void (*f)(int, int, int, int ));
  513.     void set_glutDisplayFunc(void (*f)(void)) {glutDisplayFunc(f);}
  514.     void set_glutTimerFunc(unsigned int millis, void (*f)(int value), int value)
  515.     { ::glutTimerFunc(millis,f,value);}
  516.     void set_glutOverlayDisplayFunc(void(*f)(void)){glutOverlayDisplayFunc(f);}
  517.     void set_glutSpaceballMotionFunc(Int3_CB f)  {glutSpaceballMotionFunc(f);}
  518.     void set_glutSpaceballRotateFunc(Int3_CB f)  {glutSpaceballRotateFunc(f);}
  519.     void set_glutSpaceballButtonFunc(Int2_CB f)  {glutSpaceballButtonFunc(f);}
  520.     void set_glutTabletMotionFunc(Int2_CB f)        {glutTabletMotionFunc(f);}
  521.     void set_glutTabletButtonFunc(Int4_CB f)        {glutTabletButtonFunc(f);}
  522.     /*    void set_glutWindowStatusFunc(Int1_CB f)        {glutWindowStatusFunc(f);} */
  523.     void set_glutMenuStatusFunc(Int3_CB f)            {glutMenuStatusFunc(f);}
  524.     void set_glutMenuStateFunc(Int1_CB f)              {glutMenuStateFunc(f);}
  525.     void set_glutButtonBoxFunc(Int2_CB f)              {glutButtonBoxFunc(f);}
  526.     void set_glutDialsFunc(Int2_CB f)                      {glutDialsFunc(f);}  
  527.   
  529.     GLUI          *create_glui( const char *name, long flags=0, int x=-1, int y=-1 ); 
  530.     GLUI          *create_glui_subwindow( int parent_window, long flags=0 );
  531.     GLUI          *find_glui_by_window_id( int window_id );
  532.     void           get_viewport_area( int *x, int *y, int *w, int *h );
  533.     void           auto_set_viewport();
  534.     void           close_all();
  535.     void           sync_live_all();
  537.     void           reshape();
  539.     float          get_version() { return GLUI_VERSION; }
  541.     void glui_setIdleFuncIfNecessary(void);
  543. private:
  544.     GLUI_Node     glut_windows;
  545.     void (*glut_idle_CB)(void);
  547.     void          add_cb_to_glut_window(int window,int cb_type,void *cb);
  548. };
  550. /**
  551.  This is the only GLUI_Master_Object in existence.
  552. */
  553. extern GLUI_Master_Object GLUI_Master;
  555. /************************************************************/
  556. /*                                                          */
  557. /*              Class for managing a GLUT window            */
  558. /*                                                          */
  559. /************************************************************/
  561. /**
  562.  A top-level window.  The GLUI_Master GLUT callback can route events
  563.  to the callbacks in this class, for arbitrary use by external users.
  564.  (see GLUI_Master_Object::set_glutKeyboardFunc).
  565.  
  566.  This entire approach seems to be superceded by the "subwindow" flavor
  567.  of GLUI.
  568. */
  569. class GLUI_Glut_Window : public GLUI_Node 
  570. {
  571. public:
  572.     GLUI_Glut_Window();
  574.     int    glut_window_id;
  576.     /*********** Pointers to GLUT callthrough functions *****/
  577.     void (*glut_keyboard_CB)(unsigned char, int, int);
  578.     void (*glut_special_CB)(int, int, int);
  579.     void (*glut_reshape_CB)(int, int);
  580.     void (*glut_passive_motion_CB)(int,int);
  581.     void (*glut_mouse_CB)(int,int,int,int);
  582.     void (*glut_visibility_CB)(int);
  583.     void (*glut_motion_CB)(int,int);
  584.     void (*glut_display_CB)(void);
  585.     void (*glut_entry_CB)(int);
  586. };
  588. /************************************************************/
  589. /*                                                          */
  590. /*       Main Window GLUI class (not user-level)            */
  591. /*                                                          */
  592. /************************************************************/
  594. /**
  595.   A GLUI_Main handles GLUT events for one window, routing them to the 
  596.   appropriate controls.  The central user-visible "GLUI" class 
  597.   inherits from this class; users should not allocate GLUT_Main objects.
  598.   
  599.   There's a separate GLUI_Main object for:
  600.    - Each top-level window with GUI stuff in it.
  601. - Each "subwindow" of another top-level window.
  603.   All the GLUI_Main objects are listed in GLUI_Master.gluis.
  604.   A better name for this class might be "GLUI_Environment";
  605.   this class provides the window-level context for every control.
  606. */
  607. class GLUI_Main : public GLUI_Node 
  608. {
  609.     /********** Friend classes *************/
  611.     friend class GLUI_Control;
  612.     friend class GLUI_Rotation;
  613.     friend class GLUI_Translation;
  614.     friend class GLUI;
  615.     friend class GLUI_Master_Object;
  617.     /*********** Friend functions **********/
  619.     friend void glui_mouse_func(int button, int state, int x, int y);
  620.     friend void glui_keyboard_func(unsigned char key, int x, int y);
  621.     friend void glui_special_func(int key, int x, int y);
  622.     friend void glui_passive_motion_func(int x, int y);
  623.     friend void glui_reshape_func( int w, int h );
  624.     friend void glui_visibility_func(int state);
  625.     friend void glui_motion_func(int x, int y);
  626.     friend void glui_entry_func(int state);
  627.     friend void glui_display_func( void );
  628.     friend void glui_idle_func(void);
  630.     friend void glui_parent_window_reshape_func( int w, int h );
  631.     friend void glui_parent_window_keyboard_func( unsigned char, int, int );
  632.     friend void glui_parent_window_special_func( int, int, int );
  633.     friend void glui_parent_window_mouse_func( int, int, int, int );
  635. protected:
  636.     /*** Variables ***/
  637.     int           main_gfx_window_id;
  638.     int           mouse_button_down;
  639.     int           glut_window_id;
  640.     int           top_level_glut_window_id;
  641.     GLUI_Control *active_control;
  642.     GLUI_Control *mouse_over_control;
  643.     GLUI_Panel   *main_panel;
  644.     enum buffer_mode_t {
  645.       buffer_front=1, ///< Draw updated controls directly to screen.
  646.       buffer_back=2   ///< Double buffering: postpone updates until next redraw.
  647.     };
  648.     buffer_mode_t buffer_mode; ///< Current drawing mode
  649.     int           curr_cursor;
  650.     int           w, h;
  651.     long          flags; 
  652.     bool          closing;
  653.     int           parent_window;
  654.     int           glui_id;
  656.     /********** Misc functions *************/
  658.     GLUI_Control  *find_control( int x, int y );
  659.     GLUI_Control  *find_next_control( GLUI_Control *control );
  660.     GLUI_Control  *find_next_control_rec( GLUI_Control *control );
  661.     GLUI_Control  *find_next_control_( GLUI_Control *control );
  662.     GLUI_Control  *find_prev_control( GLUI_Control *control );
  663.     void           create_standalone_window( const char *name, int x=-1, int y=-1 );
  664.     void           create_subwindow( int parent,int window_alignment );
  665.     void           setup_default_glut_callbacks( void );
  667.     void           mouse(int button, int state, int x, int y);
  668.     void           keyboard(unsigned char key, int x, int y);
  669.     void           special(int key, int x, int y);
  670.     void           passive_motion(int x, int y);
  671.     void           reshape( int w, int h );
  672.     void           visibility(int state);
  673.     void           motion(int x, int y);
  674.     void           entry(int state);
  675.     void           display( void );
  676.     void           idle(void);
  677.     int            needs_idle(void);
  679.     void (*glut_mouse_CB)(int, int, int, int);
  680.     void (*glut_keyboard_CB)(unsigned char, int, int);
  681.     void (*glut_special_CB)(int, int, int);
  682.     void (*glut_reshape_CB)(int, int);
  685.     /*********** Controls ************/
  687.     virtual int    add_control( GLUI_Node *parent, GLUI_Control *control );
  690.     /********** Constructors and Destructors ***********/
  692.     GLUI_Main( void );
  694. public:
  695.     GLUI_StdBitmaps  std_bitmaps;
  696.     GLUI_String      window_name;
  697.     RGBc             bkgd_color;
  698.     float            bkgd_color_f[3];
  700.     void            *font;
  701.     int              curr_modifiers;
  703.     void         adjust_glut_xy( int &x, int &y ) { x; y = h-y; }
  704.     void         activate_control( GLUI_Control *control, int how );
  705.     void         align_controls( GLUI_Control *control );
  706.     void         deactivate_current_control( void );
  707.     
  708.     /** Draw a 3D-look pushed-out box around this rectangle */
  709.     void         draw_raised_box( int x, int y, int w, int h );
  710.     /** Draw a 3D-look pushed-in box around this rectangle */
  711.     void         draw_lowered_box( int x, int y, int w, int h );
  712.     
  713.     /** Return true if this control should redraw itself immediately (front buffer);
  714.        Or queue up a redraw and return false if it shouldn't (back buffer).
  715.     */
  716.     bool         should_redraw_now(GLUI_Control *ctl);
  717.     
  718.     /** Switch to the appropriate draw buffer now.  Returns the old draw buffer. 
  719.        This routine should probably only be called from inside the GLUI_DrawingSentinal,
  720.        in glui_internal_control.h
  721.     */
  722.     int          set_current_draw_buffer();
  723.     /** Go back to using this draw buffer.  Undoes set_current_draw_buffer. */
  724.     void         restore_draw_buffer( int buffer_state );
  725.     
  726.     /** Pack, resize the window, and redraw all the controls. */
  727.     void         refresh();
  728.     
  729.     /** Redraw the main graphics window */
  730.     void         post_update_main_gfx();
  731.   
  732.     /** Recompute the sizes and positions of all controls */
  733.     void         pack_controls();
  734.     
  735.     void         close_internal();
  736.     void         check_subwindow_position();
  737.     void         set_ortho_projection();
  738.     void         set_viewport();
  739.     int          get_glut_window_id( void ) { return glut_window_id; } /* JVK */
  740. };
  742. /************************************************************/
  743. /*                                                          */
  744. /*       GLUI_Control: base class for all controls          */
  745. /*                                                          */
  746. /************************************************************/
  748. /**
  749.  All the GUI objects inherit from GLUI_Control: buttons,
  750.  checkboxes, labels, edit boxes, scrollbars, etc.
  751.  Most of the work of this class is in routing events,
  752.  like keystrokes, mouseclicks, redraws, and sizing events.
  753.  
  754.  Yes, this is a huge and hideous class.  It needs to be 
  755.  split up into simpler subobjects.  None of the data members
  756.  should be directly accessed by users (they should be protected,
  757.  not public); only subclasses.
  758. */
  759. class GLUI_Control : public GLUI_Node 
  760. {
  761. public:
  763. /** Onscreen coordinates */
  764.     int             w, h;                        /* dimensions of control */
  765.     int             x_abs, y_abs;
  766.     int             x_off, y_off_top, y_off_bot; /* INNER margins, by which child
  767.                                                     controls are indented */
  768.     int             contain_x, contain_y; 
  769.     int             contain_w, contain_h;
  770.     /* if this is a container control (e.g., 
  771.        radiogroup or panel) this indicated dimensions
  772.        of inner area in which controls reside */
  774. /** "activation" for tabbing between controls. */
  775.     int             active_type; ///< "GLUI_CONTROL_ACTIVE_..."
  776.     bool            active;       ///< If true, we've got the focus
  777.     bool            can_activate; ///< If false, remove from tab order.
  778.     bool            spacebar_mouse_click; ///< Spacebar simulates click.
  779.     
  780. /** Callbacks */
  781.     long            user_id;  ///< Integer to pass to callback function.
  782.     GLUI_CB         callback; ///< User callback function, or NULL.
  784. /** Variable value storage */
  785.     float           float_val;        /**< Our float value */
  786.     int             int_val;          /**< Our integer value */
  787.     float           float_array_val[GLUI_DEF_MAX_ARRAY];
  788.     int             float_array_size;
  789.     GLUI_String     text;       /**< The text inside this control */
  790.     
  791. /** "Live variable" updating */
  792.     void           *ptr_val;          /**< A pointer to the user's live variable value */
  793.     int             live_type;
  794.     bool            live_inited;
  795.     /* These variables store the last value that live variable was known to have. */
  796.     int             last_live_int;  
  797.     float           last_live_float;
  798.     GLUI_String     last_live_text;
  799.     float           last_live_float_array[GLUI_DEF_MAX_ARRAY];
  800.     
  801. /** Properties of our control */    
  802.     GLUI           *glui;       /**< Our containing event handler (NEVER NULL during event processing!) */
  803.     bool            is_container;  /**< Is this a container class (e.g., panel) */
  804.     int             alignment;
  805.     bool            enabled;    /**< Is this control grayed out? */
  806.     GLUI_String     name;       /**< The name of this control */
  807.     void           *font;       /**< Our glutbitmap font */
  808.     bool            collapsible, is_open;
  809.     GLUI_Node       collapsed_node;
  810.     bool            hidden; /* Collapsed controls (and children) are hidden */
  811.     int             char_widths[CHAR_WIDTH_HASH_SIZE][2]; /* Character width hash table */
  813. public:
  814.     /*** Get/Set values ***/
  815.     virtual void   set_name( const char *string );
  816.     virtual void   set_int_val( int new_int )         { int_val = new_int; output_live(true); }
  817.     virtual void   set_float_val( float new_float )   { float_val = new_float; output_live(true); }
  818.     virtual void   set_ptr_val( void *new_ptr )       { ptr_val = new_ptr; output_live(true); }
  819.     virtual void   set_float_array_val( float *array_ptr );
  821.     virtual float  get_float_val( void )              { return float_val; }
  822.     virtual int    get_int_val( void )                { return int_val; }
  823.     virtual void   get_float_array_val( float *array_ptr );
  824.     virtual int    get_id( void ) const { return user_id; }
  825.     virtual void   set_id( int id ) { user_id=id; }
  827.     virtual int mouse_down_handler( int local_x, int local_y )                 { local_x; local_y; return false; }
  828.     virtual int mouse_up_handler( int local_x, int local_y, bool inside )       { local_x; local_y; inside; return false; }
  829.     virtual int mouse_held_down_handler( int local_x, int local_y, bool inside) { local_x; local_y; inside; return false; }
  830.     virtual int key_handler( unsigned char key, int modifiers )                { key; modifiers; return false; }
  831.     virtual int special_handler( int key,int modifiers )                       { key; modifiers; return false; }
  833.     virtual void update_size( void )     { }
  834.     virtual void idle( void )            { }
  835.     virtual int  mouse_over( int state, int x, int y ) { state; x; y; return false; }
  837.     virtual void enable( void ); 
  838.     virtual void disable( void );
  839.     virtual void activate( int how )     { how; active = true; }
  840.     virtual void deactivate( void )     { active = false; }
  842.     /** Hide (shrink into a rollout) and unhide (expose from a rollout) */
  843.     void         hide_internal( int recurse );
  844.     void         unhide_internal( int recurse );
  846.     /** Return true if it currently makes sense to draw this class. */
  847.     int          can_draw( void ) { return (glui != NULL && hidden == false); }
  849.     /** Redraw this control.
  850.        In single-buffering mode (drawing to GL_FRONT), this is just 
  851.            a call to translate_and_draw_front (after a can_draw() check).
  852.        In double-buffering mode (drawing to GL_BACK), this queues up 
  853.           a redraw and returns false, since you shouldn't draw yet.
  854.     */
  855.     void          redraw(void);
  856.     
  857.     /** Redraw everybody in our window. */
  858.     void         redraw_window(void);
  860.     virtual void align( void );
  861.     void         pack( int x, int y );    /* Recalculate positions and offsets */
  862.     void         pack_old( int x, int y );    
  863.     void         draw_recursive( int x, int y );
  864.     int          set_to_glut_window( void );
  865.     void         restore_window( int orig );
  866.     void         translate_and_draw_front( void );
  867.     void         translate_to_origin( void ) 
  868.     {glTranslatef((float)x_abs+.5f,(float)y_abs+.5f,0.0f);}
  869.     virtual void draw( int x, int y )=0;
  870.     void         set_font( void *new_font );
  871.     void        *get_font( void );
  872.     int          string_width( const char *text );
  873.     int          string_width( const GLUI_String &str ) 
  874.     { return string_width(str.c_str()); }
  875.     int          char_width( char c );
  877.     void         draw_name( int x, int y );
  878.     void         draw_box_inwards_outline( int x_min, int x_max, 
  879.                                            int y_min, int y_max );
  880.     void         draw_box( int x_min, int x_max, int y_min, int y_max,
  881.                            float r, float g, float b );
  882.     void         draw_bkgd_box( int x_min, int x_max, int y_min, int y_max );
  883.     void         draw_emboss_box( int x_min, int x_max,int y_min,int y_max);
  884.     void         draw_string( const char *text );
  885.     void         draw_string( const GLUI_String &s ) 
  886.     { draw_string(s.c_str()); }
  887.     void         draw_char( char c );
  888.     void         draw_active_box( int x_min, int x_max, int y_min, int y_max );
  889.     void         set_to_bkgd_color( void );
  891.     void         set_w( int new_w );
  892.     void         set_h( int new_w );
  893.     void         set_alignment( int new_align );
  894.     void         sync_live( int recurse, int draw );  /* Reads live variable */
  895.     void         init_live( void );
  896.     void         output_live( int update_main_gfx );        /** Writes live variable **/
  897.     virtual void set_text( const char *t )   { t; }
  898.     void         execute_callback( void );
  899.     void         get_this_column_dims( int *col_x, int *col_y, 
  900.                                        int *col_w, int *col_h, 
  901.                                        int *col_x_off, int *col_y_off );
  902.     virtual bool needs_idle( void ) const;
  903.     virtual bool wants_tabs() const      { return false; }
  905.     GLUI_Control(void) 
  906.     {
  907.         x_off          = GLUI_XOFF;
  908.         y_off_top      = GLUI_YOFF;
  909.         y_off_bot      = GLUI_YOFF;
  910.         x_abs          = GLUI_XOFF;
  911.         y_abs          = GLUI_YOFF;
  912.         active         = false;
  913.         enabled        = true;
  914.         int_val        = 0;
  915.         last_live_int  = 0;
  916.         float_array_size = 0;
  917.         glui_format_str(name, "Control: %p", this);
  918.         float_val      = 0.0;
  919.         last_live_float = 0.0;
  920.         ptr_val        = NULL;
  921.         glui           = NULL;
  922.         w              = GLUI_DEFAULT_CONTROL_WIDTH;
  923.         h              = GLUI_DEFAULT_CONTROL_HEIGHT;
  924.         font           = NULL;
  925.         active_type    = GLUI_CONTROL_ACTIVE_MOUSEDOWN;
  926.         alignment      = GLUI_ALIGN_LEFT;
  927.         is_container   = false;
  928.         can_activate   = true;         /* By default, you can activate a control */
  929.         spacebar_mouse_click = true;    /* Does spacebar simulate a mouse click? */
  930.         live_type      = GLUI_LIVE_NONE;
  931.         text = "";
  932.         last_live_text == "";
  933.         live_inited    = false;
  934.         collapsible    = false;
  935.         is_open        = true;
  936.         hidden         = false;
  937.         memset(char_widths, -1, sizeof(char_widths)); /* JVK */
  938.         int i;
  939.         for( i=0; i<GLUI_DEF_MAX_ARRAY; i++ )
  940.             float_array_val[i] = last_live_float_array[i] = 0.0;
  941.     }
  943.     virtual ~GLUI_Control();
  944. };
  946. /************************************************************/
  947. /*                                                          */
  948. /*               Button class (container)                   */
  949. /*                                                          */
  950. /************************************************************/
  951. /**
  952.   An onscreen, clickable button--an outlined label that 
  953.   can be clicked.  When clicked, a button
  954.   calls its GLUI_CB callback with its ID.
  955. */
  956. class GLUI_Button : public GLUI_Control
  957. {
  958. public:
  959.     bool currently_inside;
  961.     int  mouse_down_handler( int local_x, int local_y );
  962.     int  mouse_up_handler( int local_x, int local_y, bool inside );
  963.     int  mouse_held_down_handler( int local_x, int local_y, bool inside );
  964.     int  key_handler( unsigned char key,int modifiers );
  966.     void draw( int x, int y );
  967.     void draw_pressed( void );
  968.     void draw_text( int sunken );
  970.     void update_size( void );
  972. /**
  973.  Create a new button.
  974.  
  975.   @param parent The panel our object is inside; or the main GLUI object.
  976.   @param name The text inside the button.
  977.   @param id Optional ID number, to pass to the optional callback function.
  978.   @param callback Optional callback function, taking either the int ID or control.
  979. */
  980.     GLUI_Button( GLUI_Node *parent, const char *name, 
  981.                  int id=-1, GLUI_CB cb=GLUI_CB() );
  982.     GLUI_Button( void ) { common_init(); };
  984. protected:
  985.     void common_init(void) {
  986.         glui_format_str(name, "Button: %p", this );
  987.         h            = GLUI_BUTTON_SIZE;
  988.         w            = 100;
  989.         alignment    = GLUI_ALIGN_CENTER;
  990.         can_activate = true;
  991.     }
  992. };
  995. /************************************************************/
  996. /*                                                          */
  997. /*               Checkbox class (container)                 */
  998. /*                                                          */
  999. /************************************************************/
  1001. /**
  1002.  A checkbox, which can be checked on or off.  Can be linked
  1003.  to an int value, which gets 1 for on and 0 for off.
  1004. */
  1005. class GLUI_Checkbox : public GLUI_Control
  1006. {
  1007. public:
  1008.     int  orig_value;
  1009.     bool currently_inside;
  1010.     int  text_x_offset;
  1012.     int  mouse_down_handler( int local_x, int local_y );
  1013.     int  mouse_up_handler( int local_x, int local_y, bool inside );
  1014.     int  mouse_held_down_handler( int local_x, int local_y, bool inside );
  1015.     int  key_handler( unsigned char key,int modifiers );
  1017.     void update_size( void );
  1019.     void draw( int x, int y );
  1021.     void draw_active_area( void );
  1022.     void draw_empty_box( void );
  1023.     void set_int_val( int new_val );
  1025. /**
  1026.  Create a new checkbox object.
  1027.  
  1028.   @param parent The panel our object is inside; or the main GLUI object.
  1029.   @param name Label next to our checkbox.
  1030.   @param value_ptr Optional integer value to attach to this checkbox.  When the 
  1031.      checkbox is checked or unchecked, *value_ptr will also be changed. ("Live Vars").
  1032.   @param id Optional ID number, to pass to the optional callback function.
  1033.   @param callback Optional callback function, taking either the int ID or control.
  1034. */
  1035.     GLUI_Checkbox(GLUI_Node *parent, const char *name, int *value_ptr=NULL,
  1036.                   int id=-1, GLUI_CB callback=GLUI_CB());
  1037.     GLUI_Checkbox( void ) { common_init(); }
  1039. protected:
  1040.     void common_init(void) {
  1041.         glui_format_str( name, "Checkbox: %p", this );
  1042.         w              = 100;
  1043.         h              = GLUI_CHECKBOX_SIZE;
  1044.         orig_value     = -1;
  1045.         text_x_offset  = 18;
  1046.         can_activate   = true;
  1047.         live_type      = GLUI_LIVE_INT;   /* This control has an 'int' live var */
  1048.     }
  1049. };
  1051. /************************************************************/
  1052. /*                                                          */
  1053. /*               Column class                               */
  1054. /*                                                          */
  1055. /************************************************************/
  1057. /**
  1058.  A GLUI_Column object separates all previous controls
  1059.  from subsequent controls with a vertical bar.
  1060. */
  1061. class GLUI_Column : public GLUI_Control
  1062. {
  1063. public:
  1064.     void draw( int x, int y );
  1066. /**
  1067.  Create a new column, which separates the previous controls
  1068.  from subsequent controls.
  1069.  
  1070.   @param parent The panel our object is inside; or the main GLUI object.
  1071.   @param draw_bar If true, draw a visible bar between new and old controls.
  1072. */
  1073.     GLUI_Column( GLUI_Node *parent, int draw_bar = true );
  1074.     GLUI_Column( void ) { common_init(); }
  1076. protected:
  1077.     void common_init() {
  1078.         w            = 0;
  1079.         h            = 0;
  1080.         int_val      = 0;
  1081.         can_activate = false;
  1082.     }
  1083. };
  1086. /************************************************************/
  1087. /*                                                          */
  1088. /*               Panel class (container)                    */
  1089. /*                                                          */
  1090. /************************************************************/
  1092. /**
  1093.  A GLUI_Panel contains a group of related controls.
  1094. */
  1095. class GLUI_Panel : public GLUI_Control
  1096. {
  1097. public:
  1099. /**
  1100.  Create a new panel.  A panel groups together a set of related controls.
  1101.  
  1102.   @param parent The outer panel our panel is inside; or the main GLUI object.
  1103.   @param name The string name at the top of our panel.
  1104.   @param type Optional style to display the panel with--GLUI_PANEL_EMBOSSED by default.
  1105.       GLUI_PANEL_RAISED causes the panel to appear higher than the surroundings.
  1106.       GLUI_PANEL_NONE causes the panel's outline to be invisible.
  1107. */
  1108.     GLUI_Panel( GLUI_Node *parent, const char *name, 
  1109.                 int type=GLUI_PANEL_EMBOSSED );
  1110.     GLUI_Panel() { common_init(); }
  1112.     void draw( int x, int y );
  1113.     void set_name( const char *text );
  1114.     void set_type( int new_type );
  1116.     void update_size( void );
  1118. protected:
  1119.     void common_init( void ) {
  1120.         w            = 300;
  1121.         h            = GLUI_DEFAULT_CONTROL_HEIGHT + 7;
  1122.         int_val      = GLUI_PANEL_EMBOSSED;
  1123.         alignment    = GLUI_ALIGN_CENTER;
  1124.         is_container = true; 
  1125.         can_activate = false;
  1126.         name="";
  1127.     };
  1128. };
  1130. /************************************************************/
  1131. /*                                                          */
  1132. /*               File Browser class (container)             */
  1133. /*                         JVK                              */
  1134. /************************************************************/
  1136. /**
  1137.  A list of files the user can select from.
  1138. */
  1139. class GLUI_FileBrowser : public GLUI_Panel
  1140. {
  1141. public:
  1142. /**
  1143.  Create a new list of files the user can select from.
  1144.  
  1145.   @param parent The panel our object is inside; or the main GLUI object.
  1146.   @param name Prompt to give to the user at the top of the file browser.
  1147.   @param frame_type Optional style to display the panel with--GLUI_PANEL_EMBOSSED by default.
  1148.       GLUI_PANEL_RAISED causes the panel to appear higher than the surroundings.
  1149.       GLUI_PANEL_NONE causes the panel's outline to be invisible.
  1150.   @param id Optional ID number, to pass to the optional callback function.
  1151.   @param callback Optional callback function, taking either the int ID or control.
  1152. */
  1153.     GLUI_FileBrowser( GLUI_Node *parent, 
  1154.                       const char *name,
  1155.                       int frame_type = GLUI_PANEL_EMBOSSED,
  1156.                       int user_id = -1,
  1157.                       GLUI_CB callback = GLUI_CB());
  1159.     GLUI_List *list;
  1160.     GLUI_String current_dir;
  1162.     void fbreaddir(const char *);
  1163.     static void dir_list_callback(GLUI_Control*);
  1165.     void set_w(int w);
  1166.     void set_h(int h);
  1167.     const char* get_file() { return file.c_str(); }
  1168.     void set_allow_change_dir(int c) { allow_change_dir = c; }
  1170. protected:
  1171.     void common_init() 
  1172.     {
  1173.         w            = GLUI_DEFAULT_CONTROL_WIDTH;
  1174.         h            = GLUI_DEFAULT_CONTROL_HEIGHT;
  1175.         int_val      = GLUI_PANEL_EMBOSSED;
  1176.         alignment    = GLUI_ALIGN_CENTER;
  1177.         is_container = true; 
  1178.         can_activate = false;
  1179.         allow_change_dir = true;
  1180.         last_item    = -1;
  1181.         user_id      = -1;
  1182.         name         = "";
  1183.         current_dir  = ".";
  1184.         file         = "";
  1185.     };
  1187. private:
  1188.     int last_item;
  1189.     GLUI_String file;
  1190.     int allow_change_dir;
  1192. };
  1194. /************************************************************/
  1195. /*                                                          */
  1196. /*               Rollout class (container)                  */
  1197. /*                                                          */
  1198. /************************************************************/
  1199. /**
  1200.  A rollout contains a set of controls,
  1201.  like a panel, but can be collapsed to just the name.
  1202. */
  1203. class GLUI_Rollout : public GLUI_Panel
  1204. {
  1205. public:
  1207. /**
  1208.  Create a new rollout.  A rollout contains a set of controls,
  1209.  like a panel, but can be collapsed to just the name.
  1210.  
  1211.   @param parent The panel our object is inside; or the main GLUI object.
  1212.   @param name String to show at the top of the rollout.
  1213.   @param open Optional boolean.  If true (the default), the rollout's controls are displayed.
  1214.     If false, the rollout is closed to display only the name.
  1215.   @param type Optional style to display the panel with--GLUI_PANEL_EMBOSSED by default.
  1216.       GLUI_PANEL_RAISED causes the panel to appear higher than the surroundings.
  1217.       GLUI_PANEL_NONE causes the panel's outline to be invisible.
  1218. */
  1219.     GLUI_Rollout( GLUI_Node *parent, const char *name, int open=true, 
  1220.                   int type=GLUI_PANEL_EMBOSSED );
  1221.     GLUI_Rollout( void ) { common_init(); }
  1222.     
  1223.     
  1224.     bool        currently_inside, initially_inside;
  1225.     GLUI_Button  button;
  1227.     void draw( int x, int y );
  1228.     void draw_pressed( void );
  1229.     int mouse_down_handler( int local_x, int local_y );
  1230.     int mouse_up_handler( int local_x, int local_y, bool inside );
  1231.     int  mouse_held_down_handler( int local_x, int local_y, bool inside );
  1232.         
  1233.     void  open( void ); 
  1234.     void  close( void );
  1236.     void update_size( void );
  1238. protected:
  1239.     void common_init() {
  1240.         currently_inside = false;
  1241.         initially_inside = false;
  1242.         can_activate     = true;
  1243.         is_container     = true;
  1244.         h                = GLUI_DEFAULT_CONTROL_HEIGHT + 7;
  1245.         w                = GLUI_DEFAULT_CONTROL_WIDTH;
  1246.         y_off_top        = 21;
  1247.         collapsible      = true;
  1248.         name = "";
  1249.     }
  1250. };
  1252. /************************************************************/
  1253. /*                                                          */
  1254. /*               Tree    Panel class (container)            */
  1255. /*                         JVK                              */
  1256. /************************************************************/
  1258. /**
  1259.   One collapsible entry in a GLUI_TreePanel.
  1260. */
  1261. class GLUI_Tree : public GLUI_Panel
  1262. {
  1263. public:
  1264.     GLUI_Tree(GLUI_Node *parent, const char *name, 
  1265.               int open=false, int inset=0);
  1267. private:
  1268.     int level;   // how deep is this node
  1269.     float red;   //Color coding of column line
  1270.     float green;
  1271.     float blue;
  1272.     float lred;   //Color coding of level name
  1273.     float lgreen;
  1274.     float lblue;
  1275.     int id;
  1276.     GLUI_Column *column;
  1277.     int is_current;          // Whether this tree is the
  1278.     // current root in a treePanel
  1279.     int child_number;
  1280.     int format;
  1282. public:
  1283.     bool        currently_inside, initially_inside;
  1284.     GLUI_Button  button;
  1285.     GLUI_String  level_name; // level name, eg: 1.1.2, III, or 3
  1286.     GLUI_TreePanel *panel; 
  1288.     void draw( int x, int y );
  1289.     void draw_pressed( void );
  1290.     int mouse_down_handler( int local_x, int local_y );
  1291.     int mouse_up_handler( int local_x, int local_y, bool inside );
  1292.     int  mouse_held_down_handler( int local_x, int local_y, bool inside );
  1293.     void set_column(GLUI_Column *c) { column = c; }
  1294.     void  open( void ); 
  1295.     void  close( void );
  1297.     /*   void set_name( const char *text )   { panel.set_name( text ); }; */
  1298.     void update_size( void );
  1299.     void set_id(int i) { id = i; }
  1300.     void set_level(int l) { level = l; }
  1301.     void set_format(int f) { format = f; }
  1302.     void set_current(int c) { is_current = c; }
  1303.     int get_id() { return id; }
  1304.     int get_level() { return level; }
  1305.     int get_child_number() { return child_number; }
  1306.     void enable_bar() { if (column) { column->int_val = 1;  set_color(red, green, blue); } }
  1307.     void disable_bar() { if (column) { column->int_val = 0;  } } 
  1308.     void set_child_number(int c) { child_number = c; } 
  1309.     void set_level_color(float r, float g, float b) { 
  1310.         lred = r;
  1311.         lgreen = g;
  1312.         lblue  = b;
  1313.     }
  1314.     void set_color(float r, float g, float b) { 
  1315.         red = r;
  1316.         green = g;
  1317.         blue  = b;
  1318.     }
  1319. protected:
  1320.     void common_init()
  1321.     {
  1322.         currently_inside = false;
  1323.         initially_inside = false;
  1324.         can_activate     = true;
  1325.         is_container     = true;
  1326.         h                = GLUI_DEFAULT_CONTROL_HEIGHT + 7;
  1327.         w                = GLUI_DEFAULT_CONTROL_WIDTH;
  1328.         y_off_top        = 21;
  1329.         collapsible      = true;
  1330.         red              = .5;
  1331.         green            = .5;
  1332.         blue             = .5;
  1333.         lred             = 0;
  1334.         lgreen           = 0;
  1335.         lblue            = 0;
  1336.         column           = NULL;
  1337.         is_current       = 0;
  1338.         child_number     = 0;
  1339.         format           = 0;
  1340.         panel            = NULL;
  1341.         name             = "";
  1342.         level_name       = "";
  1343.         level            = 0;
  1344.     
  1345.     };
  1346. };
  1349. /************************************************************/
  1350. /*                                                          */
  1351. /*               TreePanel class (container) JVK            */
  1352. /*                                                          */
  1353. /************************************************************/
  1355. /**
  1356.   Manages, maintains, and formats a tree of GLUI_Tree objects.
  1357.   These are shown in a heirarchical, collapsible display.
  1358.   
  1359.   FIXME: There's an infinite loop in the traversal code (OSL 2006/06)
  1360. */
  1361. class GLUI_TreePanel : public GLUI_Panel 
  1362. {
  1363. public:
  1364.     GLUI_TreePanel(GLUI_Node *parent, const char *name,
  1365.                    bool open=false, int inset=0);
  1367.     int max_levels;
  1368.     int next_id;
  1369.     int format;
  1370.     float red;
  1371.     float green;
  1372.     float blue;
  1373.     float lred;
  1374.     float lgreen;
  1375.     float lblue;
  1376.     int root_children;
  1377.     /* These variables allow the tree panel to traverse the tree
  1378.        using only two function calls. (Well, four, if you count 
  1379.        going in reverse */
  1381.     GLUI_Tree    *curr_branch; /* Current Branch */
  1382.     GLUI_Panel *curr_root;   /* Current Root */
  1384. public:
  1385.     void            set_color(float r, float g, float b); 
  1386.     void            set_level_color(float r, float g, float b);
  1387.     void            set_format(int f) { format = f; }
  1389.     /* Adds branch to curr_root */
  1390.     GLUI_Tree *     ab(const char *name, GLUI_Tree *root = NULL);
  1391.     /* Goes up one level, resets curr_root and curr_branch to parents*/
  1392.     void            fb(GLUI_Tree *branch= NULL);
  1393.     /* Deletes the curr_branch, goes up one level using fb */
  1394.     void            db(GLUI_Tree *branch = NULL);
  1395.     /* Finds the very last branch of curr_root, resets vars */
  1396.     void            descendBranch(GLUI_Panel *root = NULL);
  1397.     /* Resets curr_root and curr branch to TreePanel and lastChild */
  1398.     void            resetToRoot(GLUI_Panel *new_root = NULL);
  1399.     void            next( void );
  1400.     void            refresh( void );
  1401.     void            expand_all( void );
  1402.     void            collapse_all( void );
  1403.     void            update_all( void );
  1404.     void            initNode(GLUI_Tree *temp);
  1405.     void            formatNode(GLUI_Tree *temp);
  1407. protected:
  1408.     int uniqueID( void ) { next_id++; return next_id - 1; }
  1409.     void common_init() 
  1410.     {
  1411.         GLUI_Panel();
  1412.         next_id = 0;
  1413.         curr_root = this;
  1414.         curr_branch = NULL;
  1415.         red = .5;
  1416.         green = .5;
  1417.         blue = .5;
  1418.         root_children = 0;
  1419.     }
  1420. };
  1422. /************************************************************/
  1423. /*                                                          */
  1424. /*                     User-Level GLUI class                */
  1425. /*                                                          */
  1426. /************************************************************/
  1428. class GLUI_Rotation;
  1429. class GLUI_Translation;
  1431. /**
  1432.  The main user-visible interface object to GLUI.
  1433.  
  1434. */
  1435. class GLUI : public GLUI_Main 
  1436. {
  1437. public:
  1438. /** DEPRECATED interface for creating new GLUI objects */
  1439.     int   add_control( GLUI_Control *control ) { return main_panel->add_control(control); }
  1441.     void  add_column( int draw_bar = true );
  1442.     void  add_column_to_panel( GLUI_Panel *panel, int draw_bar = true );
  1444.     void  add_separator( void );
  1445.     void  add_separator_to_panel( GLUI_Panel *panel );
  1447.     GLUI_RadioGroup 
  1448.     *add_radiogroup( int *live_var=NULL,
  1449.                      int user_id=-1,GLUI_CB callback=GLUI_CB());
  1451.     GLUI_RadioGroup 
  1452.     *add_radiogroup_to_panel(  GLUI_Panel *panel,
  1453.                                int *live_var=NULL,
  1454.                                int user_id=-1, GLUI_CB callback=GLUI_CB() );
  1455.     GLUI_RadioButton
  1456.     *add_radiobutton_to_group(  GLUI_RadioGroup *group,
  1457.                                 const char *name );
  1459.     GLUI_Listbox *add_listbox( const char *name, int *live_var=NULL,
  1460.                                int id=-1, GLUI_CB callback=GLUI_CB() );
  1461.     GLUI_Listbox *add_listbox_to_panel( GLUI_Panel *panel,
  1462.                                         const char *name, int *live_var=NULL,
  1463.                                         int id=-1, GLUI_CB callback=GLUI_CB());
  1465.     GLUI_Rotation *add_rotation( const char *name, float *live_var=NULL,
  1466.                                  int id=-1, GLUI_CB callback=GLUI_CB() );
  1467.     GLUI_Rotation *add_rotation_to_panel( GLUI_Panel *panel,
  1468.                                           const char *name, float *live_var=NULL,
  1469.                                           int id=-1, GLUI_CB callback=GLUI_CB());
  1470.   
  1471.     GLUI_Translation *add_translation( const char *name,
  1472.                                        int trans_type, float *live_var=NULL,
  1473.                                        int id=-1, GLUI_CB callback=GLUI_CB() );
  1474.     GLUI_Translation *add_translation_to_panel( 
  1475.         GLUI_Panel *panel, const char *name, 
  1476.         int trans_type, float *live_var=NULL,
  1477.         int id=-1, GLUI_CB callback=GLUI_CB());
  1478.   
  1479.     GLUI_Checkbox  *add_checkbox( const char *name, 
  1480.                                   int *live_var=NULL,
  1481.                                   int id=-1, GLUI_CB callback=GLUI_CB());
  1482.     GLUI_Checkbox  *add_checkbox_to_panel( GLUI_Panel *panel, const char *name, 
  1483.                                            int *live_var=NULL, int id=-1, 
  1484.                                            GLUI_CB callback=GLUI_CB());
  1486.     GLUI_Button  *add_button( const char *name, int id=-1, 
  1487.                               GLUI_CB callback=GLUI_CB());
  1488.     GLUI_Button  *add_button_to_panel( GLUI_Panel *panel, const char *name, 
  1489.                                        int id=-1, GLUI_CB callback=GLUI_CB() );
  1491.     GLUI_StaticText  *add_statictext( const char *name );
  1492.     GLUI_StaticText  *add_statictext_to_panel( GLUI_Panel *panel, const char *name );
  1494.     GLUI_EditText  *add_edittext( const char *name, 
  1495.                                   int data_type=GLUI_EDITTEXT_TEXT,
  1496.                                   void*live_var=NULL,
  1497.                                   int id=-1, GLUI_CB callback=GLUI_CB() );
  1498.     GLUI_EditText  *add_edittext_to_panel( GLUI_Panel *panel, 
  1499.                                            const char *name,
  1500.                                            int data_type=GLUI_EDITTEXT_TEXT,
  1501.                                            void *live_var=NULL, int id=-1, 
  1502.                                            GLUI_CB callback=GLUI_CB() );
  1503.     GLUI_EditText  *add_edittext( const char *name, GLUI_String& live_var, 
  1504.                                   int id=-1, GLUI_CB callback=GLUI_CB() );
  1505.     GLUI_EditText  *add_edittext_to_panel( GLUI_Panel *panel, const char *name, 
  1506.                                            GLUI_String& live_var, int id=-1,
  1507.                                            GLUI_CB callback=GLUI_CB() );
  1509.     GLUI_Spinner  *add_spinner( const char *name, 
  1510.                                 int data_type=GLUI_SPINNER_INT,
  1511.                                 void *live_var=NULL,
  1512.                                 int id=-1, GLUI_CB callback=GLUI_CB() );
  1513.     GLUI_Spinner  *add_spinner_to_panel( GLUI_Panel *panel, 
  1514.                                          const char *name,
  1515.                                          int data_type=GLUI_SPINNER_INT,
  1516.                                          void *live_var=NULL,
  1517.                                          int id=-1,
  1518.                                          GLUI_CB callback=GLUI_CB() );
  1520.     GLUI_Panel     *add_panel( const char *name, int type=GLUI_PANEL_EMBOSSED );
  1521.     GLUI_Panel     *add_panel_to_panel( GLUI_Panel *panel, const char *name, 
  1522.                                         int type=GLUI_PANEL_EMBOSSED );
  1525.     GLUI_Rollout   *add_rollout( const char *name, int open=true,
  1526.                                  int type=GLUI_PANEL_EMBOSSED);
  1527.     GLUI_Rollout   *add_rollout_to_panel( GLUI_Panel *panel, const char *name, 
  1528.                                           int open=true,
  1529.                                           int type=GLUI_PANEL_EMBOSSED);
  1532. /** Set the window where our widgets should be displayed. */
  1533.     void            set_main_gfx_window( int window_id );
  1534.     int             get_glut_window_id( void ) { return glut_window_id; }
  1536.     void            enable( void ) { main_panel->enable(); }
  1537.     void            disable( void );
  1539.     void            sync_live( void );
  1541.     void            close( void );
  1543.     void            show( void );
  1544.     void            hide( void );
  1546.     /***** GLUT callback setup functions *****/
  1547.     /*
  1548.       void set_glutDisplayFunc(void (*f)(void));
  1549.       void set_glutReshapeFunc(void (*f)(int width, int height));
  1550.       void set_glutKeyboardFunc(void (*f)(unsigned char key, int x, int y));
  1551.       void set_glutSpecialFunc(void (*f)(int key, int x, int y));
  1552.       void set_glutMouseFunc(void (*f)(int button, int state, int x, int y));
  1553.       void set_glutMotionFunc(void (*f)(int x, int y));
  1554.       void set_glutPassiveMotionFunc(void (*f)(int x, int y));
  1555.       void set_glutEntryFunc(void (*f)(int state));
  1556.       void set_glutVisibilityFunc(void (*f)(int state));
  1557.       void set_glutInit( int *argcp, const char **argv );
  1558.       void set_glutInitWindowSize(int width, int height);
  1559.       void set_glutInitWindowPosition(int x, int y);
  1560.       void set_glutInitDisplayMode(unsigned int mode);
  1561.       int  set_glutCreateWindow(const char *name);
  1562.     */
  1564.     /***** Constructors and desctructors *****/
  1566.     int init( const char *name, long flags, int x, int y, int parent_window );
  1567. protected:
  1568.     virtual int add_control( GLUI_Node *parent, GLUI_Control *control ) {
  1569.         return GLUI_Main::add_control( parent, control );
  1570.     }
  1571. };
  1573. /************************************************************/
  1574. /*                                                          */
  1575. /*               EditText class                             */
  1576. /*                                                          */
  1577. /************************************************************/
  1579. class GLUI_EditText : public GLUI_Control
  1580. {
  1581. public:
  1582.     int                 has_limits;
  1583.     int                 data_type;
  1584.     GLUI_String         orig_text;
  1585.     int                 insertion_pt;
  1586.     int                 title_x_offset;
  1587.     int                 text_x_offset;
  1588.     int                 substring_start; /*substring that gets displayed in box*/
  1589.     int                 substring_end;  
  1590.     int                 sel_start, sel_end;  /* current selection */
  1591.     int                 num_periods;
  1592.     int                 last_insertion_pt;
  1593.     float               float_low, float_high;
  1594.     int                 int_low, int_high;
  1595.     GLUI_Spinner       *spinner;
  1596.     int                 debug;
  1597.     int                 draw_text_only;
  1600.     int  mouse_down_handler( int local_x, int local_y );
  1601.     int  mouse_up_handler( int local_x, int local_y, bool inside );
  1602.     int  mouse_held_down_handler( int local_x, int local_y, bool inside );
  1603.     int  key_handler( unsigned char key,int modifiers );
  1604.     int  special_handler( int key, int modifiers );
  1606.     void activate( int how );
  1607.     void deactivate( void );
  1609.     void draw( int x, int y );
  1611.     int  mouse_over( int state, int x, int y );
  1613.     int  find_word_break( int start, int direction );
  1614.     int  substring_width( int start, int end );
  1615.     void clear_substring( int start, int end );
  1616.     int  find_insertion_pt( int x, int y );
  1617.     int  update_substring_bounds( void );
  1618.     void update_and_draw_text( void );
  1619.     void draw_text( int x, int y );
  1620.     void draw_insertion_pt( void );
  1621.     void set_numeric_text( void );
  1622.     void update_x_offsets( void );
  1623.     void update_size( void );
  1625.     void set_float_limits( float low,float high,int limit_type=GLUI_LIMIT_CLAMP);
  1626.     void set_int_limits( int low, int high, int limit_type=GLUI_LIMIT_CLAMP );
  1627.     void set_float_val( float new_val );
  1628.     void set_int_val( int new_val );
  1629.     void set_text( const char *text );
  1630.     void set_text( const GLUI_String &s) { set_text(s.c_str()); }
  1631.     const char *get_text()               { return text.c_str(); }
  1633.     void dump( FILE *out, const char *text );
  1635.     // Constructor, no live variable
  1636.     GLUI_EditText( GLUI_Node *parent, const char *name,
  1637.                    int text_type=GLUI_EDITTEXT_TEXT,
  1638.                    int id=-1, GLUI_CB callback=GLUI_CB() );
  1639.     // Constructor, int live variable
  1640.     GLUI_EditText( GLUI_Node *parent, const char *name,
  1641.                    int *live_var,
  1642.                    int id=-1, GLUI_CB callback=GLUI_CB() );
  1643.     // Constructor, float live variable
  1644.     GLUI_EditText( GLUI_Node *parent, const char *name,
  1645.                    float *live_var,
  1646.                    int id=-1, GLUI_CB callback=GLUI_CB() );
  1647.     // Constructor, char* live variable
  1648.     GLUI_EditText( GLUI_Node *parent, const char *name, 
  1649.                    char *live_var,
  1650.                    int id=-1, GLUI_CB callback=GLUI_CB() );
  1651.     // Constructor, std::string live variable
  1652.     GLUI_EditText( GLUI_Node *parent, const char *name, 
  1653.                    std::string &live_var,
  1654.                    int id=-1, GLUI_CB callback=GLUI_CB() );
  1656.     // Deprecated constructor, only called internally
  1657.     GLUI_EditText( GLUI_Node *parent, const char *name,
  1658.                    int text_type, void *live_var,
  1659.                    int id, GLUI_CB callback );
  1660.     // Deprecated constructor, only called internally
  1661.     GLUI_EditText( void ) { common_init(); }
  1663. protected:
  1664.     void common_init( void ) {
  1665.         h                     = GLUI_EDITTEXT_HEIGHT;
  1666.         w                     = GLUI_EDITTEXT_WIDTH;
  1667.         title_x_offset        = 0;
  1668.         text_x_offset         = 55;
  1669.         insertion_pt          = -1;
  1670.         last_insertion_pt     = -1;
  1671.         name                  = "";
  1672.         substring_start       = 0;
  1673.         data_type             = GLUI_EDITTEXT_TEXT;
  1674.         substring_end         = 2;
  1675.         num_periods           = 0;
  1676.         has_limits            = GLUI_LIMIT_NONE;
  1677.         sel_start             = 0;
  1678.         sel_end               = 0;
  1679.         active_type           = GLUI_CONTROL_ACTIVE_PERMANENT;
  1680.         can_activate          = true;
  1681.         spacebar_mouse_click  = false;
  1682.         spinner               = NULL;
  1683.         debug                 = false;
  1684.         draw_text_only        = false;
  1685.     }
  1686.     void common_construct( GLUI_Node *parent, const char *name, 
  1687.                            int data_type, int live_type, void *live_var,
  1688.                            int id, GLUI_CB callback );
  1689. };
  1691. /************************************************************/
  1692. /*                                                          */
  1693. /*               CommandLine class                          */
  1694. /*                                                          */
  1695. /************************************************************/
  1697. class GLUI_CommandLine : public GLUI_EditText
  1698. {
  1699. public:
  1700.     typedef GLUI_EditText Super;
  1702.     enum { HIST_SIZE = 100 };
  1703.     std::vector<GLUI_String> hist_list;
  1704.     int  curr_hist;
  1705.     int  oldest_hist;
  1706.     int  newest_hist;
  1707.     bool commit_flag;
  1709. public:
  1710.     int  key_handler( unsigned char key,int modifiers );
  1711.     int  special_handler( int key,int modifiers );
  1712.     void deactivate( void );
  1714.     virtual const char *get_history( int command_number ) const
  1715.     { return hist_list[command_number - oldest_hist].c_str(); }
  1716.     virtual GLUI_String& get_history_str( int command_number )
  1717.     { return hist_list[command_number - oldest_hist]; }
  1718.     virtual const GLUI_String& get_history_str( int command_number ) const
  1719.     { return hist_list[command_number - oldest_hist]; }
  1720.     virtual void recall_history( int history_number );
  1721.     virtual void scroll_history( int direction );
  1722.     virtual void add_to_history( const char *text );
  1723.     virtual void reset_history( void );
  1725.     void dump( FILE *out, const char *text );
  1728.     GLUI_CommandLine( GLUI_Node *parent, const char *name, void *live_var=NULL,
  1729.                       int id=-1, GLUI_CB callback=GLUI_CB() );
  1730.     GLUI_CommandLine( void ) { common_init(); }
  1731. protected:
  1732.     void common_init() {
  1733.         hist_list.resize(HIST_SIZE);
  1734.         curr_hist = 0;
  1735.         oldest_hist = 0;
  1736.         newest_hist = 0;
  1737.         commit_flag = false;
  1738.     }
  1739. };
  1741. /************************************************************/
  1742. /*                                                          */
  1743. /*              RadioGroup class (container)                */
  1744. /*                                                          */
  1745. /************************************************************/
  1747. class GLUI_RadioGroup : public GLUI_Control
  1748. {
  1749. public:
  1750.     int  num_buttons;
  1752.     void draw( int x, int y );
  1753.     void set_name( const char *text );
  1754.     void set_int_val( int int_val ); 
  1755.     void set_selected( int int_val );
  1757.     void draw_group( int translate );
  1759.     GLUI_RadioGroup( GLUI_Node *parent, int *live_var=NULL,
  1760.                      int user_id=-1,GLUI_CB callback=GLUI_CB() );
  1761.     GLUI_RadioGroup( void ) { common_init(); }
  1763. protected:
  1764.     void common_init( void ) {
  1765.         x_off         = 0;
  1766.         y_off_top     = 0;
  1767.         y_off_bot     = 0;
  1768.         is_container  = true;
  1769.         w             = 300;
  1770.         h             = 300;
  1771.         num_buttons   = 0;
  1772.         name          = "";
  1773.         can_activate  = false;
  1774.         live_type     = GLUI_LIVE_INT;
  1775.     }
  1776. };
  1778. /************************************************************/
  1779. /*                                                          */
  1780. /*               RadioButton class (container)              */
  1781. /*                                                          */
  1782. /************************************************************/
  1784. class GLUI_RadioButton : public GLUI_Control
  1785. {
  1786. public:
  1787.     int orig_value;
  1788.     bool currently_inside;
  1789.     int text_x_offset;
  1791.     int  mouse_down_handler( int local_x, int local_y );
  1792.     int  mouse_up_handler( int local_x, int local_y, bool inside );
  1793.     int  mouse_held_down_handler( int local_x, int local_y, bool inside );
  1795.     void draw( int x, int y );
  1796.     void update_size( void );
  1798.     void draw_active_area( void );
  1799.     void draw_checked( void );
  1800.     void draw_unchecked( void );
  1801.     void draw_O( void );
  1803.     GLUI_RadioButton( GLUI_RadioGroup *group, const char *name );
  1804.     GLUI_RadioGroup *group;
  1806. protected:
  1807.     void common_init()
  1808.     {
  1809.         glui_format_str( name, "RadioButton: %p", (void *) this );
  1810.         h              = GLUI_RADIOBUTTON_SIZE;
  1811.         group          = NULL;
  1812.         orig_value     = -1;
  1813.         text_x_offset  = 18;
  1814.         can_activate   = true;
  1815.     }
  1816. };
  1819. /************************************************************/
  1820. /*                                                          */
  1821. /*               Separator class (container)                */
  1822. /*                                                          */
  1823. /************************************************************/
  1825. class GLUI_Separator : public GLUI_Control
  1826. {
  1827. public:
  1828.     void draw( int x, int y );
  1830.     GLUI_Separator( GLUI_Node *parent );
  1831.     GLUI_Separator( void ) { common_init(); }
  1833. protected:
  1834.     void common_init() {
  1835.         w            = 100;
  1836.         h            = GLUI_SEPARATOR_HEIGHT;
  1837.         can_activate = false;
  1838.     }
  1839. };
  1841. #define  GLUI_SPINNER_ARROW_WIDTH   12
  1842. #define  GLUI_SPINNER_ARROW_HEIGHT   8
  1843. #define  GLUI_SPINNER_ARROW_Y        2
  1845. #define  GLUI_SPINNER_STATE_NONE     0
  1846. #define  GLUI_SPINNER_STATE_UP       1
  1847. #define  GLUI_SPINNER_STATE_DOWN     2
  1848. #define  GLUI_SPINNER_STATE_BOTH     3
  1850. #define  GLUI_SPINNER_DEFAULT_GROWTH_EXP   1.05f
  1852. /************************************************************/
  1853. /*                                                          */
  1854. /*               Spinner class (container)                  */
  1855. /*                                                          */
  1856. /************************************************************/
  1857.  
  1858. class GLUI_Spinner : public GLUI_Control
  1859. {
  1860. public:
  1861.     // Constructor, no live var
  1862.     GLUI_Spinner( GLUI_Node* parent, const char *name, 
  1863.                   int data_type=GLUI_SPINNER_INT, int id=-1, GLUI_CB callback=GLUI_CB() );
  1864.     // Constructor, int live var
  1865.     GLUI_Spinner( GLUI_Node* parent, const char *name, 
  1866.                   int *live_var, int id=-1, GLUI_CB callback=GLUI_CB() );
  1867.     // Constructor, float live var
  1868.     GLUI_Spinner( GLUI_Node* parent, const char *name, 
  1869.                   float *live_var, int id=-1, GLUI_CB callback=GLUI_CB() );
  1870.     // Deprecated constructor
  1871.     GLUI_Spinner( GLUI_Node* parent, const char *name, 
  1872.                   int data_type,
  1873.                   void *live_var,
  1874.                   int id=-1, GLUI_CB callback=GLUI_CB() );
  1875.     // Deprecated constructor
  1876.     GLUI_Spinner( void ) { common_init(); }
  1878.     bool          currently_inside;
  1879.     int           state;
  1880.     float         growth, growth_exp;
  1881.     int           last_x, last_y;
  1882.     int           data_type;
  1883.     int           callback_count;
  1884.     int           last_int_val;
  1885.     float         last_float_val;
  1886.     int           first_callback;
  1887.     float         user_speed;
  1889.     GLUI_EditText *edittext;
  1891.     int  mouse_down_handler( int local_x, int local_y );
  1892.     int  mouse_up_handler( int local_x, int local_y, bool inside );
  1893.     int  mouse_held_down_handler( int local_x, int local_y, bool inside );
  1894.     int  key_handler( unsigned char key,int modifiers );
  1895.     int  special_handler(   int key,int modifiers );
  1897.     void draw( int x, int y );
  1898.     void draw_pressed( void );
  1899.     void draw_unpressed( void );
  1900.     void draw_text( int sunken );
  1902.     void update_size( void );
  1904.     void set_float_limits( float low,float high,int limit_type=GLUI_LIMIT_CLAMP);
  1905.     void set_int_limits( int low, int high,int limit_type=GLUI_LIMIT_CLAMP);
  1906.     int  find_arrow( int local_x, int local_y );
  1907.     void do_drag( int x, int y );
  1908.     void do_callbacks( void );
  1909.     void do_click( void );
  1910.     void idle( void );
  1911.     bool needs_idle( void ) const;
  1913.     const char *get_text( void );
  1915.     void set_float_val( float new_val );
  1916.     void set_int_val( int new_val );
  1917.     float  get_float_val( void );
  1918.     int    get_int_val( void );
  1919.     void increase_growth( void );
  1920.     void reset_growth( void );
  1922.     void set_speed( float speed ) { user_speed = speed; }
  1924. protected:
  1925.     void common_init() {
  1926.         glui_format_str( name, "Spinner: %p", this );
  1927.         h            = GLUI_EDITTEXT_HEIGHT;
  1928.         w            = GLUI_EDITTEXT_WIDTH;
  1929.         x_off        = 0;
  1930.         y_off_top    = 0;
  1931.         y_off_bot    = 0;
  1932.         can_activate = true;
  1933.         state        = GLUI_SPINNER_STATE_NONE;
  1934.         edittext     = NULL;
  1935.         growth_exp   = GLUI_SPINNER_DEFAULT_GROWTH_EXP;
  1936.         callback_count = 0;
  1937.         first_callback = true;
  1938.         user_speed   = 1.0;
  1939.     }
  1940.     void common_construct( GLUI_Node* parent, const char *name, 
  1941.                            int data_type, void *live_var,
  1942.                            int id, GLUI_CB callback );
  1943. };
  1945. /************************************************************/
  1946. /*                                                          */
  1947. /*               StaticText class                           */
  1948. /*                                                          */
  1949. /************************************************************/
  1951. class GLUI_StaticText : public GLUI_Control
  1952. {
  1953. public:
  1954.     void set_text( const char *text );
  1955.     void draw( int x, int y );
  1956.     void draw_text( void );
  1957.     void update_size( void );
  1958.     void erase_text( void );
  1960.     GLUI_StaticText(GLUI_Node *parent, const char *name);
  1961.     GLUI_StaticText( void ) { common_init(); }
  1963. protected:
  1964.     void common_init() {
  1965.         h       = GLUI_STATICTEXT_SIZE;
  1966.         name    = "";
  1967.         can_activate  = false;
  1968.     }
  1969. };
  1971. /************************************************************/
  1972. /*                                                          */
  1973. /*               TextBox class - JVK                        */
  1974. /*                                                          */
  1975. /************************************************************/
  1977. class GLUI_TextBox : public GLUI_Control
  1978. {
  1979. public:
  1980.     /* GLUI Textbox - JVK */
  1981.     GLUI_TextBox(GLUI_Node *parent, GLUI_String &live_var,
  1982.                  bool scroll = false, int id=-1, GLUI_CB callback=GLUI_CB() );
  1983.     GLUI_TextBox( GLUI_Node *parent,
  1984.                   bool scroll = false, int id=-1,
  1985.                   GLUI_CB callback=GLUI_CB() );
  1987.     GLUI_String         orig_text;
  1988.     int                 insertion_pt;
  1989.     int                 substring_start; /*substring that gets displayed in box*/
  1990.     int                 substring_end;  
  1991.     int                 sel_start, sel_end;  /* current selection */
  1992.     int                 last_insertion_pt;
  1993.     int                 debug;
  1994.     int                 draw_text_only;
  1995.     int                 tab_width;
  1996.     int                 start_line;
  1997.     int                 num_lines;
  1998.     int                 curr_line;
  1999.     int                 visible_lines;
  2000.     int                 insert_x;        /* Similar to "insertion_pt", these variables keep */
  2001.     int                 insert_y;        /* track of where the ptr is, but in pixels */
  2002.     int                 keygoal_x;       /* where up down keys would like to put insertion pt*/
  2003.     GLUI_Scrollbar     *scrollbar;
  2005.     int  mouse_down_handler( int local_x, int local_y );
  2006.     int  mouse_up_handler( int local_x, int local_y, bool inside );
  2007.     int  mouse_held_down_handler( int local_x, int local_y, bool inside );
  2008.     int  key_handler( unsigned char key,int modifiers );
  2009.     int  special_handler( int key,int modifiers );
  2010.   
  2011.     void activate( int how );
  2012.     void deactivate( void );
  2014.     void enable( void );
  2015.     void disable( void );
  2017.     void draw( int x, int y );
  2019.     int  mouse_over( int state, int x, int y );
  2021.     int get_box_width();
  2022.     int  find_word_break( int start, int direction );
  2023.     int  substring_width( int start, int end, int initial_width=0 );
  2024.     void clear_substring( int start, int end );
  2025.     int  find_insertion_pt( int x, int y );
  2026.     int  update_substring_bounds( void );
  2027.     void update_and_draw_text( void );
  2028.     void draw_text( int x, int y );
  2029.     void draw_insertion_pt( void );
  2030.     void update_x_offsets( void );
  2031.     void update_size( void );
  2033.     void set_text( const char *text );
  2034.     const char *get_text( void )         { return text.c_str(); }
  2036.     void dump( FILE *out, char *text );
  2037.     void set_tab_w(int w) { tab_width = w; }
  2038.     void set_start_line(int l) { start_line = l; }
  2039.     static void scrollbar_callback(GLUI_Control*);
  2041.     bool wants_tabs( void ) const { return true; }
  2043. protected:
  2044.     void common_init()
  2045.     {
  2046.         h                     = GLUI_TEXTBOX_HEIGHT;
  2047.         w                     = GLUI_TEXTBOX_WIDTH;
  2048.         tab_width             = GLUI_TAB_WIDTH;
  2049.         num_lines             = 0;
  2050.         visible_lines         = 0;
  2051.         start_line            = 0;
  2052.         curr_line             = 0;
  2053.         insert_y              = -1;
  2054.         insert_x              = -1;
  2055.         insertion_pt          = -1;
  2056.         last_insertion_pt     = -1;
  2057.         name[0]               = '';
  2058.         substring_start       = 0;
  2059.         substring_end         = 2;
  2060.         sel_start             = 0;
  2061.         sel_end               = 0;
  2062.         active_type           = GLUI_CONTROL_ACTIVE_PERMANENT;
  2063.         can_activate          = true;
  2064.         spacebar_mouse_click  = false;
  2065.         scrollbar             = NULL;
  2066.         debug                 = false;
  2067.         draw_text_only        = false;
  2068.     }
  2069.     void common_construct(
  2070.         GLUI_Node *parent, GLUI_String *live_var, 
  2071.         bool scroll, int id, GLUI_CB callback); 
  2072. };
  2074. /************************************************************/
  2075. /*                                                          */
  2076. /*                   List class - JVK                       */
  2077. /*                                                          */
  2078. /************************************************************/
  2080. class GLUI_List_Item : public GLUI_Node 
  2081. {
  2082. public:
  2083.     GLUI_String text;
  2084.     int         id;
  2085. };
  2087. /************************************************************/
  2088. /*                                                          */
  2089. /*               List class - JVK                           */
  2090. /*                                                          */
  2091. /************************************************************/
  2093. class GLUI_List : public GLUI_Control
  2094. {
  2095. public:
  2096.     /* GLUI List - JVK */
  2097.     GLUI_List( GLUI_Node *parent, bool scroll = false,
  2098.                int id=-1, GLUI_CB callback=GLUI_CB() );
  2099.                /*, GLUI_Control *object = NULL 
  2100.                ,GLUI_InterObject_CB obj_cb = NULL);*/
  2102.     GLUI_List( GLUI_Node *parent,
  2103.                GLUI_String& live_var, bool scroll = false, 
  2104.                int id=-1, 
  2105.                GLUI_CB callback=GLUI_CB()
  2106.                /*,GLUI_Control *object = NULL */
  2107.                /*,GLUI_InterObject_CB obj_cb = NULL*/);
  2110.     GLUI_String         orig_text;
  2111.     int                 debug;
  2112.     int                 draw_text_only;
  2113.     int                 start_line;
  2114.     int                 num_lines;
  2115.     int                 curr_line;
  2116.     int                 visible_lines;
  2117.     GLUI_Scrollbar      *scrollbar;
  2118.     GLUI_List_Item      items_list;
  2119.     GLUI_Control        *associated_object;
  2120.     GLUI_CB             obj_cb;
  2121.     int                 cb_click_type;
  2122.     int                 last_line;
  2123.     int                 last_click_time;
  2125.     int  mouse_down_handler( int local_x, int local_y );
  2126.     int  mouse_up_handler( int local_x, int local_y, bool inside );
  2127.     int  mouse_held_down_handler( int local_x, int local_y, bool inside );
  2128.     int  key_handler( unsigned char key,int modifiers );
  2129.     int  special_handler( int key,int modifiers );
  2130.   
  2131.     void activate( int how );
  2132.     void deactivate( void );
  2134.     void draw( int x, int y );
  2136.     int  mouse_over( int state, int x, int y );
  2138.     int get_box_width();
  2139.     int  find_word_break( int start, int direction );
  2140.     int  substring_width( const char *t, int start, int end );
  2141.     int  find_line( int x, int y );
  2142.     void update_and_draw_text( void );
  2143.     void draw_text( const char *t, int selected, int x, int y );
  2144.     void update_size( void );
  2147.     int  add_item( int id, const char *text );
  2148.     int  delete_item( const char *text );
  2149.     int  delete_item( int id );
  2150.     int  delete_all();
  2152.     GLUI_List_Item *get_item_ptr( const char *text );
  2153.     GLUI_List_Item *get_item_ptr( int id );
  2155.     void dump( FILE *out, const char *text );
  2156.     void set_start_line(int l) { start_line = l; }
  2157.     static void scrollbar_callback(GLUI_Control*);
  2158.     int get_current_item() { return curr_line; }
  2159.     void set_click_type(int d) {
  2160.         cb_click_type = d; }
  2161.     void set_object_callback(GLUI_CB cb=GLUI_CB(), GLUI_Control*obj=NULL)
  2162.     { obj_cb=cb; associated_object=obj; }
  2164. protected:
  2165.     void common_init()
  2166.     {
  2167.         h                     = GLUI_LIST_HEIGHT;
  2168.         w                     = GLUI_LIST_WIDTH;
  2169.         num_lines             = 0;
  2170.         visible_lines         = 0;
  2171.         start_line            = 0;
  2172.         curr_line             = 0;
  2173.         name[0]               = '';
  2174.         active_type           = GLUI_CONTROL_ACTIVE_PERMANENT;
  2175.         can_activate          = true;
  2176.         spacebar_mouse_click  = false;
  2177.         scrollbar             = NULL;
  2178.         debug                 = false;
  2179.         draw_text_only        = false;
  2180.         cb_click_type         = GLUI_SINGLE_CLICK;
  2181.         last_line             = -1;
  2182.         last_click_time       = 0;
  2183.         associated_object     = NULL;
  2184.     };
  2185.     void common_construct(
  2186.         GLUI_Node *parent,
  2187.         GLUI_String* live_var, bool scroll,
  2188.         int id,
  2189.         GLUI_CB callback
  2190.         /*,GLUI_Control *object*/
  2191.         /*,GLUI_InterObject_CB obj_cb*/);
  2192. };
  2194. /************************************************************/
  2195. /*                                                          */
  2196. /*               Scrollbar class - JVK                      */
  2197. /*                                                          */
  2198. /************************************************************/
  2199.  
  2200. class GLUI_Scrollbar : public GLUI_Control
  2201. {
  2202. public:
  2203.     // Constructor, no live var
  2204.     GLUI_Scrollbar( GLUI_Node *parent,
  2205.                     const char *name, 
  2206.                     int horz_vert=GLUI_SCROLL_HORIZONTAL,
  2207.                     int data_type=GLUI_SCROLL_INT,
  2208.                     int id=-1, GLUI_CB callback=GLUI_CB() 
  2209.                     /*,GLUI_Control *object = NULL*/
  2210.                     /*,GLUI_InterObject_CB obj_cb = NULL*/
  2211.                     );
  2213.     // Constructor, int live var
  2214.     GLUI_Scrollbar( GLUI_Node *parent, const char *name, int horz_vert,
  2215.                     int *live_var,
  2216.                     int id=-1, GLUI_CB callback=GLUI_CB() 
  2217.                     /*,GLUI_Control *object = NULL*/
  2218.                     /*,GLUI_InterObject_CB obj_cb = NULL*/
  2219.                     );
  2221.     // Constructor, float live var
  2222.     GLUI_Scrollbar( GLUI_Node *parent, const char *name, int horz_vert,
  2223.                     float *live_var,
  2224.                     int id=-1, GLUI_CB callback=GLUI_CB()
  2225.                     /*,GLUI_Control *object = NULL*/
  2226.                     /*,GLUI_InterObject_CB obj_cb = NULL*/
  2227.                     );
  2229.     bool          currently_inside;
  2230.     int           state;
  2231.     float         growth, growth_exp;
  2232.     int           last_x, last_y;
  2233.     int           data_type;
  2234.     int           callback_count;
  2235.     int           last_int_val;  ///< Used to prevent repeated callbacks.
  2236.     float         last_float_val;
  2237.     int           first_callback;
  2238.     float         user_speed;
  2239.     float         float_min, float_max;
  2240.     int           int_min, int_max;
  2241.     int           horizontal;
  2242.     double     last_update_time; ///< GLUI_Time() we last advanced scrollbar.
  2243.     double     velocity_limit; ///< Maximum distance to advance per second.
  2244.     int box_length;
  2245.     int box_start_position;
  2246.     int box_end_position;
  2247.     int track_length;
  2250.     /* Rather than directly access an Editbox or Textbox for 
  2251.        changing variables, a pointer to some object is defined
  2252.        along with a static callback in the form func(void *, int) -
  2253.        the int is the new value, the void * must be cast to that
  2254.        particular object type before use.
  2255.     */
  2256.     void *        associated_object; /* Lets the Spinner manage it's own callbacks */
  2257.     GLUI_CB       object_cb; /* function pointer to object call_back */
  2259.     int  mouse_down_handler( int local_x, int local_y );
  2260.     int  mouse_up_handler( int local_x, int local_y, bool inside );
  2261.     int  mouse_held_down_handler( int local_x, int local_y, bool inside );
  2262.     int  key_handler( unsigned char key,int modifiers );
  2263.     int  special_handler( int key,int modifiers );
  2264.   
  2265.     void draw( int x, int y );
  2266.     void draw_pressed( void );
  2267.     void draw_unpressed( void );
  2268.     void draw_text( int sunken );
  2270.     void update_size( void );
  2272.     void set_int_limits( int low, int high,int limit_type=GLUI_LIMIT_CLAMP);
  2273.     void set_float_limits( float low,float high,int limit_type=GLUI_LIMIT_CLAMP);
  2274.     int  find_arrow( int local_x, int local_y );
  2275.     void do_drag( int x, int y );
  2276.     void do_callbacks( void );
  2277.     void draw_scroll( void );
  2278.     void do_click( void );
  2279.     void idle( void );
  2280.     bool needs_idle( void ) const;
  2281.     void set_int_val( int new_val );
  2282.     void set_float_val( float new_val );
  2283.     void increase_growth( void );
  2284.     void reset_growth( void );
  2286.     void set_speed( float speed ) { user_speed = speed; };
  2287.     void update_scroll_parameters();
  2288.     void set_object_callback(GLUI_CB cb=GLUI_CB(), GLUI_Control*obj=NULL)
  2289.     { object_cb=cb; associated_object=obj; }
  2291. protected:
  2292.     void common_init ( void );
  2293.     void common_construct(
  2294.         GLUI_Node *parent,
  2295.         const char *name, 
  2296.         int horz_vert,
  2297.         int data_type, void* live_var,
  2298.         int id, GLUI_CB callback
  2299.         /*,GLUI_Control *object
  2300.         ,GLUI_InterObject_CB obj_cb*/
  2301.         );
  2303.     virtual void draw_scroll_arrow(int arrowtype, int x, int y);
  2304.     virtual void draw_scroll_box(int x, int y, int w, int h);
  2305. };
  2307. /************************************************************/
  2308. /*                                                          */
  2309. /*                   Listbox class                          */
  2310. /*                                                          */
  2311. /************************************************************/
  2313. class GLUI_Listbox_Item : public GLUI_Node 
  2314. {
  2315. public:
  2316.     GLUI_String text;
  2317.     int         id;
  2318. };
  2320. class GLUI_Listbox : public GLUI_Control
  2321. {
  2322. public:
  2323.     GLUI_String       curr_text;
  2324.     GLUI_Listbox_Item items_list;
  2325.     int               depressed;
  2327.     int  orig_value;
  2328.     bool currently_inside;
  2329.     int  text_x_offset, title_x_offset;
  2330.     int  glut_menu_id;
  2332.     int  mouse_down_handler( int local_x, int local_y );
  2333.     int  mouse_up_handler( int local_x, int local_y, bool inside );
  2334.     int  mouse_held_down_handler( int local_x, int local_y, bool inside );
  2335.     int  key_handler( unsigned char key,int modifiers );
  2336.     int  special_handler( int key,int modifiers );
  2338.     void update_size( void );
  2339.     void draw( int x, int y );
  2340.     int  mouse_over( int state, int x, int y );
  2342.     void set_int_val( int new_val );
  2343.     void dump( FILE *output );
  2345.     int  add_item( int id, const char *text );
  2346.     int  delete_item( const char *text );
  2347.     int  delete_item( int id );
  2348.     int  sort_items( void );
  2350.     int  do_selection( int item );
  2352.     GLUI_Listbox_Item *get_item_ptr( const char *text );
  2353.     GLUI_Listbox_Item *get_item_ptr( int id );
  2354.   
  2356.     GLUI_Listbox( GLUI_Node *parent,
  2357.                   const char *name, int *live_var=NULL,
  2358.                   int id=-1, GLUI_CB callback=GLUI_CB() );
  2359.     GLUI_Listbox( void ) { common_init(); }
  2361. protected:
  2362.     /** Change w and return true if we need to be widened to fit the current item. */
  2363.     bool recalculate_item_width( void );
  2364.     void common_init() {
  2365.         glui_format_str( name, "Listbox: %p", this );
  2366.         w              = GLUI_EDITTEXT_WIDTH;
  2367.         h              = GLUI_EDITTEXT_HEIGHT;
  2368.         orig_value     = -1;
  2369.         title_x_offset = 0;
  2370.         text_x_offset  = 55;
  2371.         can_activate   = true;
  2372.         curr_text      = "";
  2373.         live_type      = GLUI_LIVE_INT;  /* This has an integer live var */
  2374.         depressed      = false;
  2375.         glut_menu_id   = -1;
  2376.     }
  2378.     ~GLUI_Listbox();
  2379. };
  2381. /************************************************************/
  2382. /*                                                          */
  2383. /*              Mouse_Interaction class                     */
  2384. /*                                                          */
  2385. /************************************************************/
  2387. /**
  2388.   This is the superclass of translation and rotation widgets.
  2389. */
  2390. class GLUI_Mouse_Interaction : public GLUI_Control
  2391. {
  2392. public:
  2393.     /*int  get_main_area_size( void ) { return MIN( h-18,  */
  2394.     int            draw_active_area_only;
  2396.     int  mouse_down_handler( int local_x, int local_y );
  2397.     int  mouse_up_handler( int local_x, int local_y, bool inside );
  2398.     int  mouse_held_down_handler( int local_x, int local_y, bool inside );
  2399.     int  special_handler( int key, int modifiers );
  2400.     void update_size( void );
  2401.     void draw( int x, int y );
  2402.     void draw_active_area( void );
  2404.     /***  The following methods (starting with "iaction_") need to
  2405.           be overloaded  ***/
  2406.     virtual int  iaction_mouse_down_handler( int local_x, int local_y ) = 0;
  2407.     virtual int  iaction_mouse_up_handler( int local_x, int local_y, bool inside )=0;
  2408.     virtual int  iaction_mouse_held_down_handler( int local_x, int local_y, bool inside )=0;
  2409.     virtual int  iaction_special_handler( int key, int modifiers )=0;
  2410.     virtual void iaction_draw_active_area_persp( void )=0;
  2411.     virtual void iaction_draw_active_area_ortho( void )=0;
  2412.     virtual void iaction_dump( FILE *output )=0;
  2413.     virtual void iaction_init( void ) = 0;
  2414.   
  2415.     GLUI_Mouse_Interaction( void ) {
  2416.         glui_format_str( name, "Mouse_Interaction: %p", this );
  2417.         w              = GLUI_MOUSE_INTERACTION_WIDTH;
  2418.         h              = GLUI_MOUSE_INTERACTION_HEIGHT;
  2419.         can_activate   = true;
  2420.         live_type      = GLUI_LIVE_NONE;
  2421.         alignment      = GLUI_ALIGN_CENTER;
  2422.         draw_active_area_only = false;
  2423.     }
  2424. };
  2426. /************************************************************/
  2427. /*                                                          */
  2428. /*                   Rotation class                         */
  2429. /*                                                          */
  2430. /************************************************************/
  2432. /**
  2433.   An onscreen rotation controller--allows the user to interact with
  2434.   a 3D rotation via a spaceball-like interface.
  2435. */
  2436. class GLUI_Rotation : public GLUI_Mouse_Interaction
  2437. {
  2438. public:
  2439.     Arcball        *ball;
  2440.     GLUquadricObj *quadObj;
  2441.     bool           can_spin, spinning;
  2442.     float          damping;
  2443.   
  2444.     int  iaction_mouse_down_handler( int local_x, int local_y );
  2445.     int  iaction_mouse_up_handler( int local_x, int local_y, bool inside );
  2446.     int  iaction_mouse_held_down_handler( int local_x, int local_y, bool inside );
  2447.     int  iaction_special_handler( int key, int modifiers );
  2448.     void iaction_init( void ) { init_ball(); }
  2449.     void iaction_draw_active_area_persp( void );
  2450.     void iaction_draw_active_area_ortho( void );
  2451.     void iaction_dump( FILE *output );
  2453.     /*  void update_size( void ); */
  2454.     /*  void draw( int x, int y ); */
  2455.     /*  int mouse_over( int state, int x, int y ); */
  2457.     void setup_texture( void );
  2458.     void setup_lights( void );
  2459.     void draw_ball( float radius );
  2461.     void init_ball( void );
  2463.     void reset( void );
  2465.     bool needs_idle( void ) const;
  2466.     void idle( void );
  2468.     void copy_float_array_to_ball( void );
  2469.     void copy_ball_to_float_array( void );
  2471.     void set_spin( float damp_factor );
  2473.     GLUI_Rotation( GLUI_Node *parent, const char *name, float *live_var=NULL,
  2474.                    int id=-1, GLUI_CB callback=GLUI_CB() );
  2475.     GLUI_Rotation(void) { common_init(); }
  2477. protected:
  2478.     void common_init();
  2479. };
  2481. /************************************************************/
  2482. /*                                                          */
  2483. /*                   Translation class                      */
  2484. /*                                                          */
  2485. /************************************************************/
  2487. /**
  2488.   An onscreen translation controller--allows the user to interact with
  2489.   a 3D translation.
  2490. */
  2491. class GLUI_Translation : public GLUI_Mouse_Interaction
  2492. {
  2493. public:
  2494.     int trans_type;  /* Is this an XY or a Z controller? */
  2495.     int down_x, down_y;
  2496.     float scale_factor;
  2497.     GLUquadricObj *quadObj;
  2498.     int   trans_mouse_code;
  2499.     float orig_x, orig_y, orig_z;
  2500.     int   locked;
  2502.     int  iaction_mouse_down_handler( int local_x, int local_y );
  2503.     int  iaction_mouse_up_handler( int local_x, int local_y, bool inside );
  2504.     int  iaction_mouse_held_down_handler( int local_x, int local_y, bool inside );
  2505.     int  iaction_special_handler( int key, int modifiers );
  2506.     void iaction_init( void ) { }
  2507.     void iaction_draw_active_area_persp( void );
  2508.     void iaction_draw_active_area_ortho( void );
  2509.     void iaction_dump( FILE *output );
  2511.     void set_speed( float s ) { scale_factor = s; }
  2513.     void setup_texture( void );
  2514.     void setup_lights( void );
  2515.     void draw_2d_arrow( int radius, int filled, int orientation ); 
  2516.     void draw_2d_x_arrows( int radius );
  2517.     void draw_2d_y_arrows( int radius );
  2518.     void draw_2d_z_arrows( int radius );
  2519.     void draw_2d_xy_arrows( int radius );
  2521.     int  get_mouse_code( int x, int y );
  2523.     /* Float array is either a single float (for single-axis controls),
  2524.        or two floats for X and Y (if an XY controller) */
  2526.     float get_z( void ) {       return float_array_val[0];  }
  2527.     float get_x( void ) {       return float_array_val[0];  }
  2528.     float get_y( void ) {
  2529.         if ( trans_type == GLUI_TRANSLATION_XY )    return float_array_val[1];
  2530.         else return float_array_val[0];
  2531.     }
  2533.     void  set_z( float val );
  2534.     void  set_x( float val );
  2535.     void  set_y( float val );
  2536.     void  set_one_val( float val, int index );
  2538.     GLUI_Translation( GLUI_Node *parent, const char *name,
  2539.                       int trans_type, float *live_var=NULL,
  2540.                       int id=-1, GLUI_CB callback=GLUI_CB() );
  2541.     GLUI_Translation( void ) { common_init(); }
  2543. protected:
  2544.     void common_init() {
  2545.         locked              = GLUI_TRANSLATION_LOCK_NONE;
  2546.         glui_format_str( name, "Translation: %p", this );
  2547.         w                   = GLUI_MOUSE_INTERACTION_WIDTH;
  2548.         h                   = GLUI_MOUSE_INTERACTION_HEIGHT;
  2549.         can_activate        = true;
  2550.         live_type           = GLUI_LIVE_FLOAT_ARRAY;
  2551.         float_array_size    = 0;
  2552.         alignment           = GLUI_ALIGN_CENTER;
  2553.         trans_type          = GLUI_TRANSLATION_XY;
  2554.         scale_factor        = 1.0;
  2555.         quadObj             = NULL;
  2556.         trans_mouse_code    = GLUI_TRANSLATION_MOUSE_NONE;
  2557.     }
  2558. };
  2560. /********** Misc functions *********************/
  2561. int _glutBitmapWidthString( void *font, const char *s );
  2562. void _glutBitmapString( void *font, const char *s );
  2564. /********** Our own callbacks for glut *********/
  2565. /* These are the callbacks that we pass to glut.  They take
  2566.    some action if necessary, then (possibly) call the user-level
  2567.    glut callbacks.  
  2568. */
  2570. void glui_display_func( void );
  2571. void glui_reshape_func( int w, int h );
  2572. void glui_keyboard_func(unsigned char key, int x, int y);
  2573. void glui_special_func(int key, int x, int y);
  2574. void glui_mouse_func(int button, int state, int x, int y);
  2575. void glui_motion_func(int x, int y);
  2576. void glui_passive_motion_func(int x, int y);
  2577. void glui_entry_func(int state);
  2578. void glui_visibility_func(int state);
  2579. void glui_idle_func(void);
  2581. void glui_parent_window_reshape_func( int w, int h );
  2582. void glui_parent_window_keyboard_func(unsigned char key, int x, int y);
  2583. void glui_parent_window_mouse_func(int, int, int, int );
  2584. void glui_parent_window_special_func(int key, int x, int y);
  2586. #endif