projects / Faustine.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Install, Readme and Changes files updated.
[Faustine.git] / interpretor / faust-0.9.47mr3 / architecture / gui / faustgtk.h
1 #ifndef FAUST_GTKUI_H
2 #define FAUST_GTKUI_H
3
4 #include "GUI.h"
5
6 /******************************************************************************
7 *******************************************************************************
8
9 GRAPHIC USER INTERFACE
10 gtk interface
11
12 *******************************************************************************
13 *******************************************************************************/
14 #include <string>
15 #include <set>
16
17 #include <math.h>
18 #include <stdlib.h>
19 #include <string.h>
20
21 #include <gtk/gtk.h>
22 #include <gdk/gdkkeysyms.h>
23 #include <assert.h>
24
25 using namespace std;
26
27 #define max(x,y) (((x)>(y)) ? (x) : (y))
28 #define min(x,y) (((x)<(y)) ? (x) : (y))
29
30 #define stackSize 256
31
32 // Insertion modes
33
34 #define kSingleMode 0
35 #define kBoxMode 1
36 #define kTabMode 2
37
38 //------------ calculate needed precision
39 static int precision(double n)
40 {
41 if (n < 0.009999) return 3;
42 else if (n < 0.099999) return 2;
43 else if (n < 0.999999) return 1;
44 else return 0;
45 }
46
47 namespace gtk_knob
48 {
49
50 class GtkKnob
51 {
52 private:
53 double start_x, start_y, max_value;
54 public:
55 GtkRange parent;
56 int last_quadrant;
57 GtkKnob();
58 ~GtkKnob();
59 GtkWidget *gtk_knob_new_with_adjustment(GtkAdjustment *_adjustment);
60
61 };
62
63 #define GTK_TYPE_KNOB (gtk_knob_get_type())
64 #define GTK_KNOB(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_KNOB, GtkKnob))
65 #define GTK_IS_KNOB(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_KNOB))
66 #define GTK_KNOB_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_KNOB, GtkKnobClass))
67 #define GTK_IS_KNOB_CLASS(obj) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_KNOB))
68
69 GtkKnob::GtkKnob()
70 // GtkKnob constructor
71 {
72
73 }
74
75 GtkKnob::~GtkKnob()
76 {
77 // Nothing specific to do...
78 }
79
80 struct GtkKnobClass {
81 GtkRangeClass parent_class;
82 int knob_x;
83 int knob_y;
84 int knob_step;
85 int button_is;
86
87 };
88
89 //------forward declaration
90 GType gtk_knob_get_type ();
91
92 /****************************************************************
93 ** calculate the knop pointer with dead zone
94 */
95
96 const double scale_zero = 20 * (M_PI/180); // defines "dead zone" for knobs
97
98 static void knob_expose(GtkWidget *widget, int knob_x, int knob_y, GdkEventExpose *event, int arc_offset)
99 {
100 /** check resize **/
101 int grow;
102 if(widget->allocation.width > widget->allocation.height) {
103 grow = widget->allocation.height;
104 } else {
105 grow = widget->allocation.width;
106 }
107 knob_x = grow-4;
108 knob_y = grow-4;
109 /** get values for the knob **/
110 GtkAdjustment *adj = gtk_range_get_adjustment(GTK_RANGE(widget));
111 int knobx = (widget->allocation.x+2 + (widget->allocation.width-4 - knob_x) * 0.5);
112 int knoby = (widget->allocation.y+2 + (widget->allocation.height-4 - knob_y) * 0.5);
113 int knobx1 = (widget->allocation.x+2 + (widget->allocation.width-4)* 0.5);
114 int knoby1 = (widget->allocation.y+2 + (widget->allocation.height-4) * 0.5);
115 double knobstate = (adj->value - adj->lower) / (adj->upper - adj->lower);
116 double angle = scale_zero + knobstate * 2 * (M_PI - scale_zero);
117 double knobstate1 = (0. - adj->lower) / (adj->upper - adj->lower);
118 double pointer_off = knob_x/6;
119 double radius = min(knob_x-pointer_off, knob_y-pointer_off) / 2;
120 double lengh_x = (knobx+radius+pointer_off/2) - radius * sin(angle);
121 double lengh_y = (knoby+radius+pointer_off/2) + radius * cos(angle);
122 double radius1 = min(knob_x, knob_y) / 2 ;
123
124 /** get widget forground color convert to cairo **/
125 GtkStyle *style = gtk_widget_get_style (widget);
126 double r = min(0.6,style->fg[gtk_widget_get_state(widget)].red/65535.0),
127 g = min(0.6,style->fg[gtk_widget_get_state(widget)].green/65535.0),
128 b = min(0.6,style->fg[gtk_widget_get_state(widget)].blue/65535.0);
129
130 /** paint focus **/
131 if (GTK_WIDGET_HAS_FOCUS(widget)== TRUE) {
132 gtk_paint_focus(widget->style, widget->window, GTK_STATE_NORMAL, NULL, widget, NULL,
133 knobx-2, knoby-2, knob_x+4, knob_y+4);
134 }
135 /** create clowing knobs with cairo **/
136 cairo_t *cr = gdk_cairo_create(GDK_DRAWABLE(widget->window));
137 GdkRegion *region;
138 region = gdk_region_rectangle (&widget->allocation);
139 gdk_region_intersect (region, event->region);
140 gdk_cairo_region (cr, region);
141 cairo_clip (cr);
142
143 cairo_arc(cr,knobx1+arc_offset, knoby1+arc_offset, knob_x/2.1, 0, 2 * M_PI );
144 cairo_pattern_t*pat =
145 cairo_pattern_create_radial (knobx1+arc_offset-knob_x/6,knoby1+arc_offset-knob_x/6, 1,knobx1+arc_offset,knoby1+arc_offset,knob_x/2.1 );
146 if(adj->lower<0 && adj->value>0.) {
147 cairo_pattern_add_color_stop_rgb (pat, 0, r+0.4, g+0.4 + knobstate-knobstate1, b+0.4);
148 cairo_pattern_add_color_stop_rgb (pat, 0.7, r+0.15, g+0.15 + (knobstate-knobstate1)*0.5, b+0.15);
149 cairo_pattern_add_color_stop_rgb (pat, 1, r, g, b);
150 } else if(adj->lower<0 && adj->value<=0.) {
151 cairo_pattern_add_color_stop_rgb (pat, 0, r+0.4 +knobstate1- knobstate, g+0.4, b+0.4);
152 cairo_pattern_add_color_stop_rgb (pat, 0.7, r+0.15 +(knobstate1- knobstate)*0.5, g+0.15, b+0.15);
153 cairo_pattern_add_color_stop_rgb (pat, 1, r, g, b);
154 } else {
155 cairo_pattern_add_color_stop_rgb (pat, 0, r+0.4, g+0.4 +knobstate, b+0.4);
156 cairo_pattern_add_color_stop_rgb (pat, 0.7, r+0.15, g+0.15 + knobstate*0.5, b+0.15);
157 cairo_pattern_add_color_stop_rgb (pat, 1, r, g, b);
158 }
159 cairo_set_source (cr, pat);
160 cairo_fill_preserve (cr);
161 gdk_cairo_set_source_color(cr, gtk_widget_get_style (widget)->fg);
162 cairo_set_line_width(cr, 2.0);
163 cairo_stroke(cr);
164
165 /** create a rotating pointer on the kob**/
166 cairo_set_source_rgb(cr, 0.1, 0.1, 0.1);
167 cairo_set_line_width(cr,max(3, min(7, knob_x/15)));
168 cairo_set_line_cap(cr, CAIRO_LINE_CAP_ROUND);
169 cairo_set_line_join(cr, CAIRO_LINE_JOIN_BEVEL);
170 cairo_move_to(cr, knobx+radius1, knoby+radius1);
171 cairo_line_to(cr,lengh_x,lengh_y);
172 cairo_stroke(cr);
173 cairo_set_source_rgb(cr, 0.9, 0.9, 0.9);
174 cairo_set_line_width(cr,min(5, max(1,knob_x/30)));
175 cairo_move_to(cr, knobx+radius1, knoby+radius1);
176 cairo_line_to(cr,lengh_x,lengh_y);
177 cairo_stroke(cr);
178 cairo_pattern_destroy (pat);
179 gdk_region_destroy (region);
180 cairo_destroy(cr);
181 }
182
183 /****************************************************************
184 ** general expose events for all "knob" controllers
185 */
186
187 //----------- draw the Knob when moved
188 static gboolean gtk_knob_expose (GtkWidget *widget, GdkEventExpose *event)
189 {
190 g_assert(GTK_IS_KNOB(widget));
191 GtkKnobClass *klass = GTK_KNOB_CLASS(GTK_OBJECT_GET_CLASS(widget));
192 knob_expose(widget, klass->knob_x, klass->knob_y, event, 0);
193 return TRUE;
194 }
195
196 /****************************************************************
197 ** set initial size for GdkDrawable per type
198 */
199
200 static void gtk_knob_size_request (GtkWidget *widget, GtkRequisition *requisition)
201 {
202 g_assert(GTK_IS_KNOB(widget));
203 GtkKnobClass *klass = GTK_KNOB_CLASS(GTK_OBJECT_GET_CLASS(widget));
204 requisition->width = klass->knob_x;
205 requisition->height = klass->knob_y;
206 }
207
208 /****************************************************************
209 ** set value from key bindings
210 */
211
212 static void gtk_knob_set_value (GtkWidget *widget, int dir_down)
213 {
214 g_assert(GTK_IS_KNOB(widget));
215
216 GtkAdjustment *adj = gtk_range_get_adjustment(GTK_RANGE(widget));
217
218 int oldstep = (int)(0.5f + (adj->value - adj->lower) / adj->step_increment);
219 int step;
220 int nsteps = (int)(0.5f + (adj->upper - adj->lower) / adj->step_increment);
221 if (dir_down)
222 step = oldstep - 1;
223 else
224 step = oldstep + 1;
225 float value = adj->lower + step * double(adj->upper - adj->lower) / nsteps;
226 gtk_widget_grab_focus(widget);
227 gtk_range_set_value(GTK_RANGE(widget), value);
228 }
229
230 /****************************************************************
231 ** keyboard bindings
232 */
233
234 static gboolean gtk_knob_key_press (GtkWidget *widget, GdkEventKey *event)
235 {
236 g_assert(GTK_IS_KNOB(widget));
237
238 GtkAdjustment *adj = gtk_range_get_adjustment(GTK_RANGE(widget));
239 switch (event->keyval) {
240 case GDK_Home:
241 gtk_range_set_value(GTK_RANGE(widget), adj->lower);
242 return TRUE;
243 case GDK_End:
244 gtk_range_set_value(GTK_RANGE(widget), adj->upper);
245 return TRUE;
246 case GDK_Up:
247 gtk_knob_set_value(widget, 0);
248 return TRUE;
249 case GDK_Right:
250 gtk_knob_set_value(widget, 0);
251 return TRUE;
252 case GDK_Down:
253 gtk_knob_set_value(widget, 1);
254 return TRUE;
255 case GDK_Left:
256 gtk_knob_set_value(widget, 1);
257 return TRUE;
258 }
259
260 return FALSE;
261 }
262
263 /****************************************************************
264 ** alternative (radial) knob motion mode (ctrl + mouse pressed)
265 */
266
267 static void knob_pointer_event(GtkWidget *widget, gdouble x, gdouble y, int knob_x, int knob_y,
268 bool drag, int state)
269 {
270 static double last_y = 2e20;
271 GtkKnob *knob = GTK_KNOB(widget);
272 GtkAdjustment *adj = gtk_range_get_adjustment(GTK_RANGE(widget));
273 double radius = min(knob_x, knob_y) / 2;
274 int knobx = (widget->allocation.width - knob_x) / 2;
275 int knoby = (widget->allocation.height - knob_y) / 2;
276 double posx = (knobx + radius) - x; // x axis right -> left
277 double posy = (knoby + radius) - y; // y axis top -> bottom
278 double value;
279 if (!drag) {
280 if (state & GDK_CONTROL_MASK) {
281 last_y = 2e20;
282 return;
283 } else {
284 last_y = posy;
285 }
286 }
287 if (last_y < 1e20) { // in drag started with Control Key
288 const double scaling = 0.005;
289 double scal = (state & GDK_SHIFT_MASK ? scaling*0.1 : scaling);
290 value = (last_y - posy) * scal;
291 last_y = posy;
292 gtk_range_set_value(GTK_RANGE(widget), adj->value - value * (adj->upper - adj->lower));
293 return;
294 }
295
296 double angle = atan2(-posx, posy) + M_PI; // clockwise, zero at 6 o'clock, 0 .. 2*M_PI
297 if (drag) {
298 // block "forbidden zone" and direct moves between quadrant 1 and 4
299 int quadrant = 1 + int(angle/M_PI_2);
300 if (knob->last_quadrant == 1 && (quadrant == 3 || quadrant == 4)) {
301 angle = scale_zero;
302 } else if (knob->last_quadrant == 4 && (quadrant == 1 || quadrant == 2)) {
303 angle = 2*M_PI - scale_zero;
304 } else {
305 if (angle < scale_zero) {
306 angle = scale_zero;
307 } else if (angle > 2*M_PI - scale_zero) {
308 angle = 2*M_PI - scale_zero;
309 }
310 knob->last_quadrant = quadrant;
311 }
312 } else {
313 if (angle < scale_zero) {
314 angle = scale_zero;
315 } else if (angle > 2*M_PI - scale_zero) {
316 angle = 2*M_PI - scale_zero;
317 }
318 knob->last_quadrant = 0;
319 }
320 angle = (angle - scale_zero) / (2 * (M_PI-scale_zero)); // normalize to 0..1
321 gtk_range_set_value(GTK_RANGE(widget), adj->lower + angle * (adj->upper - adj->lower));
322 }
323
324 /****************************************************************
325 ** mouse button pressed set value
326 */
327
328 static gboolean gtk_knob_button_press (GtkWidget *widget, GdkEventButton *event)
329 {
330 g_assert(GTK_IS_KNOB(widget));
331
332 GtkKnobClass *klass = GTK_KNOB_CLASS(GTK_OBJECT_GET_CLASS(widget));
333
334
335 switch (event->button) {
336 case 1: // left button
337 gtk_widget_grab_focus(widget);
338 gtk_widget_grab_default (widget);
339 gtk_grab_add(widget);
340 klass->button_is = 1;
341 knob_pointer_event(widget, event->x, event->y, klass->knob_x, klass->knob_y,
342 false, event->state);
343 break;
344 case 2: //wheel
345 klass->button_is = 2;
346 break;
347 case 3: // right button
348 klass->button_is = 3;
349 break;
350 default: // do nothing
351 break;
352 }
353 return TRUE;
354 }
355
356 /****************************************************************
357 ** mouse button release
358 */
359
360 static gboolean gtk_knob_button_release (GtkWidget *widget, GdkEventButton *event)
361 {
362 g_assert(GTK_IS_KNOB(widget));
363 GTK_KNOB_CLASS(GTK_OBJECT_GET_CLASS(widget))->button_is = 0;
364 if (GTK_WIDGET_HAS_GRAB(widget))
365 gtk_grab_remove(widget);
366 return FALSE;
367 }
368
369 /****************************************************************
370 ** set the value from mouse movement
371 */
372
373 static gboolean gtk_knob_pointer_motion (GtkWidget *widget, GdkEventMotion *event)
374 {
375 g_assert(GTK_IS_KNOB(widget));
376 GtkKnobClass *klass = GTK_KNOB_CLASS(GTK_OBJECT_GET_CLASS(widget));
377
378 gdk_event_request_motions (event);
379
380 if (GTK_WIDGET_HAS_GRAB(widget)) {
381 knob_pointer_event(widget, event->x, event->y, klass->knob_x, klass->knob_y,
382 true, event->state);
383 }
384 return FALSE;
385 }
386
387 /****************************************************************
388 ** set value from mouseweel
389 */
390
391 static gboolean gtk_knob_scroll (GtkWidget *widget, GdkEventScroll *event)
392 {
393 usleep(5000);
394 gtk_knob_set_value(widget, event->direction);
395 return FALSE;
396 }
397
398 /****************************************************************
399 ** init the GtkKnobClass
400 */
401
402 static void gtk_knob_class_init (GtkKnobClass *klass)
403 {
404 GtkWidgetClass *widget_class = GTK_WIDGET_CLASS(klass);
405
406 /** set here the sizes and steps for the used knob **/
407 //--------- small knob size and steps
408
409 klass->knob_x = 30;
410 klass->knob_y = 30;
411 klass->knob_step = 86;
412
413 //--------- event button
414 klass->button_is = 0;
415
416 //--------- connect the events with funktions
417 widget_class->expose_event = gtk_knob_expose;
418 widget_class->size_request = gtk_knob_size_request;
419 widget_class->button_press_event = gtk_knob_button_press;
420 widget_class->button_release_event = gtk_knob_button_release;
421 widget_class->motion_notify_event = gtk_knob_pointer_motion;
422 widget_class->key_press_event = gtk_knob_key_press;
423 widget_class->scroll_event = gtk_knob_scroll;
424 }
425
426 /****************************************************************
427 ** init the Knob type/size
428 */
429
430 static void gtk_knob_init (GtkKnob *knob)
431 {
432 GtkWidget *widget = GTK_WIDGET(knob);
433 GtkKnobClass *klass = GTK_KNOB_CLASS(GTK_OBJECT_GET_CLASS(widget));
434
435 GTK_WIDGET_SET_FLAGS (GTK_WIDGET(knob), GTK_CAN_FOCUS);
436 GTK_WIDGET_SET_FLAGS (GTK_WIDGET(knob), GTK_CAN_DEFAULT);
437
438 widget->requisition.width = klass->knob_x;
439 widget->requisition.height = klass->knob_y;
440
441 }
442
443 /****************************************************************
444 ** redraw when value changed
445 */
446
447 static gboolean gtk_knob_value_changed(gpointer obj)
448 {
449 GtkWidget *widget = (GtkWidget *)obj;
450 gtk_widget_queue_draw(widget);
451 return FALSE;
452 }
453
454 /****************************************************************
455 ** create small knob
456 */
457
458 GtkWidget *GtkKnob::gtk_knob_new_with_adjustment(GtkAdjustment *_adjustment)
459 {
460 GtkWidget *widget = GTK_WIDGET( g_object_new (GTK_TYPE_KNOB, NULL ));
461 GtkKnob *knob = GTK_KNOB(widget);
462 knob->last_quadrant = 0;
463 if (widget) {
464 gtk_range_set_adjustment(GTK_RANGE(widget), _adjustment);
465 g_signal_connect(GTK_OBJECT(widget), "value-changed",
466 G_CALLBACK(gtk_knob_value_changed), widget);
467 }
468 return widget;
469 }
470
471 /****************************************************************
472 ** get the Knob type
473 */
474
475 GType gtk_knob_get_type (void)
476 {
477 static GType kn_type = 0;
478 if (!kn_type) {
479 static const GTypeInfo kn_info = {
480 sizeof(GtkKnobClass), NULL, NULL, (GClassInitFunc)gtk_knob_class_init, NULL, NULL, sizeof (GtkKnob), 0, (GInstanceInitFunc)gtk_knob_init
481 };
482 kn_type = g_type_register_static(GTK_TYPE_RANGE, "GtkKnob", &kn_info, (GTypeFlags)0);
483 }
484 return kn_type;
485 }
486 }/* end of gtk_knob namespace */
487
488 gtk_knob::GtkKnob myGtkKnob;
489
490 /**
491 * rmWhiteSpaces(): Remove the leading and trailing white spaces of a string
492 * (but not those in the middle of the string)
493 */
494 static string rmWhiteSpaces(const string& s)
495 {
496 size_t i = s.find_first_not_of(" \t");
497 size_t j = s.find_last_not_of(" \t");
498
499 if (i != string::npos & j != string::npos) {
500 return s.substr(i, 1+j-i);
501 } else {
502 return "";
503 }
504 }
505
506
507 /**
508 * Extracts metdata from a label : 'vol [unit: dB]' -> 'vol' + metadata
509 */
510 static void extractMetadata(const string& fulllabel, string& label, map<string, string>& metadata)
511 {
512 enum {kLabel, kEscape1, kEscape2, kEscape3, kKey, kValue};
513 int state = kLabel; int deep = 0;
514 string key, value;
515
516 for (unsigned int i=0; i < fulllabel.size(); i++) {
517 char c = fulllabel[i];
518 switch (state) {
519 case kLabel :
520 assert (deep == 0);
521 switch (c) {
522 case '\\' : state = kEscape1; break;
523 case '[' : state = kKey; deep++; break;
524 default : label += c;
525 }
526 break;
527
528 case kEscape1 :
529 label += c;
530 state = kLabel;
531 break;
532
533 case kEscape2 :
534 key += c;
535 state = kKey;
536 break;
537
538 case kEscape3 :
539 value += c;
540 state = kValue;
541 break;
542
543 case kKey :
544 assert (deep > 0);
545 switch (c) {
546 case '\\' : state = kEscape2;
547 break;
548
549 case '[' : deep++;
550 key += c;
551 break;
552
553 case ':' : if (deep == 1) {
554 state = kValue;
555 } else {
556 key += c;
557 }
558 break;
559 case ']' : deep--;
560 if (deep < 1) {
561 metadata[rmWhiteSpaces(key)] = "";
562 state = kLabel;
563 key="";
564 value="";
565 } else {
566 key += c;
567 }
568 break;
569 default : key += c;
570 }
571 break;
572
573 case kValue :
574 assert (deep > 0);
575 switch (c) {
576 case '\\' : state = kEscape3;
577 break;
578
579 case '[' : deep++;
580 value += c;
581 break;
582
583 case ']' : deep--;
584 if (deep < 1) {
585 metadata[rmWhiteSpaces(key)]=rmWhiteSpaces(value);
586 state = kLabel;
587 key="";
588 value="";
589 } else {
590 value += c;
591 }
592 break;
593 default : value += c;
594 }
595 break;
596
597 default :
598 cerr << "ERROR unrecognized state " << state << endl;
599 }
600 }
601 label = rmWhiteSpaces(label);
602 }
603
604
605 class GTKUI : public GUI
606 {
607 private :
608 static bool fInitialized;
609 static map<float*, float> fGuiSize; // map widget zone with widget size coef
610 static map<float*, string> fTooltip; // map widget zone with tooltip strings
611 static set<float*> fKnobSet; // set of widget zone to be knobs
612 string gGroupTooltip;
613
614 bool isKnob(float* zone){return fKnobSet.count(zone) > 0;}
615
616 protected :
617 GtkWidget* fWindow;
618 int fTop;
619 GtkWidget* fBox[stackSize];
620 int fMode[stackSize];
621 bool fStopped;
622
623 GtkWidget* addWidget(const char* label, GtkWidget* w);
624 virtual void pushBox(int mode, GtkWidget* w);
625
626
627 public :
628 static const gboolean expand = TRUE;
629 static const gboolean fill = TRUE;
630 static const gboolean homogene = FALSE;
631
632 GTKUI(char * name, int* pargc, char*** pargv);
633
634 // -- Labels and metadata
635
636 virtual void declare (float* zone, const char* key, const char* value);
637 virtual int checkLabelOptions (GtkWidget* widget, const string& fullLabel, string& simplifiedLabel);
638 virtual void checkForTooltip (float* zone, GtkWidget* widget);
639
640 // -- layout groups
641
642 virtual void openFrameBox(const char* label);
643 virtual void openTabBox(const char* label = "");
644 virtual void openHorizontalBox(const char* label = "");
645 virtual void openVerticalBox(const char* label = "");
646
647 // -- extra widget's layouts
648
649 virtual void openDialogBox(const char* label, float* zone);
650 virtual void openEventBox(const char* label = "");
651 virtual void openHandleBox(const char* label = "");
652 virtual void openExpanderBox(const char* label, float* zone);
653
654 virtual void closeBox();
655 virtual void adjustStack(int n);
656
657 // -- active widgets
658
659 virtual void addButton(const char* label, float* zone);
660 virtual void addToggleButton(const char* label, float* zone);
661 virtual void addCheckButton(const char* label, float* zone);
662 virtual void addVerticalSlider(const char* label, float* zone, float init, float min, float max, float step);
663 virtual void addHorizontalSlider(const char* label, float* zone, float init, float min, float max, float step);
664 virtual void addKnob(const char* label, float* zone, float init, float min, float max, float step);
665 virtual void addNumEntry(const char* label, float* zone, float init, float min, float max, float step);
666
667 // -- passive display widgets
668
669 virtual void addNumDisplay(const char* label, float* zone, int precision);
670 virtual void addTextDisplay(const char* label, float* zone, const char* names[], float min, float max);
671 virtual void addHorizontalBargraph(const char* label, float* zone, float min, float max);
672 virtual void addVerticalBargraph(const char* label, float* zone, float min, float max);
673
674 virtual void show();
675 virtual void run();
676
677 };
678
679
680
681 /******************************************************************************
682 *******************************************************************************
683
684 GRAPHIC USER INTERFACE (v2)
685 gtk implementation
686
687 *******************************************************************************
688 *******************************************************************************/
689
690 // global static fields
691
692 bool GTKUI::fInitialized = false;
693 map<float*, float> GTKUI::fGuiSize;
694 map<float*, string> GTKUI::fTooltip;
695 set<float*> GTKUI::fKnobSet; // set of widget zone to be knobs
696
697 /**
698 * Format tooltip string by replacing some white spaces by
699 * return characters so that line width doesn't exceed n.
700 * Limitation : long words exceeding n are not cut
701 */
702 static string formatTooltip(int n, const string& tt)
703 {
704 string ss = tt; // ss string we are going to format
705 int lws = 0; // last white space encountered
706 int lri = 0; // last return inserted
707 for (int i=0; i<tt.size(); i++) {
708 if (tt[i] == ' ') lws = i;
709 if (((i-lri) >= n) && (lws > lri)) {
710 // insert return here
711 ss[lws] = '\n';
712 lri = lws;
713 }
714 }
715 cout << ss;
716 return ss;
717 }
718
719
720
721 static gint delete_event( GtkWidget *widget, GdkEvent *event, gpointer data )
722 {
723 return FALSE;
724 }
725
726 static void destroy_event( GtkWidget *widget, gpointer data )
727 {
728 gtk_main_quit ();
729 }
730
731
732 GTKUI::GTKUI(char * name, int* pargc, char*** pargv)
733 {
734 if (!fInitialized) {
735 gtk_init(pargc, pargv);
736 fInitialized = true;
737 }
738
739 fWindow = gtk_window_new (GTK_WINDOW_TOPLEVEL);
740 //gtk_container_set_border_width (GTK_CONTAINER (fWindow), 10);
741 gtk_window_set_title (GTK_WINDOW (fWindow), name);
742 gtk_signal_connect (GTK_OBJECT (fWindow), "delete_event", GTK_SIGNAL_FUNC (delete_event), NULL);
743 gtk_signal_connect (GTK_OBJECT (fWindow), "destroy", GTK_SIGNAL_FUNC (destroy_event), NULL);
744
745 fTop = 0;
746 fBox[fTop] = gtk_vbox_new (homogene, 4);
747 fMode[fTop] = kBoxMode;
748 gtk_container_add (GTK_CONTAINER (fWindow), fBox[fTop]);
749 fStopped = false;
750 }
751
752 // empilement des boites
753
754 void GTKUI::pushBox(int mode, GtkWidget* w)
755 {
756 ++fTop;
757 assert(fTop < stackSize);
758 fMode[fTop] = mode;
759 fBox[fTop] = w;
760 }
761
762
763 /**
764 * Remove n levels from the stack S before the top level
765 * adjustStack(n): S -> S' with S' = S(0),S(n+1),S(n+2),...
766 */
767 void GTKUI::adjustStack(int n)
768 {
769 if (n > 0) {
770 assert(fTop >= n);
771
772 fTop -= n;
773 fMode[fTop] = fMode[fTop+n];
774 fBox[fTop] = fBox[fTop+n];
775 }
776 }
777
778 void GTKUI::closeBox()
779 {
780 --fTop;
781 assert(fTop >= 0);
782 }
783
784
785 /**
786 * Analyses the widget zone metadata declarations and takes
787 * appropriate actions
788 */
789 void GTKUI::declare(float* zone, const char* key, const char* value)
790 {
791 if (zone == 0) {
792 // special zone 0 means group metadata
793 if (strcmp(key,"tooltip")==0) {
794 // only group tooltip are currently implemented
795 gGroupTooltip = formatTooltip(30, value);
796 }
797 } else {
798 if (strcmp(key,"size")==0) {
799 fGuiSize[zone]=atof(value);
800 }
801 else if (strcmp(key,"tooltip")==0) {
802 fTooltip[zone] = formatTooltip(30,value) ;
803 }
804 else if (strcmp(key,"style")==0) {
805 if (strcmp(value,"knob") == 0) {
806 fKnobSet.insert(zone);
807 }
808 }
809 }
810 }
811
812
813
814 /**
815 * Analyses a full label and activates the relevant options. returns a simplified
816 * label (without options) and an amount of stack adjustement (in case additional
817 * containers were pushed on the stack).
818 */
819
820 int GTKUI::checkLabelOptions(GtkWidget* widget, const string& fullLabel, string& simplifiedLabel)
821 {
822 map<string, string> metadata;
823 extractMetadata(fullLabel, simplifiedLabel, metadata);
824
825 if (metadata.count("tooltip")) {
826 gtk_tooltips_set_tip (gtk_tooltips_new (), widget, metadata["tooltip"].c_str(), NULL);
827 }
828 if (metadata["option"] == "detachable") {
829 openHandleBox(simplifiedLabel.c_str());
830 return 1;
831 }
832
833 //---------------------
834 if (gGroupTooltip != string()) {
835 gtk_tooltips_set_tip (gtk_tooltips_new (), widget, gGroupTooltip.c_str(), NULL);
836 gGroupTooltip = string();
837 }
838
839 //----------------------
840
841 // no adjustement of the stack needed
842 return 0;
843 }
844
845 /**
846 * Check if a tooltip is associated to a zone and add it to the corresponding widget
847 */
848 void GTKUI::checkForTooltip(float* zone, GtkWidget* widget)
849 {
850 if (fTooltip.count(zone)) {
851 gtk_tooltips_set_tip (gtk_tooltips_new (), widget, fTooltip[zone].c_str(), NULL);
852 }
853 }
854
855
856 // les differentes boites
857
858 void GTKUI::openFrameBox(const char* label)
859 {
860 GtkWidget * box = gtk_frame_new (label);
861 //gtk_container_set_border_width (GTK_CONTAINER (box), 10);
862
863 pushBox(kSingleMode, addWidget(label, box));
864 }
865
866
867 void GTKUI::openTabBox(const char* fullLabel)
868 {
869 string label;
870 GtkWidget* widget = gtk_notebook_new();
871
872 int adjust = checkLabelOptions(widget, fullLabel, label);
873
874 pushBox(kTabMode, addWidget(label.c_str(), widget));
875
876 // adjust stack because otherwise Handlebox will remain open
877 adjustStack(adjust);
878 }
879
880
881 void GTKUI::openHorizontalBox(const char* fullLabel)
882 {
883 string label;
884 GtkWidget* box = gtk_hbox_new (homogene, 4);
885 int adjust = checkLabelOptions(box, fullLabel, label);
886
887 gtk_container_set_border_width (GTK_CONTAINER (box), 10);
888
889 if (fMode[fTop] != kTabMode && label[0] != 0) {
890 GtkWidget * frame = addWidget(label.c_str(), gtk_frame_new (label.c_str()));
891 gtk_container_add (GTK_CONTAINER(frame), box);
892 gtk_widget_show(box);
893 pushBox(kBoxMode, box);
894 } else {
895 pushBox(kBoxMode, addWidget(label.c_str(), box));
896 }
897
898 // adjust stack because otherwise Handlebox will remain open
899 adjustStack(adjust);
900 }
901
902
903 void GTKUI::openVerticalBox(const char* fullLabel)
904 {
905 string label;
906 GtkWidget * box = gtk_vbox_new (homogene, 4);
907 int adjust = checkLabelOptions(box, fullLabel, label);
908
909 gtk_container_set_border_width (GTK_CONTAINER (box), 10);
910
911 if (fMode[fTop] != kTabMode && label[0] != 0) {
912 GtkWidget * frame = addWidget(label.c_str(), gtk_frame_new (label.c_str()));
913 gtk_container_add (GTK_CONTAINER(frame), box);
914 gtk_widget_show(box);
915 pushBox(kBoxMode, box);
916 } else {
917 pushBox(kBoxMode, addWidget(label.c_str(), box));
918 }
919
920 // adjust stack because otherwise Handlebox will remain open
921 adjustStack(adjust);
922 }
923
924
925 void GTKUI::openHandleBox(const char* label)
926 {
927 GtkWidget * box = gtk_hbox_new (homogene, 4);
928 gtk_container_set_border_width (GTK_CONTAINER (box), 2);
929 if (fMode[fTop] != kTabMode && label[0] != 0)
930 {
931 GtkWidget * frame = addWidget(label, gtk_handle_box_new ());
932 gtk_container_add (GTK_CONTAINER(frame), box);
933 gtk_widget_show(box);
934 pushBox(kBoxMode, box);
935 }
936 else
937 {
938 pushBox(kBoxMode, addWidget(label, box));
939 }
940 }
941
942
943 void GTKUI::openEventBox(const char* label)
944 {
945 GtkWidget * box = gtk_hbox_new (homogene, 4);
946 gtk_container_set_border_width (GTK_CONTAINER (box), 2);
947 if (fMode[fTop] != kTabMode && label[0] != 0)
948 {
949 GtkWidget * frame = addWidget(label, gtk_event_box_new ());
950 gtk_container_add (GTK_CONTAINER(frame), box);
951 gtk_widget_show(box);
952 pushBox(kBoxMode, box);
953 }
954 else
955 {
956 pushBox(kBoxMode, addWidget(label, box));
957 }
958 }
959
960
961 struct uiExpanderBox : public uiItem
962 {
963 GtkExpander* fButton;
964 uiExpanderBox(GUI* ui, float* zone, GtkExpander* b) : uiItem(ui, zone), fButton(b) {}
965 static void expanded (GtkWidget *widget, gpointer data)
966 {
967 float v = gtk_expander_get_expanded (GTK_EXPANDER(widget));
968 if (v == 1.000000)
969 {
970 v = 0;
971 }
972 else v = 1;
973 ((uiItem*)data)->modifyZone(v);
974 }
975
976 virtual void reflectZone()
977 {
978 float v = *fZone;
979 fCache = v;
980 gtk_expander_set_expanded(GTK_EXPANDER(fButton), v);
981 }
982 };
983
984 void GTKUI::openExpanderBox(const char* label, float* zone)
985 {
986 *zone = 0.0;
987 GtkWidget * box = gtk_hbox_new (homogene, 4);
988 gtk_container_set_border_width (GTK_CONTAINER (box), 2);
989 if (fMode[fTop] != kTabMode && label[0] != 0)
990 {
991 GtkWidget * frame = addWidget(label, gtk_expander_new (label));
992 gtk_container_add (GTK_CONTAINER(frame), box);
993 uiExpanderBox* c = new uiExpanderBox(this, zone, GTK_EXPANDER(frame));
994 gtk_signal_connect (GTK_OBJECT (frame), "activate", GTK_SIGNAL_FUNC (uiExpanderBox::expanded), (gpointer)c);
995 gtk_widget_show(box);
996 pushBox(kBoxMode, box);
997 }
998 else
999 {
1000 pushBox(kBoxMode, addWidget(label, box));
1001 }
1002 }
1003
1004
1005
1006 GtkWidget* GTKUI::addWidget(const char* label, GtkWidget* w)
1007 {
1008 switch (fMode[fTop]) {
1009 case kSingleMode : gtk_container_add (GTK_CONTAINER(fBox[fTop]), w); break;
1010 case kBoxMode : gtk_box_pack_start (GTK_BOX(fBox[fTop]), w, expand, fill, 0); break;
1011 case kTabMode : gtk_notebook_append_page (GTK_NOTEBOOK(fBox[fTop]), w, gtk_label_new(label)); break;
1012 }
1013 gtk_widget_show (w);
1014 return w;
1015 }
1016
1017 // --------------------------- Press button ---------------------------
1018
1019 struct uiButton : public uiItem
1020 {
1021 GtkButton* fButton;
1022
1023 uiButton (GUI* ui, float* zone, GtkButton* b) : uiItem(ui, zone), fButton(b) {}
1024
1025 static void pressed( GtkWidget *widget, gpointer data )
1026 {
1027 uiItem* c = (uiItem*) data;
1028 c->modifyZone(1.0);
1029 }
1030
1031 static void released( GtkWidget *widget, gpointer data )
1032 {
1033 uiItem* c = (uiItem*) data;
1034 c->modifyZone(0.0);
1035 }
1036
1037 virtual void reflectZone()
1038 {
1039 float v = *fZone;
1040 fCache = v;
1041 if (v > 0.0) gtk_button_pressed(fButton); else gtk_button_released(fButton);
1042 }
1043 };
1044
1045 void GTKUI::addButton(const char* label, float* zone)
1046 {
1047 *zone = 0.0;
1048 GtkWidget* button = gtk_button_new_with_label (label);
1049 addWidget(label, button);
1050
1051 uiButton* c = new uiButton(this, zone, GTK_BUTTON(button));
1052
1053 gtk_signal_connect (GTK_OBJECT (button), "pressed", GTK_SIGNAL_FUNC (uiButton::pressed), (gpointer) c);
1054 gtk_signal_connect (GTK_OBJECT (button), "released", GTK_SIGNAL_FUNC (uiButton::released), (gpointer) c);
1055
1056 checkForTooltip(zone, button);
1057 }
1058
1059 // --------------------------- Toggle Buttons ---------------------------
1060
1061 struct uiToggleButton : public uiItem
1062 {
1063 GtkToggleButton* fButton;
1064
1065 uiToggleButton(GUI* ui, float* zone, GtkToggleButton* b) : uiItem(ui, zone), fButton(b) {}
1066
1067 static void toggled (GtkWidget *widget, gpointer data)
1068 {
1069 float v = (GTK_TOGGLE_BUTTON (widget)->active) ? 1.0 : 0.0;
1070 ((uiItem*)data)->modifyZone(v);
1071 }
1072
1073 virtual void reflectZone()
1074 {
1075 float v = *fZone;
1076 fCache = v;
1077 gtk_toggle_button_set_active(fButton, v > 0.0);
1078 }
1079 };
1080
1081 void GTKUI::addToggleButton(const char* label, float* zone)
1082 {
1083 *zone = 0.0;
1084 GtkWidget* button = gtk_toggle_button_new_with_label (label);
1085 addWidget(label, button);
1086
1087 uiToggleButton* c = new uiToggleButton(this, zone, GTK_TOGGLE_BUTTON(button));
1088 gtk_signal_connect (GTK_OBJECT (button), "toggled", GTK_SIGNAL_FUNC (uiToggleButton::toggled), (gpointer) c);
1089
1090 checkForTooltip(zone, button);
1091 }
1092
1093
1094
1095 void show_dialog(GtkWidget *widget, gpointer data)
1096 {
1097 if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(widget)) == TRUE)
1098 {
1099 gtk_widget_show(GTK_WIDGET(data));
1100 gint root_x, root_y;
1101 gtk_window_get_position (GTK_WINDOW(data), &root_x, &root_y);
1102 root_y -= 120;
1103 gtk_window_move(GTK_WINDOW(data), root_x, root_y);
1104 }
1105 else gtk_widget_hide(GTK_WIDGET(data));
1106 }
1107
1108 static gboolean deleteevent( GtkWidget *widget, gpointer data )
1109 {
1110 return TRUE;
1111 }
1112
1113 void GTKUI::openDialogBox(const char* label, float* zone)
1114 {
1115 // create toplevel window and set properties
1116 GtkWidget * dialog = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1117 gtk_window_set_decorated(GTK_WINDOW(dialog), TRUE);
1118 gtk_window_set_deletable(GTK_WINDOW(dialog), FALSE);
1119 gtk_window_set_resizable(GTK_WINDOW(dialog), FALSE);
1120 gtk_window_set_gravity(GTK_WINDOW(dialog), GDK_GRAVITY_SOUTH);
1121 gtk_window_set_transient_for (GTK_WINDOW(dialog), GTK_WINDOW(fWindow));
1122 gtk_window_set_position (GTK_WINDOW(dialog), GTK_WIN_POS_MOUSE);
1123 gtk_window_set_keep_below (GTK_WINDOW(dialog), FALSE);
1124 gtk_window_set_title (GTK_WINDOW (dialog), label);
1125 g_signal_connect (G_OBJECT (dialog), "delete_event", G_CALLBACK (deleteevent), NULL);
1126 gtk_window_set_destroy_with_parent(GTK_WINDOW(dialog), TRUE);
1127
1128 GtkWidget * box = gtk_hbox_new (homogene, 4);
1129
1130 *zone = 0.0;
1131 GtkWidget* button = gtk_toggle_button_new ();
1132 gtk_signal_connect (GTK_OBJECT (button), "toggled", GTK_SIGNAL_FUNC (show_dialog), (gpointer) dialog);
1133
1134 gtk_container_add (GTK_CONTAINER(fBox[fTop]), button);
1135 gtk_container_add (GTK_CONTAINER(dialog), box);
1136 gtk_widget_show (button);
1137 gtk_widget_show(box);
1138 pushBox(kBoxMode, box);
1139 }
1140
1141
1142
1143
1144 // --------------------------- Check Button ---------------------------
1145
1146 struct uiCheckButton : public uiItem
1147 {
1148 GtkToggleButton* fButton;
1149
1150 uiCheckButton(GUI* ui, float* zone, GtkToggleButton* b) : uiItem(ui, zone), fButton(b) {}
1151
1152 static void toggled (GtkWidget *widget, gpointer data)
1153 {
1154 float v = (GTK_TOGGLE_BUTTON (widget)->active) ? 1.0 : 0.0;
1155 ((uiItem*)data)->modifyZone(v);
1156 }
1157
1158 virtual void reflectZone()
1159 {
1160 float v = *fZone;
1161 fCache = v;
1162 gtk_toggle_button_set_active(fButton, v > 0.0);
1163 }
1164 };
1165
1166 void GTKUI::addCheckButton(const char* label, float* zone)
1167 {
1168 *zone = 0.0;
1169 GtkWidget* button = gtk_check_button_new_with_label (label);
1170 addWidget(label, button);
1171
1172 uiCheckButton* c = new uiCheckButton(this, zone, GTK_TOGGLE_BUTTON(button));
1173 gtk_signal_connect (GTK_OBJECT (button), "toggled", GTK_SIGNAL_FUNC(uiCheckButton::toggled), (gpointer) c);
1174
1175 checkForTooltip(zone, button);
1176 }
1177
1178
1179 // --------------------------- Adjustmenty based widgets ---------------------------
1180
1181 struct uiAdjustment : public uiItem
1182 {
1183 GtkAdjustment* fAdj;
1184
1185 uiAdjustment(GUI* ui, float* zone, GtkAdjustment* adj) : uiItem(ui, zone), fAdj(adj) {}
1186
1187 static void changed (GtkWidget *widget, gpointer data)
1188 {
1189 float v = GTK_ADJUSTMENT (widget)->value;
1190 ((uiItem*)data)->modifyZone(v);
1191 }
1192
1193 virtual void reflectZone()
1194 {
1195 float v = *fZone;
1196 fCache = v;
1197 gtk_adjustment_set_value(fAdj, v);
1198 }
1199 };
1200
1201 // --------------------------- format knob value display ---------------------------
1202
1203 struct uiValueDisplay : public uiItem
1204 {
1205 GtkLabel* fLabel;
1206 int fPrecision ;
1207
1208 uiValueDisplay(GUI* ui, float* zone, GtkLabel* label, int precision)
1209 : uiItem(ui, zone), fLabel(label), fPrecision(precision) {}
1210
1211 virtual void reflectZone()
1212 {
1213 float v = *fZone;
1214 fCache = v;
1215 char s[64];
1216 if (fPrecision <= 0)
1217 snprintf(s, 63, "%d", int(v));
1218
1219 else if (fPrecision > 3)
1220 snprintf(s, 63, "%f", v);
1221
1222 else if (fPrecision == 1)
1223 {
1224 const char* format[] = {"%.1f", "%.2f", "%.3f"};
1225 snprintf(s, 63, format[1-1], v);
1226 }
1227 else if (fPrecision == 2)
1228 {
1229 const char* format[] = {"%.1f", "%.2f", "%.3f"};
1230 snprintf(s, 63, format[2-1], v);
1231 }
1232 else
1233 {
1234 const char* format[] = {"%.1f", "%.2f", "%.3f"};
1235 snprintf(s, 63, format[3-1], v);
1236 }
1237 gtk_label_set_text(fLabel, s);
1238 }
1239 };
1240
1241 // ------------------------------- Knob -----------------------------------------
1242
1243 void GTKUI::addKnob(const char* label, float* zone, float init, float min, float max, float step)
1244 {
1245 *zone = init;
1246 GtkObject* adj = gtk_adjustment_new(init, min, max, step, 10*step, 0);
1247
1248 uiAdjustment* c = new uiAdjustment(this, zone, GTK_ADJUSTMENT(adj));
1249
1250 gtk_signal_connect (GTK_OBJECT (adj), "value-changed", GTK_SIGNAL_FUNC (uiAdjustment::changed), (gpointer) c);
1251
1252 GtkWidget* slider = gtk_vbox_new (FALSE, 0);
1253 GtkWidget* fil = gtk_vbox_new (FALSE, 0);
1254 GtkWidget* rei = gtk_vbox_new (FALSE, 0);
1255 GtkWidget* re =myGtkKnob.gtk_knob_new_with_adjustment(GTK_ADJUSTMENT(adj));
1256 GtkWidget* lw = gtk_label_new("");
1257 new uiValueDisplay(this, zone, GTK_LABEL(lw),precision(step));
1258 gtk_container_add (GTK_CONTAINER(rei), re);
1259 if(fGuiSize[zone]) {
1260 float size = 30 * fGuiSize[zone];
1261 gtk_widget_set_size_request(rei, size, size );
1262 gtk_box_pack_start (GTK_BOX(slider), fil, TRUE, TRUE, 0);
1263 gtk_box_pack_start (GTK_BOX(slider), rei, FALSE, FALSE, 0);
1264 } else {
1265 gtk_container_add (GTK_CONTAINER(slider), fil);
1266 gtk_container_add (GTK_CONTAINER(slider), rei);
1267 }
1268 gtk_container_add (GTK_CONTAINER(slider), lw);
1269 gtk_widget_show_all(slider);
1270
1271 if (label && label[0]!=0) {
1272 openFrameBox(label);
1273 addWidget(label, slider);
1274 closeBox();
1275 } else {
1276 addWidget(label, slider);
1277 }
1278
1279 checkForTooltip(zone, slider);
1280 }
1281
1282 // -------------------------- Vertical Slider -----------------------------------
1283
1284 void GTKUI::addVerticalSlider(const char* label, float* zone, float init, float min, float max, float step)
1285 {
1286 if (isKnob(zone)) {
1287 addKnob(label, zone, init, min, max, step);
1288 return;
1289 }
1290 *zone = init;
1291 GtkObject* adj = gtk_adjustment_new(init, min, max, step, 10*step, 0);
1292
1293 uiAdjustment* c = new uiAdjustment(this, zone, GTK_ADJUSTMENT(adj));
1294
1295 gtk_signal_connect (GTK_OBJECT (adj), "value-changed", GTK_SIGNAL_FUNC (uiAdjustment::changed), (gpointer) c);
1296
1297 GtkWidget* slider = gtk_vscale_new (GTK_ADJUSTMENT(adj));
1298 gtk_scale_set_digits(GTK_SCALE(slider), precision(step));
1299 float size = 160;
1300 if(fGuiSize[zone]) {
1301 size = 160 * fGuiSize[zone];
1302 }
1303 gtk_widget_set_size_request(slider, -1, size);
1304
1305 gtk_range_set_inverted (GTK_RANGE(slider), TRUE);
1306
1307 if (label && label[0]!=0) {
1308 openFrameBox(label);
1309 addWidget(label, slider);
1310 closeBox();
1311 } else {
1312 addWidget(label, slider);
1313 }
1314
1315 checkForTooltip(zone, slider);
1316 }
1317
1318 // -------------------------- Horizontal Slider -----------------------------------
1319
1320 void GTKUI::addHorizontalSlider(const char* label, float* zone, float init, float min, float max, float step)
1321 {
1322 if (isKnob(zone)) {
1323 addKnob(label, zone, init, min, max, step);
1324 return;
1325 }
1326 *zone = init;
1327 GtkObject* adj = gtk_adjustment_new(init, min, max, step, 10*step, 0);
1328
1329 uiAdjustment* c = new uiAdjustment(this, zone, GTK_ADJUSTMENT(adj));
1330
1331 gtk_signal_connect (GTK_OBJECT (adj), "value-changed", GTK_SIGNAL_FUNC (uiAdjustment::changed), (gpointer) c);
1332
1333 GtkWidget* slider = gtk_hscale_new (GTK_ADJUSTMENT(adj));
1334 gtk_scale_set_digits(GTK_SCALE(slider), precision(step));
1335 float size = 160;
1336 if(fGuiSize[zone]) {
1337 size = 160 * fGuiSize[zone];
1338 }
1339 gtk_widget_set_size_request(slider, size, -1);
1340
1341 if (label && label[0]!=0) {
1342 openFrameBox(label);
1343 addWidget(label, slider);
1344 closeBox();
1345 } else {
1346 addWidget(label, slider);
1347 }
1348
1349 checkForTooltip(zone, slider);
1350 }
1351
1352
1353 // ------------------------------ Num Entry -----------------------------------
1354
1355 void GTKUI::addNumEntry(const char* label, float* zone, float init, float min, float max, float step)
1356 {
1357 if (isKnob(zone)) {
1358 addKnob(label, zone, init, min, max, step);
1359 return;
1360 }
1361 *zone = init;
1362 GtkObject* adj = gtk_adjustment_new(init, min, max, step, 10*step, step);
1363
1364 uiAdjustment* c = new uiAdjustment(this, zone, GTK_ADJUSTMENT(adj));
1365
1366 gtk_signal_connect (GTK_OBJECT (adj), "value-changed", GTK_SIGNAL_FUNC (uiAdjustment::changed), (gpointer) c);
1367
1368 GtkWidget* spinner = gtk_spin_button_new (GTK_ADJUSTMENT(adj), 0.005, precision(step));
1369
1370 openFrameBox(label);
1371 addWidget(label, spinner);
1372 closeBox();
1373
1374 checkForTooltip(zone, spinner);
1375 }
1376
1377
1378 // ========================== passive widgets ===============================
1379
1380
1381 // ------------------------------ Progress Bar -----------------------------------
1382
1383 struct uiBargraph : public uiItem
1384 {
1385 GtkProgressBar* fProgressBar;
1386 float fMin;
1387 float fMax;
1388
1389 uiBargraph(GUI* ui, float* zone, GtkProgressBar* pbar, float lo, float hi)
1390 : uiItem(ui, zone), fProgressBar(pbar), fMin(lo), fMax(hi) {}
1391
1392 float scale(float v) { return (v-fMin)/(fMax-fMin); }
1393
1394 virtual void reflectZone()
1395 {
1396 float v = *fZone;
1397 fCache = v;
1398 gtk_progress_bar_set_fraction(fProgressBar, scale(v));
1399 }
1400 };
1401
1402
1403
1404 void GTKUI::addVerticalBargraph(const char* label, float* zone, float lo, float hi)
1405 {
1406 GtkWidget* pb = gtk_progress_bar_new();
1407 gtk_progress_bar_set_orientation(GTK_PROGRESS_BAR(pb), GTK_PROGRESS_BOTTOM_TO_TOP);
1408 gtk_widget_set_size_request(pb, 8, -1);
1409 new uiBargraph(this, zone, GTK_PROGRESS_BAR(pb), lo, hi);
1410 openFrameBox(label);
1411 addWidget(label, pb);
1412 closeBox();
1413
1414 checkForTooltip(zone, pb);
1415 }
1416
1417
1418 void GTKUI::addHorizontalBargraph(const char* label, float* zone, float lo, float hi)
1419 {
1420 GtkWidget* pb = gtk_progress_bar_new();
1421 gtk_progress_bar_set_orientation(GTK_PROGRESS_BAR(pb), GTK_PROGRESS_LEFT_TO_RIGHT);
1422 gtk_widget_set_size_request(pb, -1, 8);
1423 new uiBargraph(this, zone, GTK_PROGRESS_BAR(pb), lo, hi);
1424 openFrameBox(label);
1425 addWidget(label, pb);
1426 closeBox();
1427
1428 checkForTooltip(zone, pb);
1429 }
1430
1431
1432 // ------------------------------ Num Display -----------------------------------
1433
1434 struct uiNumDisplay : public uiItem
1435 {
1436 GtkLabel* fLabel;
1437 int fPrecision;
1438
1439 uiNumDisplay(GUI* ui, float* zone, GtkLabel* label, int precision)
1440 : uiItem(ui, zone), fLabel(label), fPrecision(precision) {}
1441
1442 virtual void reflectZone()
1443 {
1444 float v = *fZone;
1445 fCache = v;
1446 char s[64];
1447 if (fPrecision <= 0) {
1448 snprintf(s, 63, "%d", int(v));
1449 } else if (fPrecision>3) {
1450 snprintf(s, 63, "%f", v);
1451 } else {
1452 const char* format[] = {"%.1f", "%.2f", "%.3f"};
1453 snprintf(s, 63, format[fPrecision-1], v);
1454 }
1455 gtk_label_set_text(fLabel, s);
1456 }
1457 };
1458
1459
1460 void GTKUI::addNumDisplay(const char* label, float* zone, int precision )
1461 {
1462 GtkWidget* lw = gtk_label_new("");
1463 new uiNumDisplay(this, zone, GTK_LABEL(lw), precision);
1464 openFrameBox(label);
1465 addWidget(label, lw);
1466 closeBox();
1467
1468 checkForTooltip(zone, lw);
1469 }
1470
1471
1472 // ------------------------------ Text Display -----------------------------------
1473
1474 struct uiTextDisplay : public uiItem
1475 {
1476 GtkLabel* fLabel;
1477 const char** fNames;
1478 float fMin;
1479 float fMax;
1480 int fNum;
1481
1482
1483 uiTextDisplay (GUI* ui, float* zone, GtkLabel* label, const char* names[], float lo, float hi)
1484 : uiItem(ui, zone), fLabel(label), fNames(names), fMin(lo), fMax(hi)
1485 {
1486 fNum = 0;
1487 while (fNames[fNum] != 0) fNum++;
1488 }
1489
1490 virtual void reflectZone()
1491 {
1492 float v = *fZone;
1493 fCache = v;
1494
1495 int idx = int(fNum*(v-fMin)/(fMax-fMin));
1496
1497 if (idx < 0) idx = 0;
1498 else if (idx >= fNum) idx = fNum-1;
1499
1500 gtk_label_set_text(fLabel, fNames[idx]);
1501 }
1502 };
1503
1504
1505 void GTKUI::addTextDisplay(const char* label, float* zone, const char* names[], float lo, float hi )
1506 {
1507 GtkWidget* lw = gtk_label_new("");
1508 new uiTextDisplay (this, zone, GTK_LABEL(lw), names, lo, hi);
1509 openFrameBox(label);
1510 addWidget(label, lw);
1511 closeBox();
1512
1513 checkForTooltip(zone, lw);
1514 }
1515
1516
1517
1518 void GTKUI::show()
1519 {
1520 assert(fTop == 0);
1521 gtk_widget_show (fBox[0]);
1522 gtk_widget_show (fWindow);
1523 }
1524
1525
1526 /**
1527 * Update all user items reflecting zone z
1528 */
1529
1530 static gboolean callUpdateAllGuis(gpointer)
1531 {
1532 GUI::updateAllGuis();
1533 return TRUE;
1534 }
1535
1536
1537 void GTKUI::run()
1538 {
1539 assert(fTop == 0);
1540 gtk_widget_show (fBox[0]);
1541 gtk_widget_show (fWindow);
1542 gtk_timeout_add(40, callUpdateAllGuis, 0);
1543 gtk_main ();
1544 stop();
1545 }
1546
1547
1548
1549 #endif
1550
An OCaml-based interpreter for Faust and its vector extension