« back to all changes in this revision
Viewing changes to glui_add_controls.cpp
- browse files at revision 1
- compare with another revision
- download diff
- download tarball
- view history from revision 1
- Committer: Bazaar Package Importer
- Author(s): Marcelo E. Magallon
- Date: 2001-09-23 12:57:28 UTC
- Revision ID: james.westby@ubuntu.com-20010923125728-qbts7xit2eg1ogo2
Tags: upstream-2.1.0.beta
Import upstream version 2.1.0.beta
- files added:
- msvc
added
removed
glui_add_controls.cpp
1
/****************************************************************************
2
3
GLUI User Interface Toolkit
4
---------------------------
5
6
glui_add_controls.cpp - Routines for adding controls to a GLUI window
7
8
9
--------------------------------------------------
10
11
Copyright (c) 1998 Paul Rademacher
12
13
This program is freely distributable without licensing fees and is
14
provided without guarantee or warrantee expressed or implied. This
15
program is -not- in the public domain.
16
17
*****************************************************************************/
18
19
#include "glui.h"
20
#include "stdinc.h"
21
#include <GL/glut.h>
22
23
24
/*********************************** GLUI:: add_checkbox() ************/
25
26
GLUI_Checkbox *GLUI:: add_checkbox( char *name, int *value_ptr,
27
int id, GLUI_Update_CB callback )
28
{
29
return add_checkbox_to_panel( main_panel,
30
name, value_ptr, id, callback );
31
}
32
33
34
/*********************************** GLUI:: add_checkbox_to_panel() **********/
35
36
GLUI_Checkbox *GLUI::add_checkbox_to_panel( GLUI_Panel *panel,
37
char *name, int *value_ptr,
38
int id,
39
GLUI_Update_CB callback )
40
{
41
GLUI_Checkbox *control;
42
43
control = new GLUI_Checkbox;
44
45
if ( control ) {
46
control->set_ptr_val( value_ptr );
47
control->user_id = id;
48
control->set_name( name );
49
control->callback = callback;
50
51
add_control( panel, control );
52
53
control->init_live();
54
55
return control;
56
}
57
else {
58
return NULL;
59
}
60
}
61
62
63
64
/************************************ GLUI_Main::add_control() **************/
65
66
int GLUI_Main::add_control( GLUI_Node *parent, GLUI_Control *control )
67
{
68
GLUI_Control *parent_control;
69
70
/*** Collapsible nodes have to be handled differently, b/c the first and
71
last children are swapped in and out ***/
72
parent_control = ((GLUI_Control*)parent);
73
if ( parent_control->collapsible == true ) {
74
if ( NOT parent_control->is_open ) {
75
/** Swap in the original first and last children **/
76
parent_control->child_head = parent_control->collapsed_node.child_head;
77
parent_control->child_tail = parent_control->collapsed_node.child_tail;
78
79
/*** Link this control ***/
80
control->link_this_to_parent_last( parent );
81
82
/** Swap the children back out ***/
83
parent_control->collapsed_node.child_head = parent_control->child_head;
84
parent_control->collapsed_node.child_tail = parent_control->child_tail;
85
parent_control->child_head = NULL;
86
parent_control->child_tail = NULL;
87
}
88
else {
89
control->link_this_to_parent_last( parent );
90
}
91
}
92
else {
93
control->link_this_to_parent_last( parent );
94
}
95
control->glui = (GLUI*) this;
96
control->update_size();
97
control->enabled = ((GLUI_Control*) parent)->enabled;
98
control->glui->refresh();
99
100
/** Now set the 'hidden' var based on the parent **/
101
if ( parent_control->hidden OR
102
(parent_control->collapsible AND NOT parent_control->is_open ) )
103
{
104
control->hidden = true;
105
}
106
107
return true;
108
}
109
110
111
/********************************************* GLUI::add_panel() *************/
112
113
GLUI_Panel *GLUI::add_panel( char *name, int type )
114
{
115
return add_panel_to_panel( main_panel, name, type );
116
}
117
118
119
/**************************************** GLUI::add_panel_to_panel() *********/
120
121
GLUI_Panel *GLUI::add_panel_to_panel( GLUI_Panel *parent_panel,
122
char *name, int type )
123
{
124
GLUI_Panel *panel;
125
126
panel = new GLUI_Panel;
127
128
if ( panel ) {
129
panel->set_name( name );
130
panel->user_id = -1;
131
panel->int_val = type;
132
133
add_control( parent_panel, panel );
134
135
return panel;
136
}
137
else {
138
return NULL;
139
}
140
}
141
142
143
/***************************** GLUI::add_radiogroup() ***************/
144
145
GLUI_RadioGroup *GLUI::add_radiogroup( int *value_ptr,
146
int user_id, GLUI_Update_CB callback)
147
{
148
return add_radiogroup_to_panel( main_panel, value_ptr,
149
user_id, callback );
150
}
151
152
153
/***************************** GLUI::add_radiogroup_to_panel() ***************/
154
155
GLUI_RadioGroup *GLUI::add_radiogroup_to_panel( GLUI_Panel *panel,
156
int *value_ptr,
157
int user_id, GLUI_Update_CB callback)
158
{
159
GLUI_RadioGroup *control;
160
GLUI_String buf;
161
162
control = new GLUI_RadioGroup;
163
164
if ( control ) {
165
control->set_ptr_val( value_ptr );
166
if ( value_ptr ) {
167
control->int_val = *value_ptr; /** Can't call set_int_val(), b/c that
168
function will try to call the
169
callback, etc */
170
/** Actually, maybe not **/
171
control->last_live_int = *value_ptr;
172
}
173
174
control->user_id = user_id;
175
sprintf( buf, "RadioGroup: %p", control );
176
control->set_name( buf );
177
control->callback = callback;
178
179
add_control( panel, control );
180
181
control->init_live();
182
183
return control;
184
}
185
else {
186
return NULL;
187
}
188
189
}
190
191
192
/***************************** GLUI::add_radiobutton_to_group() *************/
193
194
GLUI_RadioButton *GLUI::add_radiobutton_to_group( GLUI_RadioGroup *group,
195
char *name )
196
{
197
GLUI_RadioButton *control;
198
199
if ( group->type != GLUI_CONTROL_RADIOGROUP ) {
200
/*fprintf( stderr, "ERROR: Trying to add radiobutton to non-radiogroup\n" ); */
201
/*fflush( stderr ); */
202
return NULL;
203
}
204
205
control = new GLUI_RadioButton;
206
207
if ( control ) {
208
control->set_int_val( 0 );
209
/*int_val = 0; */
210
211
/** A radio button's user id is always its ordinal number (zero-indexed)
212
within the group */
213
control->user_id = group->num_buttons;
214
group->num_buttons++; /* Increments radiogroup's button count */
215
control->set_name( name );
216
control->group = group;
217
218
add_control( group, control );
219
220
/*** Now update button states ***/
221
group->set_int_val( group->int_val ); /* This tells the group to
222
reset itself to its
223
current value, thereby
224
updating all its buttons */
225
226
return control;
227
}
228
else {
229
return NULL;
230
}
231
232
}
233
234
235
/********************************** GLUI::add_statictext() ************/
236
237
GLUI_StaticText *GLUI::add_statictext( char *name )
238
{
239
return add_statictext_to_panel( main_panel, name );
240
}
241
242
243
/******************************* GLUI::add_statictext_to_panel() **********/
244
245
GLUI_StaticText *GLUI::
246
add_statictext_to_panel( GLUI_Panel *panel, char *name )
247
{
248
GLUI_StaticText *control;
249
250
control = new GLUI_StaticText;
251
252
if ( control ) {
253
control->set_name( name );
254
add_control( panel, control );
255
256
return control;
257
}
258
else {
259
return NULL;
260
}
261
262
}
263
264
265
/***************************************** GLUI:: add_button() ************/
266
267
GLUI_Button *GLUI:: add_button( char *name,
268
int id, GLUI_Update_CB callback )
269
{
270
return add_button_to_panel( main_panel,
271
name, id, callback );
272
}
273
274
275
/*********************************** GLUI:: add_button_to_panel() **********/
276
277
GLUI_Button *GLUI::add_button_to_panel( GLUI_Panel *panel,
278
char *name,
279
int id,
280
GLUI_Update_CB callback )
281
{
282
GLUI_Button *control;
283
284
control = new GLUI_Button;
285
286
if ( control ) {
287
/* control->set_ptr_val( value_ptr );
288
if ( value_ptr ) {
289
control->set_int_val( *value_ptr );
290
}*/
291
292
control->user_id = id;
293
control->callback = callback;
294
control->set_name( name );
295
296
add_control( panel, control );
297
298
return control;
299
}
300
else {
301
return NULL;
302
}
303
}
304
305
306
307
/********************************** GLUI::add_separator() ************/
308
309
void GLUI::add_separator( void )
310
{
311
add_separator_to_panel( main_panel );
312
}
313
314
315
/******************************* GLUI::add_separator_to_panel() **********/
316
317
void GLUI::add_separator_to_panel( GLUI_Panel *panel )
318
{
319
GLUI_Separator *control = new GLUI_Separator;
320
321
if ( control ) {
322
add_control( panel, control );
323
}
324
}
325
326
327
/********************************** GLUI::add_edittext() ************/
328
329
GLUI_EditText *GLUI::add_edittext( char *name,
330
int data_type, void *data,
331
int id, GLUI_Update_CB callback)
332
{
333
return add_edittext_to_panel( main_panel, name, data_type, data,
334
id, callback );
335
}
336
337
338
/******************************* GLUI::add_edittext_to_panel() **********/
339
340
GLUI_EditText *GLUI::
341
add_edittext_to_panel( GLUI_Panel *panel, char *name,
342
int data_type, void *data,
343
int id, GLUI_Update_CB callback)
344
{
345
GLUI_EditText *control;
346
347
control = new GLUI_EditText;
348
349
if ( control ) {
350
control->set_name( name );
351
352
control->data_type = data_type;
353
control->ptr_val = data;
354
control->user_id = id;
355
control->callback = callback;
356
357
if ( data_type == GLUI_EDITTEXT_TEXT ) {
358
control->live_type = GLUI_LIVE_TEXT;
359
}
360
else if ( data_type == GLUI_EDITTEXT_INT ) {
361
control->live_type = GLUI_LIVE_INT;
362
if ( data == NULL )
363
control->set_int_val(control->int_val); /** Set to some default, in case of no live var **/
364
}
365
else if ( data_type == GLUI_EDITTEXT_FLOAT ) {
366
control->live_type = GLUI_LIVE_FLOAT;
367
control->num_periods = 1;
368
if ( data == NULL )
369
control->set_float_val(control->float_val); /** Set to some default, in case of no live var **/
370
}
371
else {
372
return NULL; /* Did not pass in a valid data type */
373
}
374
375
add_control( panel, control );
376
377
control->init_live();
378
379
return control;
380
}
381
else {
382
return NULL;
383
}
384
385
}
386
387
388
/********************************** GLUI::add_spinner() ************/
389
390
GLUI_Spinner *GLUI::add_spinner( char *name,
391
int data_type, void *data,
392
int id, GLUI_Update_CB callback)
393
{
394
return add_spinner_to_panel( main_panel, name, data_type, data,
395
id, callback );
396
}
397
398
399
/******************************* GLUI::add_spinner_to_panel() **********/
400
401
GLUI_Spinner *GLUI::
402
add_spinner_to_panel( GLUI_Panel *panel, char *name,
403
int data_type, void *data,
404
int id, GLUI_Update_CB callback)
405
{
406
GLUI_Spinner *control;
407
int text_type;
408
409
control = new GLUI_Spinner;
410
411
if ( NOT strcmp( name, "Spinner Test" ))
412
id=id;
413
414
415
if ( control ) {
416
if ( data_type == GLUI_SPINNER_INT ) {
417
text_type = GLUI_EDITTEXT_INT;
418
/* control->live_type = GLUI_LIVE_INT; */
419
}
420
else if ( data_type == GLUI_SPINNER_FLOAT ) {
421
text_type = GLUI_EDITTEXT_FLOAT;
422
/* control->live_type = GLUI_LIVE_FLOAT; */
423
}
424
else {
425
return NULL; /* Did not pass in a valid data type */
426
}
427
428
GLUI_EditText *edittext =
429
add_edittext_to_panel( (GLUI_Panel*) control, name, text_type, data,
430
id, callback );
431
432
if ( edittext ) {
433
control->set_name( name );
434
control->edittext = edittext; /* Link the edittext to the spinner */
435
/* control->ptr_val = data; */
436
control->user_id = id;
437
control->data_type = data_type;
438
control->callback = callback;
439
440
edittext->spinner = control; /* Link the spinner to the edittext */
441
442
add_control( panel, control );
443
444
return control;
445
}
446
else {
447
return NULL;
448
}
449
}
450
else {
451
return NULL;
452
}
453
454
}
455
456
457
/********************************** GLUI::add_column() ************/
458
459
void GLUI::add_column( int draw_bar )
460
{
461
add_column_to_panel( main_panel, draw_bar );
462
}
463
464
465
/******************************* GLUI::add_column_to_panel() **********/
466
467
void GLUI::add_column_to_panel( GLUI_Panel *panel, int draw_bar )
468
{
469
GLUI_Column *control = new GLUI_Column;
470
471
if ( control ) {
472
control->int_val = draw_bar; /* Whether to draw vertical bar or not */
473
474
add_control( panel, control );
475
}
476
else {
477
}
478
}
479
480
481
/*********************************** GLUI:: add_listbox() ************/
482
483
GLUI_Listbox *GLUI:: add_listbox( char *name, int *value_ptr,
484
int id, GLUI_Update_CB callback )
485
{
486
return add_listbox_to_panel( main_panel,
487
name, value_ptr, id, callback );
488
}
489
490
491
/*********************************** GLUI:: add_listbox_to_panel() **********/
492
493
GLUI_Listbox *GLUI::add_listbox_to_panel( GLUI_Panel *panel,
494
char *name, int *value_ptr,
495
int id,
496
GLUI_Update_CB callback )
497
{
498
GLUI_Listbox *control;
499
500
control = new GLUI_Listbox;
501
502
if ( control ) {
503
control->set_ptr_val( value_ptr );
504
control->user_id = id;
505
control->set_name( name );
506
control->callback = callback;
507
508
add_control( panel, control );
509
510
control->init_live();
511
512
return control;
513
}
514
else {
515
return NULL;
516
}
517
}
518
519
520
/*********************************** GLUI:: add_rotation() ************/
521
522
GLUI_Rotation *GLUI:: add_rotation( char *name, float *value_ptr,
523
int id, GLUI_Update_CB callback )
524
{
525
return add_rotation_to_panel( main_panel,
526
name, value_ptr, id, callback );
527
}
528
529
530
/*********************************** GLUI:: add_rotation_to_panel() **********/
531
532
GLUI_Rotation *GLUI::add_rotation_to_panel( GLUI_Panel *panel,
533
char *name, float *value_ptr,
534
int id,
535
GLUI_Update_CB callback )
536
{
537
GLUI_Rotation *control;
538
539
control = new GLUI_Rotation;
540
541
if ( control ) {
542
control->set_ptr_val( value_ptr );
543
control->user_id = id;
544
control->set_name( name );
545
control->callback = callback;
546
add_control( panel, control );
547
control->init_live();
548
549
/*** Init the live 4x4 matrix. This is different than the standard
550
live variable behavior, since the original value of the 4x4 matrix
551
is ignored and reset to Identity ***/
552
if ( value_ptr != NULL ) {
553
int i, j, index;
554
for( i=0; i<4; i++ ) {
555
for( j=0; j<4; j++ ) {
556
index = i*4+j;
557
if ( i==j )
558
value_ptr[index] = 1.0;
559
else
560
value_ptr[index] = 0.0;
561
}
562
}
563
}
564
565
/*init_ball(); */
566
567
return control;
568
}
569
else {
570
return NULL;
571
}
572
}
573
574
575
/*********************************** GLUI:: add_translation() ************/
576
577
GLUI_Translation
578
*GLUI:: add_translation( char *name, int trans_type,
579
float *value_ptr, int id, GLUI_Update_CB callback )
580
{
581
return add_translation_to_panel( main_panel,name,trans_type,
582
value_ptr, id, callback );
583
}
584
585
586
/*********************************** GLUI:: add_translation_to_panel() **********/
587
588
GLUI_Translation
589
*GLUI::add_translation_to_panel(
590
GLUI_Panel *panel, char *name,
591
int trans_type, float *value_ptr,
592
int id, GLUI_Update_CB callback )
593
{
594
GLUI_Translation *control;
595
596
control = new GLUI_Translation;
597
598
if ( control ) {
599
control->set_ptr_val( value_ptr );
600
control->user_id = id;
601
control->set_name( name );
602
control->callback = callback;
603
add_control( panel, control );
604
control->init_live();
605
606
control->trans_type = trans_type;
607
608
if ( trans_type == GLUI_TRANSLATION_XY ) {
609
control->float_array_size = 2;
610
}
611
else if ( trans_type == GLUI_TRANSLATION_X ) {
612
control->float_array_size = 1;
613
}
614
else if ( trans_type == GLUI_TRANSLATION_Y ) {
615
control->float_array_size = 1;
616
}
617
else if ( trans_type == GLUI_TRANSLATION_Z ) {
618
control->float_array_size = 1;
619
}
620
621
return control;
622
}
623
else {
624
return NULL;
625
}
626
}
627
628
629
/********************************** GLUI::add_rollout() **************/
630
631
GLUI_Rollout *GLUI::add_rollout( char *name, int open )
632
{
633
return add_rollout_to_panel( main_panel, name, open );
634
}
635
636
637
/****************************** GLUI::add_rollout_to_panel() *********/
638
639
GLUI_Rollout *GLUI::add_rollout_to_panel(GLUI_Panel *panel,char *name,int open)
640
{
641
GLUI_Rollout *rollout;
642
643
rollout = new GLUI_Rollout;
644
645
if ( rollout ) {
646
rollout->set_name( name );
647
rollout->user_id = -1;
648
rollout->int_val = GLUI_PANEL_EMBOSSED;
649
650
if ( NOT open ) {
651
rollout->is_open = false;
652
rollout->h = GLUI_DEFAULT_CONTROL_HEIGHT + 7;
653
}
654
655
add_control( panel, rollout );
656
657
return rollout;
658
}
659
else {
660
return NULL;
661
}
662
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.1