← Back to branch summary

~ubuntu-branches/ubuntu/vivid/emscripten/vivid

« back to all changes in this revision

Viewing changes to tests/bullet/Extras/glui/glui_edittext.cpp

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2013-05-02 13:11:51 UTC
  • Revision ID: package-import@ubuntu.com-20130502131151-q8dvteqr1ef2x7xz
Tags: upstream-1.4.1~20130504~adb56cb
Import upstream version 1.4.1~20130504~adb56cb

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/bullet/Extras/glui/glui_edittext.cpp
 
1
/****************************************************************************
 
2
  
 
3
  GLUI User Interface Toolkit
 
4
  ---------------------------
 
5
 
 
6
     glui_edittext.cpp - GLUI_EditText control class
 
7
 
 
8
 
 
9
          --------------------------------------------------
 
10
 
 
11
  Copyright (c) 1998 Paul Rademacher
 
12
 
 
13
  WWW:    http://sourceforge.net/projects/glui/
 
14
  Forums: http://sourceforge.net/forum/?group_id=92496
 
15
 
 
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.
 
20
 
 
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.
 
25
 
 
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
 
29
 
 
30
*****************************************************************************/
 
31
 
 
32
#include "glui_internal_control.h"
 
33
#include <cassert>
 
34
 
 
35
/****************************** GLUI_EditText::GLUI_EditText() **********/
 
36
 
 
37
GLUI_EditText::GLUI_EditText( GLUI_Node *parent, const char *name,
 
38
                             int data_type, void *live_var,
 
39
                             int id, GLUI_CB callback )
 
40
{
 
41
  if (data_type == GLUI_EDITTEXT_TEXT) {
 
42
    live_type = GLUI_LIVE_TEXT;
 
43
  }
 
44
  else if (data_type == GLUI_EDITTEXT_STRING) {
 
45
   data_type = GLUI_EDITTEXT_TEXT;  // EDITTEXT_STRING doesn't really exist.
 
46
                                     // Except as a signal to make a string.
 
47
                                     // It's a backwards-compat hack.
 
48
   live_type = GLUI_LIVE_STRING;
 
49
  }
 
50
  else if (data_type == GLUI_EDITTEXT_INT) {
 
51
    live_type = GLUI_LIVE_INT;
 
52
  }
 
53
  else if (data_type == GLUI_EDITTEXT_FLOAT) {
 
54
    live_type = GLUI_LIVE_FLOAT;
 
55
  }
 
56
  common_construct( parent, name, data_type, live_type, live_var, id, callback );
 
57
}
 
58
 
 
59
/****************************** GLUI_EditText::GLUI_EditText() **********/
 
60
 
 
61
GLUI_EditText::GLUI_EditText( GLUI_Node *parent, const char *name,
 
62
                              int text_type, int id, GLUI_CB callback )
 
63
{
 
64
  common_construct( parent, name, text_type, GLUI_LIVE_NONE, 0, id, callback);
 
65
}
 
66
 
 
67
/****************************** GLUI_EditText::GLUI_EditText() **********/
 
68
 
 
69
GLUI_EditText::GLUI_EditText( GLUI_Node *parent, const char *name,
 
70
                              int *live_var,
 
71
                              int id, GLUI_CB callback )
 
72
{
 
73
  common_construct( parent, name, GLUI_EDITTEXT_INT, GLUI_LIVE_INT, live_var, id, callback);
 
74
}
 
75
 
 
76
/****************************** GLUI_EditText::GLUI_EditText() **********/
 
77
 
 
78
GLUI_EditText::GLUI_EditText( GLUI_Node *parent, const char *name,
 
79
                              float *live_var,
 
80
                              int id, GLUI_CB callback )
 
81
{
 
82
  common_construct( parent, name, GLUI_EDITTEXT_FLOAT, GLUI_LIVE_FLOAT, live_var, id, callback);
 
83
}
 
84
 
 
85
/****************************** GLUI_EditText::GLUI_EditText() **********/
 
86
 
 
87
GLUI_EditText::GLUI_EditText( GLUI_Node *parent, const char *name, 
 
88
                              char *live_var,
 
89
                              int id, GLUI_CB callback )
 
90
{
 
91
  common_construct( parent, name, GLUI_EDITTEXT_TEXT, GLUI_LIVE_TEXT, live_var, id, callback);
 
92
}
 
93
 
 
94
/****************************** GLUI_EditText::GLUI_EditText() **********/
 
95
 
 
96
GLUI_EditText::GLUI_EditText( GLUI_Node *parent, const char *name, 
 
97
                              std::string &live_var,
 
98
                              int id, GLUI_CB callback )
 
99
{
 
100
  common_construct( parent, name, GLUI_EDITTEXT_TEXT, GLUI_LIVE_STRING, &live_var, id, callback);
 
101
}
 
102
 
 
103
/****************************** GLUI_EditText::common_construct() **********/
 
104
 
 
105
void GLUI_EditText::common_construct( GLUI_Node *parent, const char *name, 
 
106
                                      int data_t, int live_t, void *data, int id, 
 
107
                                      GLUI_CB cb )
 
108
{
 
109
  common_init();
 
110
  set_name( name );
 
111
    
 
112
  live_type   = live_t;
 
113
  data_type   = data_t;
 
114
  ptr_val     = data;
 
115
  user_id     = id;
 
116
  callback    = cb;
 
117
    
 
118
 
 
119
  if ( live_type == GLUI_LIVE_INT) {
 
120
    if ( data == NULL )
 
121
      set_int_val(int_val);   /** Set to some default, in case of no live var **/
 
122
  }
 
123
  else if ( live_type == GLUI_LIVE_FLOAT ) {
 
124
    num_periods = 1;
 
125
    if ( data == NULL )
 
126
      set_float_val(float_val);   /** Set to some default, in case of no live var **/
 
127
  }
 
128
 
 
129
  parent->add_control( this );
 
130
 
 
131
  init_live();
 
132
}
 
133
 
 
134
/****************************** GLUI_EditText::mouse_down_handler() **********/
 
135
 
 
136
int    GLUI_EditText::mouse_down_handler( int local_x, int local_y )
 
137
{
 
138
  int tmp_insertion_pt;
 
139
 
 
140
  if ( debug )    dump( stdout, "-> MOUSE DOWN" );
 
141
 
 
142
  tmp_insertion_pt = find_insertion_pt( local_x, local_y );  
 
143
  if ( tmp_insertion_pt == -1 ) {
 
144
    if ( glui )
 
145
      glui->deactivate_current_control(  );
 
146
    return false;
 
147
  }
 
148
 
 
149
  insertion_pt = tmp_insertion_pt;
 
150
 
 
151
  sel_start = sel_end = insertion_pt;
 
152
 
 
153
  if ( can_draw())
 
154
    update_and_draw_text();
 
155
 
 
156
  if ( debug )    dump( stdout, "<- MOUSE UP" );
 
157
 
 
158
  return true;
 
159
}
 
160
 
 
161
 
 
162
/******************************** GLUI_EditText::mouse_up_handler() **********/
 
163
 
 
164
int    GLUI_EditText::mouse_up_handler( int local_x, int local_y, bool inside )
 
165
{
 
166
  return false;
 
167
}
 
168
 
 
169
 
 
170
/***************************** GLUI_EditText::mouse_held_down_handler() ******/
 
171
 
 
172
int    GLUI_EditText::mouse_held_down_handler( int local_x, int local_y,
 
173
                                               bool new_inside)
 
174
{
 
175
  int tmp_pt;
 
176
 
 
177
  if ( NOT new_inside ) 
 
178
    return false;
 
179
 
 
180
  if ( debug )    dump( stdout, "-> HELD DOWN" );
 
181
  
 
182
  tmp_pt = find_insertion_pt( local_x, local_y );
 
183
  
 
184
  if ( tmp_pt == -1 AND sel_end != 0 ) {    /* moved mouse past left edge */
 
185
    special_handler( GLUT_KEY_LEFT, GLUT_ACTIVE_SHIFT );
 
186
  }
 
187
  else if ( tmp_pt == substring_end+1 AND sel_end != (int) text.length()) {    
 
188
    /* moved mouse past right edge */
 
189
    special_handler( GLUT_KEY_RIGHT, GLUT_ACTIVE_SHIFT );    
 
190
  }
 
191
  else if ( tmp_pt != -1 AND tmp_pt != sel_end ) {
 
192
    sel_end = insertion_pt = tmp_pt;
 
193
    
 
194
    update_and_draw_text();
 
195
  }
 
196
 
 
197
  if ( debug )
 
198
    dump( stdout, "<- HELD DOWN" );
 
199
 
 
200
  return false;
 
201
}
 
202
 
 
203
 
 
204
/****************************** GLUI_EditText::key_handler() **********/
 
205
 
 
206
int    GLUI_EditText::key_handler( unsigned char key,int modifiers )
 
207
{
 
208
  int i, regular_key;
 
209
  /* int has_selection;              */
 
210
 
 
211
  if ( NOT glui )
 
212
    return false;
 
213
 
 
214
  if ( debug )
 
215
    dump( stdout, "-> KEY HANDLER" );
 
216
 
 
217
  regular_key = false;
 
218
  bool ctrl_down = (modifiers & GLUT_ACTIVE_CTRL)!=0;
 
219
  /*  has_selection = (sel_start != sel_end);              */
 
220
 
 
221
  if ( key == CTRL('m') ) {           /* RETURN */
 
222
    /*    glui->deactivate_current_control();              */
 
223
    deactivate();  /** Force callbacks, etc **/
 
224
    activate(GLUI_ACTIVATE_TAB);     /** Reselect all text **/
 
225
    redraw();
 
226
    return true;
 
227
  }
 
228
  else if ( key  == CTRL('[')) {         /* ESCAPE */
 
229
    glui->deactivate_current_control();
 
230
    return true;
 
231
  }
 
232
  else if ( (key == 127 AND !ctrl_down) OR  /* FORWARD DELETE */
 
233
            ( key == CTRL('d') AND modifiers == GLUT_ACTIVE_CTRL) ) 
 
234
  {
 
235
    if ( sel_start == sel_end ) {   /* no selection */
 
236
      if ( insertion_pt < (int)text.length() ) {
 
237
        /*** See if we're deleting a period in a float data-type box ***/
 
238
        if ( data_type == GLUI_EDITTEXT_FLOAT AND text[insertion_pt]=='.' )
 
239
          num_periods--;
 
240
 
 
241
        /*** Shift over string first ***/
 
242
        text.erase(insertion_pt,1);
 
243
      }
 
244
    }
 
245
    else {                         /* There is a selection */
 
246
      clear_substring( MIN(sel_start,sel_end), MAX(sel_start,sel_end ));
 
247
      insertion_pt = MIN(sel_start,sel_end);
 
248
      sel_start = sel_end = insertion_pt;
 
249
    }
 
250
  }
 
251
  else if ( ((key == 127) AND ctrl_down) OR   // Delete word forward
 
252
            ((key == 'd') AND (modifiers == GLUT_ACTIVE_ALT)) )
 
253
  {
 
254
    if ( sel_start == sel_end ) {   /* no selection */
 
255
      sel_start = insertion_pt;
 
256
      sel_end = find_word_break( insertion_pt, +1 );
 
257
    }
 
258
 
 
259
    clear_substring( MIN(sel_start,sel_end), MAX(sel_start,sel_end ));
 
260
    insertion_pt = MIN(sel_start,sel_end);
 
261
    sel_start = sel_end = insertion_pt;
 
262
  }
 
263
  else if ( key == CTRL('h') ) {       /* BACKSPACE */
 
264
    if ( sel_start == sel_end ) {   /* no selection */
 
265
      if ( insertion_pt > 0 ) {
 
266
        /*** See if we're deleting a period in a float data-type box ***/
 
267
        if ( data_type == GLUI_EDITTEXT_FLOAT AND text[insertion_pt-1]=='.' )
 
268
          num_periods--;
 
269
 
 
270
        /*** Shift over string first ***/
 
271
        insertion_pt--;
 
272
        text.erase(insertion_pt,1);
 
273
      }
 
274
    }
 
275
    else {                         /* There is a selection */
 
276
      clear_substring( MIN(sel_start,sel_end), MAX(sel_start,sel_end ));
 
277
      insertion_pt = MIN(sel_start,sel_end);
 
278
      sel_start = sel_end = insertion_pt;
 
279
    }
 
280
  }
 
281
  else if ( modifiers == GLUT_ACTIVE_CTRL )  /* CTRL ONLY */ 
 
282
  {
 
283
    /* Ctrl-key bindings */
 
284
    if ( key == CTRL('a') ) {
 
285
      return special_handler( GLUT_KEY_HOME, 0 );
 
286
    }
 
287
    else if ( key == CTRL('e') ) {
 
288
      return special_handler( GLUT_KEY_END, 0 );
 
289
    }
 
290
    else if ( key == CTRL('b') ) {
 
291
      return special_handler( GLUT_KEY_LEFT, 0 );
 
292
    }
 
293
    else if ( key == CTRL('f') ) {
 
294
      return special_handler( GLUT_KEY_RIGHT, 0 );
 
295
    }
 
296
    else if ( key == CTRL('p') ) {
 
297
      return special_handler( GLUT_KEY_UP, 0 );
 
298
    }
 
299
    else if ( key == CTRL('n') ) {
 
300
      return special_handler( GLUT_KEY_DOWN, 0 );
 
301
    }
 
302
    else if ( key == CTRL('u') ) { /* ERASE LINE */
 
303
      insertion_pt = 0;  
 
304
      text.erase(0,text.length());
 
305
      sel_start = sel_end = 0;
 
306
    }
 
307
    else if ( key == CTRL('k') ) { /* KILL TO END OF LINE */
 
308
      sel_start = sel_end = insertion_pt;
 
309
      text.erase(insertion_pt,GLUI_String::npos);
 
310
    }
 
311
  }
 
312
  else if ( modifiers == GLUT_ACTIVE_ALT ) /* ALT ONLY */
 
313
  {
 
314
    if ( key == 'b' ) { // Backward word
 
315
      return special_handler ( GLUT_KEY_LEFT, GLUT_ACTIVE_CTRL );
 
316
    }
 
317
    if ( key == 'f' ) { // Forward word
 
318
      return special_handler ( GLUT_KEY_RIGHT, GLUT_ACTIVE_CTRL );
 
319
    }
 
320
  }
 
321
  else if ( (modifiers & GLUT_ACTIVE_CTRL) OR
 
322
            (modifiers & GLUT_ACTIVE_ALT) ) 
 
323
  {
 
324
    /** ignore other keys with modifiers */
 
325
    return true;
 
326
  }
 
327
  else { /* Regular key */    
 
328
    regular_key = true;
 
329
 
 
330
    /** Check if we only accept numbers **/
 
331
    if (data_type == GLUI_EDITTEXT_FLOAT ) {
 
332
      if ( (key < '0' OR key > '9') AND key != '.' AND key != '-' )
 
333
        return true;
 
334
 
 
335
      if ( key == '-' ) { /* User typed a '-' */
 
336
 
 
337
        /* If user has first character selected, then '-' is allowed */
 
338
        if ( NOT ( MIN(sel_start,sel_end) == 0 AND
 
339
                   MAX(sel_start,sel_end) > 0 ) ) {
 
340
 
 
341
          /* User does not have 1st char selected */
 
342
          if (insertion_pt != 0 OR text[0] == '-' ) {
 
343
            return true; /* Can only place negative at beginning of text,
 
344
                            and only one of them */
 
345
          }
 
346
        }
 
347
      }
 
348
 
 
349
      if ( key == '.' ) {
 
350
        /*printf( "PERIOD: %d\n", num_periods );              */
 
351
 
 
352
        if ( num_periods > 0 ) {
 
353
          /** We're trying to type a period, but the text already contains
 
354
          a period.  Check whether the period is contained within
 
355
          is current selection (thus it will be safely replaced) **/
 
356
 
 
357
          int period_found = false; 
 
358
          if ( sel_start != sel_end ) {
 
359
            for( i=MIN(sel_end,sel_start); i<MAX(sel_start,sel_end); i++ ) {
 
360
              /*  printf( "%c ", text[i] );              */
 
361
              if ( text[i] == '.' ) {
 
362
                period_found = true;
 
363
                break;
 
364
              }
 
365
            }
 
366
          }
 
367
 
 
368
          /* printf( "found: %d    num: %d\n", period_found, num_periods );              */
 
369
 
 
370
          if ( NOT period_found )
 
371
            return true;
 
372
        }
 
373
      }
 
374
    } 
 
375
    else if (data_type == GLUI_EDITTEXT_INT)    
 
376
    {
 
377
      if ( (key < '0' OR key > '9') AND key != '-' )
 
378
        return true;
 
379
 
 
380
      if ( key == '-' ) { /* User typed a '-' */
 
381
 
 
382
        /* If user has first character selected, then '-' is allowed */
 
383
        if ( NOT ( MIN(sel_start,sel_end) == 0 AND
 
384
          MAX(sel_start,sel_end) > 0 ) ) {
 
385
 
 
386
            /* User does not have 1st char selected */
 
387
            if (insertion_pt != 0 OR text[0] == '-' ) {
 
388
              return true; /* Can only place negative at beginning of text,
 
389
                           and only one of them */
 
390
            }
 
391
          }
 
392
      }
 
393
    }
 
394
 
 
395
    /** This is just to get rid of warnings - the flag regular_key is 
 
396
      set if the key was not a backspace, return, whatever.  But I
 
397
      believe if we're here, we know it was a regular key anyway */
 
398
    if ( regular_key ) {
 
399
    }
 
400
 
 
401
    /**** If there's a current selection, erase it ******/
 
402
    if ( sel_start != sel_end ) {
 
403
      clear_substring( MIN(sel_start,sel_end), MAX(sel_start,sel_end ));
 
404
      insertion_pt = MIN(sel_start,sel_end);
 
405
      sel_start = sel_end = insertion_pt;
 
406
    }
 
407
 
 
408
    /******** We insert the character into the string ***/
 
409
 
 
410
    text.insert(insertion_pt,1,key);
 
411
 
 
412
    /******** Move the insertion point and substring_end one over ******/
 
413
    insertion_pt++;
 
414
    substring_end++;
 
415
 
 
416
    sel_start = sel_end = insertion_pt;
 
417
  }
 
418
 
 
419
  /******** Now redraw text ***********/
 
420
  /* Hack to prevent text box from being cleared first **/  
 
421
  /**  int substring_change =  update_substring_bounds();
 
422
  draw_text_only = 
 
423
  (NOT substring_change AND NOT has_selection AND regular_key ); 
 
424
  */
 
425
 
 
426
  draw_text_only = false;  /** Well, hack is not yet working **/
 
427
  update_and_draw_text();
 
428
  draw_text_only = false;
 
429
 
 
430
 
 
431
  if ( debug )
 
432
    dump( stdout, "<- KEY HANDLER" );
 
433
 
 
434
  /*** Now look to see if this string has a period ***/
 
435
  num_periods = 0;
 
436
  for( i=0; i<(int)text.length(); i++ )
 
437
    if ( text[i] == '.' )
 
438
      num_periods++;
 
439
 
 
440
  return true;
 
441
}
 
442
 
 
443
 
 
444
/****************************** GLUI_EditText::activate() **********/
 
445
 
 
446
void    GLUI_EditText::activate( int how )
 
447
{
 
448
  if ( debug )
 
449
    dump( stdout, "-> ACTIVATE" );
 
450
 
 
451
  active = true;
 
452
 
 
453
  if ( how == GLUI_ACTIVATE_MOUSE )
 
454
    return;  /* Don't select everything if activated with mouse */
 
455
 
 
456
  orig_text = text;
 
457
 
 
458
  sel_start    = 0;
 
459
  sel_end      = (int)text.length();
 
460
  insertion_pt = 0;
 
461
 
 
462
  if ( debug )
 
463
    dump( stdout, "<- ACTIVATE" );
 
464
}
 
465
 
 
466
 
 
467
/****************************** GLUI_EditText::deactivate() **********/
 
468
 
 
469
void    GLUI_EditText::deactivate( void )
 
470
{
 
471
  int    new_int_val;
 
472
  float  new_float_val;
 
473
 
 
474
  active = false;
 
475
 
 
476
  if ( NOT glui )
 
477
    return;
 
478
 
 
479
  if ( debug )
 
480
    dump( stdout, "-> DISACTIVATE" );
 
481
 
 
482
  sel_start = sel_end = insertion_pt = -1; 
 
483
 
 
484
  /***** Retrieve the current value from the text *****/
 
485
  /***** The live variable will be updated by set_text() ****/
 
486
  if ( data_type == GLUI_EDITTEXT_FLOAT ) {
 
487
    if ( text.length() == 0 ) /* zero-length string - make it "0.0" */
 
488
      text = "0.0";
 
489
 
 
490
    new_float_val = atof( text.c_str() );
 
491
 
 
492
    set_float_val( new_float_val );
 
493
  }
 
494
  else if ( data_type == GLUI_EDITTEXT_INT ) {
 
495
    if ( text.length() == 0 ) /* zero-length string - make it "0" */
 
496
      text = "0";
 
497
 
 
498
    new_int_val = atoi( text.c_str() );
 
499
 
 
500
    set_int_val( new_int_val );
 
501
  }
 
502
  else 
 
503
    if ( data_type == GLUI_EDITTEXT_TEXT ) {
 
504
      set_text(text); /* This will force callbacks and gfx refresh */
 
505
    }
 
506
 
 
507
  update_substring_bounds();
 
508
 
 
509
  /******** redraw text without insertion point ***********/
 
510
  redraw();
 
511
 
 
512
  /***** Now do callbacks if value changed ******/
 
513
  if ( orig_text != text ) {
 
514
    this->execute_callback();
 
515
    
 
516
    if ( 0 ) {
 
517
      /* THE CODE BELOW IS FROM WHEN SPINNER ALSO MAINTAINED CALLBACKS    */
 
518
      if ( spinner == NULL ) {   /** Are we independent of a spinner?  **/  
 
519
        if ( callback ) {
 
520
          callback( this );              
 
521
        }              
 
522
      }              
 
523
      else {                      /* We're attached to a spinner */              
 
524
        spinner->do_callbacks();  /* Let the spinner do the callback stuff */  
 
525
      }              
 
526
    }
 
527
  }
 
528
 
 
529
  if ( debug )
 
530
    dump( stdout, "<- DISACTIVATE" );
 
531
}
 
532
 
 
533
/****************************** GLUI_EditText::draw() **********/
 
534
 
 
535
void    GLUI_EditText::draw( int x, int y )
 
536
{
 
537
  GLUI_DRAWINGSENTINAL_IDIOM
 
538
  int name_x;
 
539
 
 
540
  name_x = MAX(text_x_offset - string_width(this->name) - 3,0);
 
541
  draw_name( name_x , 13);
 
542
 
 
543
  glBegin( GL_LINES );
 
544
  glColor3f( .5, .5, .5 );
 
545
  glVertex2i( text_x_offset, 0 );     glVertex2i( w, 0 );
 
546
  glVertex2i( text_x_offset, 0 );     glVertex2i( text_x_offset, h );     
 
547
 
 
548
  glColor3f( 1., 1., 1. );
 
549
  glVertex2i( text_x_offset, h );     glVertex2i( w, h );
 
550
  glVertex2i( w, h );                 glVertex2i( w, 0 );
 
551
 
 
552
  if ( enabled )
 
553
    glColor3f( 0., 0., 0. );
 
554
  else
 
555
    glColor3f( .25, .25, .25 );
 
556
  glVertex2i( text_x_offset+1, 1 );     glVertex2i( w-1, 1 );
 
557
  glVertex2i( text_x_offset+1, 1 );     glVertex2i( text_x_offset+1, h-1 );
 
558
 
 
559
  glColor3f( .75, .75, .75 );
 
560
  glVertex2i( text_x_offset+1, h-1 );     glVertex2i( w-1, h-1 );
 
561
  glVertex2i( w-1, h-1 );                 glVertex2i( w-1, 1 );
 
562
  glEnd();
 
563
 
 
564
  /** Find where to draw the text **/
 
565
  update_substring_bounds();
 
566
  draw_text(0,0);
 
567
  
 
568
  draw_insertion_pt();
 
569
}
 
570
 
 
571
 
 
572
 
 
573
/************************** GLUI_EditText::update_substring_bounds() *********/
 
574
 
 
575
int    GLUI_EditText::update_substring_bounds( void )
 
576
{
 
577
  int box_width;
 
578
  int text_len = (int)text.length();
 
579
  int old_start, old_end;
 
580
 
 
581
  old_start = substring_start;
 
582
  old_end = substring_end;
 
583
 
 
584
  /*** Calculate the width of the usable area of the edit box ***/
 
585
  box_width = MAX( this->w - this->text_x_offset 
 
586
                   - 4     /*  2 * the two-line box border */ 
 
587
                   - 2 * GLUI_EDITTEXT_BOXINNERMARGINX, 0 );
 
588
 
 
589
  CLAMP( substring_end, 0, MAX(text_len-1,0) );
 
590
  CLAMP( substring_start, 0, MAX(text_len-1,0) );
 
591
 
 
592
  if ( debug )    dump( stdout, "-> UPDATE SS" );
 
593
 
 
594
  if ( insertion_pt >= 0 AND 
 
595
       insertion_pt < substring_start ) {   /* cursor moved left */
 
596
    substring_start = insertion_pt;
 
597
 
 
598
    while ( substring_width( substring_start, substring_end ) > box_width )
 
599
      substring_end--;
 
600
  }
 
601
  else if ( insertion_pt > substring_end ) {  /* cursor moved right */
 
602
    substring_end = insertion_pt-1;
 
603
 
 
604
    while ( substring_width( substring_start, substring_end ) > box_width )
 
605
      substring_start++;
 
606
  }
 
607
  else {   /* cursor is within old substring bounds */
 
608
    if ( last_insertion_pt > insertion_pt ) {  /* cursor moved left */
 
609
    }
 
610
    else {
 
611
      while ( substring_width( substring_start, substring_end ) > box_width )
 
612
        substring_end--;
 
613
 
 
614
      while(substring_end < text_len-1 
 
615
            AND substring_width( substring_start, substring_end ) <= box_width)
 
616
        substring_end++;
 
617
    }
 
618
  }
 
619
 
 
620
  while ( substring_width( substring_start, substring_end ) > box_width )
 
621
    substring_end--;
 
622
 
 
623
  last_insertion_pt = insertion_pt;
 
624
 
 
625
  /*** No selection if not enabled ***/
 
626
  if ( NOT enabled ) {
 
627
    sel_start = sel_end = 0;
 
628
  }
 
629
 
 
630
  if ( debug )    dump( stdout, "<- UPDATE SS" );
 
631
 
 
632
  if ( substring_start == old_start AND substring_end == old_end )
 
633
    return false;  /*** bounds did not change ***/
 
634
  else 
 
635
    return true;   /*** bounds did change ***/
 
636
}
 
637
 
 
638
 
 
639
/********************************* GLUI_EditText::update_x_offsets() *********/
 
640
 
 
641
void    GLUI_EditText::update_x_offsets( void )
 
642
{
 
643
}
 
644
 
 
645
 
 
646
/********************************* GLUI_EditText::draw_text() ****************/
 
647
 
 
648
void    GLUI_EditText::draw_text( int x, int y )
 
649
{
 
650
  GLUI_DRAWINGSENTINAL_IDIOM
 
651
  int text_x, i, sel_lo, sel_hi;
 
652
 
 
653
  if ( debug )    dump( stdout, "-> DRAW_TEXT" );
 
654
 
 
655
  if ( NOT draw_text_only ) {
 
656
    if ( enabled )
 
657
      glColor3f( 1., 1., 1. );
 
658
    else
 
659
      set_to_bkgd_color();
 
660
    glDisable( GL_CULL_FACE );
 
661
    glBegin( GL_QUADS );
 
662
    glVertex2i( text_x_offset+2, 2 );     glVertex2i( w-2, 2 );
 
663
    glVertex2i( w-2, h-2 );               glVertex2i( text_x_offset+2, h-2 );
 
664
    glEnd();
 
665
  }
 
666
 
 
667
  /** Find where to draw the text **/
 
668
 
 
669
  text_x = text_x_offset + 2 + GLUI_EDITTEXT_BOXINNERMARGINX;
 
670
 
 
671
  /*printf( "text_x: %d      substr_width: %d     start/end: %d/%d\n",
 
672
    text_x,     substring_width( substring_start, substring_end ),
 
673
    substring_start, substring_end );
 
674
    */
 
675
  /** Find lower and upper selection bounds **/
 
676
  sel_lo = MIN(sel_start, sel_end );
 
677
  sel_hi = MAX(sel_start, sel_end );
 
678
 
 
679
  int sel_x_start, sel_x_end, delta;
 
680
 
 
681
  /** Draw selection area dark **/
 
682
  if ( sel_start != sel_end ) {
 
683
    sel_x_start = text_x;
 
684
    sel_x_end   = text_x;
 
685
    for( i=substring_start; i<=substring_end; i++ ) {
 
686
      delta = char_width( text[i] );
 
687
 
 
688
      if ( i < sel_lo ) {
 
689
        sel_x_start += delta;
 
690
        sel_x_end   += delta;
 
691
      }
 
692
      else if ( i < sel_hi ) {
 
693
        sel_x_end   += delta;
 
694
      }
 
695
    }
 
696
 
 
697
    glColor3f( 0.0f, 0.0f, .6f );
 
698
    glBegin( GL_QUADS );
 
699
    glVertex2i( sel_x_start, 2 );    glVertex2i( sel_x_end, 2 );
 
700
    glVertex2i( sel_x_end, h-2 );    glVertex2i( sel_x_start, h-2 );
 
701
    glEnd();
 
702
  }
 
703
   
 
704
 
 
705
  if ( sel_start == sel_end ) {   /* No current selection */
 
706
    if ( enabled )
 
707
      glColor3b( 0, 0, 0 );
 
708
    else
 
709
      glColor3b( 32, 32, 32 );
 
710
      
 
711
    glRasterPos2i( text_x, 13);
 
712
    for( i=substring_start; i<=substring_end; i++ ) {
 
713
      glutBitmapCharacter( get_font(), this->text[i] );
 
714
    }
 
715
  }
 
716
  else {                          /* There is a selection */
 
717
    int x = text_x;
 
718
    for( i=substring_start; i<=substring_end; i++ ) {
 
719
      if ( IN_BOUNDS( i, sel_lo, sel_hi-1)) { /* This character is selected */
 
720
        glColor3f( 1., 1., 1. );
 
721
        glRasterPos2i( x, 13);
 
722
        glutBitmapCharacter( get_font(), this->text[i] );
 
723
      }
 
724
      else {
 
725
        glColor3f( 0., 0., 0. );
 
726
        glRasterPos2i( x, 13);
 
727
        glutBitmapCharacter( get_font(), this->text[i] );
 
728
      }
 
729
      
 
730
      x += char_width( text[i] );
 
731
    }
 
732
  }
 
733
 
 
734
  if ( debug )    dump( stdout, "<- DRAW_TEXT" );  
 
735
}
 
736
 
 
737
 
 
738
/******************************** GLUI_EditText::find_insertion_pt() *********/
 
739
/* This function returns the character numer *before which* the insertion    */
 
740
/* point goes                                                                */
 
741
 
 
742
int  GLUI_EditText::find_insertion_pt( int x, int y )
 
743
{
 
744
  int curr_x, i;
 
745
 
 
746
  /*** See if we clicked outside box ***/
 
747
  if ( x < this->x_abs + text_x_offset )
 
748
    return -1;
 
749
 
 
750
  /* We move from right to left, looking to see if the mouse was clicked
 
751
     to the right of the ith character */
 
752
 
 
753
  curr_x = this->x_abs + text_x_offset 
 
754
    + substring_width( substring_start, substring_end )
 
755
    + 2                             /* The edittext box has a 2-pixel margin */
 
756
    + GLUI_EDITTEXT_BOXINNERMARGINX;   /** plus this many pixels blank space
 
757
                                         between the text and the box       **/
 
758
 
 
759
  /*** See if we clicked in an empty box ***/
 
760
  if ( (int) text.length() == 0 ) 
 
761
    return 0;
 
762
 
 
763
  /** find mouse click in text **/
 
764
  for( i=substring_end; i>=substring_start; i-- ) {
 
765
    curr_x -= char_width( text[i] );
 
766
 
 
767
    if ( x > curr_x ) {
 
768
      /*      printf( "-> %d\n", i );              */
 
769
      
 
770
      return i+1;
 
771
    }
 
772
  }
 
773
 
 
774
  return 0;
 
775
 
 
776
  /* Well, the mouse wasn't after any of the characters...see if it's
 
777
     before the beginning of the substring */
 
778
  if ( 0 ) {
 
779
    if ( x > (x_abs + text_x_offset + 2 ) )
 
780
      return substring_start;
 
781
    
 
782
    return -1; /* Nothing found */
 
783
  }
 
784
}
 
785
 
 
786
 
 
787
/******************************** GLUI_EditText::draw_insertion_pt() *********/
 
788
 
 
789
void     GLUI_EditText::draw_insertion_pt( void )
 
790
{
 
791
  int curr_x, i;
 
792
 
 
793
  if ( NOT can_draw() )
 
794
    return;
 
795
 
 
796
  /*** Don't draw insertion pt if control is disabled ***/
 
797
  if ( NOT enabled )
 
798
    return;
 
799
 
 
800
  if ( debug )    dump( stdout, "-> DRAW_INS_PT" );
 
801
 
 
802
  if ( sel_start != sel_end OR insertion_pt < 0 ) {
 
803
    return;  /* Don't draw insertion point if there is a current selection */
 
804
  }
 
805
 
 
806
  /*    printf( "insertion pt: %d\n", insertion_pt );              */
 
807
 
 
808
  curr_x = this->x_abs + text_x_offset 
 
809
    + substring_width( substring_start, substring_end )
 
810
    + 2                             /* The edittext box has a 2-pixel margin */
 
811
    + GLUI_EDITTEXT_BOXINNERMARGINX;   /** plus this many pixels blank space
 
812
                                         between the text and the box       **/
 
813
 
 
814
  for( i=substring_end; i>=insertion_pt; i-- ) {
 
815
    curr_x -= char_width( text[i] ); 
 
816
  }  
 
817
 
 
818
  glColor3f( 0.0, 0.0, 0.0 );
 
819
  glBegin( GL_LINE_LOOP );
 
820
  /***
 
821
    glVertex2i( curr_x, y_abs + 4 );
 
822
    glVertex2i( curr_x, y_abs + 4 );
 
823
    glVertex2i( curr_x, y_abs + h - 3 );
 
824
    glVertex2i( curr_x, y_abs + h - 3 );
 
825
    ***/
 
826
  curr_x -= x_abs;
 
827
  glVertex2i( curr_x, 0 + 4 );
 
828
  glVertex2i( curr_x, 0 + 4 );
 
829
  glVertex2i( curr_x, 0 + h - 3 );
 
830
  glVertex2i( curr_x, 0 + h - 3 );
 
831
  glEnd();
 
832
 
 
833
  if ( debug )    dump( stdout, "-> DRAW_INS_PT" );
 
834
}
 
835
 
 
836
 
 
837
 
 
838
/******************************** GLUI_EditText::substring_width() *********/
 
839
 
 
840
int  GLUI_EditText::substring_width( int start, int end )
 
841
{
 
842
  int i, width;
 
843
 
 
844
  width = 0;
 
845
 
 
846
  for( i=start; i<=end; i++ )
 
847
    width += char_width( text[i] ); 
 
848
 
 
849
  return width;
 
850
}
 
851
 
 
852
 
 
853
/***************************** GLUI_EditText::update_and_draw_text() ********/
 
854
 
 
855
void   GLUI_EditText::update_and_draw_text( void )
 
856
{
 
857
  if ( NOT can_draw() )
 
858
    return;
 
859
 
 
860
  update_substring_bounds();
 
861
  /*  printf( "ss: %d/%d\n", substring_start, substring_end );                  */
 
862
 
 
863
  redraw();
 
864
}
 
865
 
 
866
 
 
867
/********************************* GLUI_EditText::special_handler() **********/
 
868
 
 
869
int    GLUI_EditText::special_handler( int key,int modifiers )
 
870
{
 
871
  if ( NOT glui )
 
872
    return false;
 
873
  
 
874
  if ( debug )
 
875
    printf( "SPECIAL:%d - mod:%d   subs:%d/%d  ins:%d  sel:%d/%d\n", 
 
876
            key, modifiers, substring_start, substring_end,insertion_pt,
 
877
            sel_start, sel_end );        
 
878
 
 
879
  if ( key == GLUT_KEY_LEFT ) {
 
880
    if ( (modifiers & GLUT_ACTIVE_CTRL) != 0 ) {
 
881
      insertion_pt = find_word_break( insertion_pt, -1 );
 
882
    }
 
883
    else {
 
884
      insertion_pt--;
 
885
    }
 
886
  }
 
887
  else if ( key == GLUT_KEY_RIGHT ) {
 
888
    if ( (modifiers & GLUT_ACTIVE_CTRL) != 0 ) {
 
889
      insertion_pt = find_word_break( insertion_pt, +1 );
 
890
    }
 
891
    else {
 
892
      insertion_pt++;
 
893
    }
 
894
  }
 
895
  else if ( key == GLUT_KEY_HOME ) {
 
896
    insertion_pt = 0;
 
897
  }
 
898
  else if ( key == GLUT_KEY_END ) {
 
899
    insertion_pt = (int) text.length();
 
900
  }
 
901
 
 
902
  /*** Update selection if shift key is down ***/
 
903
  if ( (modifiers & GLUT_ACTIVE_SHIFT ) != 0 )
 
904
    sel_end = insertion_pt;
 
905
  else 
 
906
    sel_start = sel_end = insertion_pt;
 
907
  
 
908
 
 
909
  CLAMP( insertion_pt, 0, (int) text.length()); /* Make sure insertion_pt 
 
910
                                                                                      is in bounds */
 
911
  CLAMP( sel_start, 0, (int) text.length()); /* Make sure insertion_pt 
 
912
                                                                                    is in bounds */
 
913
  CLAMP( sel_end, 0, (int) text.length()); /* Make sure insertion_pt 
 
914
                                                                             is in bounds */
 
915
                                              
 
916
  /******** Now redraw text ***********/
 
917
  if ( can_draw())
 
918
    update_and_draw_text();
 
919
 
 
920
  return true;
 
921
}
 
922
 
 
923
 
 
924
/****************************** GLUI_EditText::find_word_break() **********/
 
925
/* It looks either left or right (depending on value of 'direction'       */
 
926
/* for the beginning of the next 'word', where word are characters        */
 
927
/* separated by one of the following tokens:  " :-.,"                     */
 
928
/* If there is no next word in the specified direction, this returns      */
 
929
/* the beginning of 'text', or the very end.                              */
 
930
 
 
931
int    GLUI_EditText::find_word_break( int start, int direction )
 
932
{
 
933
  int    i, j;
 
934
  char   *breaks = " :-.,";
 
935
  int     num_break_chars = (int)strlen(breaks), text_len = (int)text.length();
 
936
  int     new_pt;
 
937
 
 
938
  /** If we're moving left, we have to start two back, in case we're either
 
939
  already at the beginning of a word, or on a separating token.  
 
940
  Otherwise, this function would just return the word we're already at **/
 
941
  if ( direction == -1 ) {
 
942
    start -= 2;
 
943
  }
 
944
 
 
945
  /***** Iterate over text in the specified direction *****/
 
946
  for ( i=start; i >= 0 AND i < text_len; i += direction ) {
 
947
 
 
948
    /** For each character in text, iterate over list of separating tokens **/
 
949
    for( j=0; j<num_break_chars; j++ ) {
 
950
      if ( text[i] == breaks[j] ) {
 
951
 
 
952
        /** character 'i' is a separating token, so we return i+1 **/
 
953
        new_pt = i + 1;
 
954
 
 
955
        CLAMP( new_pt, 0, text_len );
 
956
 
 
957
        return new_pt;
 
958
      }
 
959
    }
 
960
  }
 
961
 
 
962
  if ( direction > 0 )  /* Return the end of string */
 
963
    return text_len;
 
964
  else                  /* Return the beginning of the text */
 
965
    return 0;
 
966
}
 
967
 
 
968
 
 
969
/********************************** GLUI_EditText::clear_substring() ********/
 
970
 
 
971
void   GLUI_EditText::clear_substring( int start, int end )
 
972
{
 
973
  int i;
 
974
 
 
975
  /*
 
976
  printf( "clearing: %d-%d   '", start,end);
 
977
  for(i=start;i<end;i++ )
 
978
  putchar(text[i]);
 
979
  printf( "'\n" ); flushout;
 
980
  */
 
981
  /*** See if we're deleting a period in a float data-type box ***/
 
982
  if ( data_type == GLUI_EDITTEXT_FLOAT ) {
 
983
    for( i=start; i<end; i++ )
 
984
      if ( text[i] == '.' )
 
985
        num_periods = 0;
 
986
  }
 
987
 
 
988
  text.erase(start,end-start);
 
989
}
 
990
 
 
991
 
 
992
 
 
993
/************************************ GLUI_EditText::update_size() **********/
 
994
 
 
995
void   GLUI_EditText::update_size( void )
 
996
{
 
997
  int text_size, delta;
 
998
 
 
999
  if ( NOT glui )
 
1000
    return;
 
1001
 
 
1002
  text_size = string_width( name );
 
1003
 
 
1004
  delta = 0;
 
1005
  if ( text_x_offset < text_size +2 )
 
1006
    delta = text_size+2-text_x_offset;
 
1007
 
 
1008
  text_x_offset += delta;
 
1009
  /*  w += delta;              */
 
1010
 
 
1011
  if ( data_type == GLUI_EDITTEXT_TEXT OR 
 
1012
       data_type == GLUI_EDITTEXT_FLOAT) {
 
1013
    if ( w < text_x_offset + GLUI_EDITTEXT_MIN_TEXT_WIDTH )
 
1014
      w = text_x_offset + GLUI_EDITTEXT_MIN_TEXT_WIDTH;
 
1015
  }
 
1016
  else if ( data_type == GLUI_EDITTEXT_INT ) {
 
1017
    if ( w < text_x_offset + GLUI_EDITTEXT_MIN_INT_WIDTH )
 
1018
      w = text_x_offset + GLUI_EDITTEXT_MIN_INT_WIDTH;
 
1019
  }
 
1020
}
 
1021
 
 
1022
 
 
1023
/****************************** GLUI_EditText::set_text() **********/
 
1024
 
 
1025
void    GLUI_EditText::set_text( const char *new_text )
 
1026
{
 
1027
  text=new_text;
 
1028
  substring_start = 0;
 
1029
  substring_end   = (int) text.length() - 1;
 
1030
  insertion_pt    = -1;
 
1031
  sel_start       = 0;
 
1032
  sel_end         = 0;
 
1033
 
 
1034
  if ( can_draw() )
 
1035
    update_and_draw_text();
 
1036
 
 
1037
  /** Update the spinner, if we have one **/
 
1038
  if ( spinner ) {
 
1039
    spinner->float_val = this->float_val;
 
1040
    spinner->int_val   = this->int_val;
 
1041
  }
 
1042
 
 
1043
  /*** Now update the live variable ***/
 
1044
  output_live(true);
 
1045
}
 
1046
 
 
1047
 
 
1048
/******************************* GLUI_EditText::set_float_val() ************/
 
1049
 
 
1050
void   GLUI_EditText::set_float_val( float new_val )
 
1051
{
 
1052
  if ( has_limits == GLUI_LIMIT_CLAMP ) {
 
1053
    /*** Clamp the new value to the existing limits ***/
 
1054
 
 
1055
    CLAMP( new_val, float_low, float_high );
 
1056
  } 
 
1057
  else if ( has_limits == GLUI_LIMIT_WRAP ) {
 
1058
    /*** Clamp the value cyclically to the limits - that is, if the
 
1059
      value exceeds the max, set it the the minimum, and conversely ***/
 
1060
 
 
1061
    if ( new_val < float_low )
 
1062
      new_val = float_high;
 
1063
    if ( new_val > float_high )
 
1064
      new_val = float_low;
 
1065
  }
 
1066
 
 
1067
  float_val = new_val;
 
1068
  int_val   = (int) new_val;  /* Mirror the value as an int, too */
 
1069
  
 
1070
  set_numeric_text();
 
1071
}
 
1072
 
 
1073
 
 
1074
/********************************** GLUI_EditText::set_int_val() ************/
 
1075
 
 
1076
void   GLUI_EditText::set_int_val( int new_val )
 
1077
{
 
1078
  if ( has_limits == GLUI_LIMIT_CLAMP ) {
 
1079
    /*** Clamp the new value to the existing limits ***/
 
1080
 
 
1081
    CLAMP( new_val, int_low, int_high );
 
1082
  }
 
1083
  else if ( has_limits == GLUI_LIMIT_WRAP ) {
 
1084
    /*** Clamp the value cyclically to the limits - that is, if the
 
1085
      value exceeds the max, set it the the minimum, and conversely ***/
 
1086
 
 
1087
    if ( new_val < int_low )
 
1088
      new_val = int_high;
 
1089
    if ( new_val > int_high )
 
1090
      new_val = int_low;
 
1091
  }
 
1092
 
 
1093
  int_val   = new_val;
 
1094
  float_val = (float) new_val;   /* We mirror the value as a float, too */
 
1095
 
 
1096
  set_numeric_text();
 
1097
}
 
1098
 
 
1099
 
 
1100
/********************************* GLUI_EditText::set_float_limits() *********/
 
1101
 
 
1102
void GLUI_EditText::set_float_limits( float low, float high, int limit_type )
 
1103
{
 
1104
  has_limits  = limit_type;
 
1105
  float_low   = low;
 
1106
  float_high  = high;
 
1107
  
 
1108
  if ( NOT IN_BOUNDS( float_val, float_low, float_high ))
 
1109
    set_float_val( float_low );
 
1110
 
 
1111
  int_low     = (int) float_low;
 
1112
  int_high    = (int) float_high;
 
1113
}
 
1114
 
 
1115
 
 
1116
/*********************************** GLUI_EditText::set_int_limits() *********/
 
1117
 
 
1118
void   GLUI_EditText::set_int_limits( int low, int high, int limit_type )
 
1119
{
 
1120
  has_limits  = limit_type;
 
1121
  int_low     = low;
 
1122
  int_high    = high;
 
1123
 
 
1124
  if ( NOT IN_BOUNDS( int_val, int_low, int_high ))
 
1125
    set_int_val( int_low );
 
1126
 
 
1127
  float_low   = (float) int_low;
 
1128
  float_high  = (float) int_high;
 
1129
}
 
1130
 
 
1131
 
 
1132
/************************************ GLUI_EditText::set_numeric_text() ******/
 
1133
 
 
1134
void    GLUI_EditText::set_numeric_text( void )
 
1135
{
 
1136
  char buf_num[200];
 
1137
  int  i, text_len;
 
1138
 
 
1139
  if ( data_type == GLUI_EDITTEXT_FLOAT ) {
 
1140
    sprintf( buf_num, "%#g", float_val );
 
1141
 
 
1142
    num_periods = 0;
 
1143
    text_len = (int) strlen(buf_num);
 
1144
    for ( i=0; i<text_len; i++ )
 
1145
      if ( buf_num[i] == '.' )
 
1146
        num_periods++;
 
1147
 
 
1148
    /* Now remove trailing zeros */
 
1149
    if ( num_periods > 0 ) {
 
1150
      text_len = (int) strlen(buf_num);
 
1151
      for ( i=text_len-1; i>0; i-- ) {
 
1152
        if ( buf_num[i] == '0' AND buf_num[i-1] != '.' )
 
1153
          buf_num[i] = '\0';
 
1154
        else 
 
1155
          break;
 
1156
      }
 
1157
    }
 
1158
    set_text( buf_num );
 
1159
  }
 
1160
  else {
 
1161
    sprintf( buf_num, "%d", int_val );
 
1162
    set_text( buf_num );
 
1163
  }
 
1164
    
 
1165
}
 
1166
 
 
1167
 
 
1168
/*************************************** GLUI_EditText::dump() **************/
 
1169
 
 
1170
void   GLUI_EditText::dump( FILE *out, const char *name )
 
1171
{
 
1172
  fprintf( out, 
 
1173
           "%s (edittext@%p):  ins_pt:%d  subs:%d/%d  sel:%d/%d   len:%d\n",
 
1174
           name, this, 
 
1175
           insertion_pt,
 
1176
           substring_start,
 
1177
           substring_end,
 
1178
           sel_start,
 
1179
           sel_end,
 
1180
           (int) text.length());
 
1181
}
 
1182
 
 
1183
 
 
1184
/**************************************** GLUI_EditText::mouse_over() ********/
 
1185
 
 
1186
int    GLUI_EditText::mouse_over( int state, int x, int y )
 
1187
{
 
1188
  if ( state ) {
 
1189
    /*  curr_cursor = GLUT_CURSOR_TEXT;              */
 
1190
    glutSetCursor( GLUT_CURSOR_TEXT );
 
1191
  }
 
1192
  else {
 
1193
    /*    printf( "OUT\n" );              */
 
1194
    glutSetCursor( GLUT_CURSOR_LEFT_ARROW );
 
1195
  }
 
1196
 
 
1197
  return true;
 
1198
}