Imported Upstream version 16.1

1 files changed, 416 insertions, 426 deletions

diff --git a/snd-genv.c b/snd-genv.c
index bee11b1..2325bed 100644
--- a/snd-genv.c
+++ b/snd-genv.c
@@ -2,12 +2,13 @@
 
 /* envelope editor and viewer */
 
-
 static GtkWidget *enved_dialog = NULL;
-static GtkWidget *applyB, *apply2B, *cancelB, *drawer, *showB, *saveB, *resetB, *firB = NULL;
-static GtkWidget *revertB, *undoB, *redoB, *printB, *brktxtL, *graphB, *fltB, *ampB, *srcB, *rbrow, *clipB, *deleteB;
-static GtkWidget *nameL, *textL, *dBB, *orderL;
-static GtkWidget *expB, *linB, *lerow, *baseScale, *baseLabel, *baseValue, *selectionB, *selrow, *revrow, *unrow, *saverow;
+static GtkWidget *enved_apply_button, *enved_apply2_button, *enved_cancel_button, *enved_drawer, *show_button;
+static GtkWidget *enved_save_button = NULL, *enved_reset_button, *fir_button = NULL;
+static GtkWidget *enved_revert_button, *enved_undo_button, *enved_redo_button, *brktxtL, *enved_graph_button;
+static GtkWidget *flt_button, *amp_button, *src_button, *rbrow, *clip_button;
+static GtkWidget *enved_name_label, *enved_text_label, *enved_dB_button, *enved_order_label;
+static GtkWidget *lin_button, *lerow, *baseScale, *baseLabel, *baseValue, *enved_selection_button, *selrow, *unrow;
 static GtkAdjustment *baseAdj, *orderAdj;
 static gc_t *gc, *rgc, *ggc;
 static slist *env_list = NULL;
@@ -28,8 +29,8 @@ static env* active_env = NULL;   /* env currently being edited */
 static axis_info *axis = NULL;
 static axis_info *gray_ap = NULL;
 
-static bool FIR_p = true;
-static bool old_clip_p = false;
+static bool is_FIR = true;
+static bool old_clipping = false;
 static bool ignore_button_release = false;
 
 
@@ -74,11 +75,11 @@ static void prepare_env_edit(env *new_env)
 }
 
 
-void set_enved_redo_sensitive(bool val) {set_sensitive(redoB, val);}
-void set_enved_revert_sensitive(bool val) {set_sensitive(revertB, val);}
-void set_enved_undo_sensitive(bool val) {set_sensitive(undoB, val);}
-void set_enved_save_sensitive(bool val) {set_sensitive(saveB, val);}
-void set_enved_show_sensitive(bool val) {set_sensitive(showB, val);}
+void set_enved_redo_sensitive(bool val) {set_sensitive(enved_redo_button, val);}
+void set_enved_revert_sensitive(bool val) {set_sensitive(enved_revert_button, val);}
+void set_enved_undo_sensitive(bool val) {set_sensitive(enved_undo_button, val);}
+void set_enved_save_sensitive(bool val) {set_sensitive(enved_save_button, val);}
+void set_enved_show_sensitive(bool val) {set_sensitive(show_button, val);}
 
 
 void make_scrolled_env_list(void)
@@ -94,7 +95,7 @@ void make_scrolled_env_list(void)
 
 void enved_reflect_peak_env_completion(snd_info *sp)
 {
-  if ((enved_dialog) && (active_channel) && (enved_wave_p(ss)))
+  if ((enved_dialog) && (active_channel) && (enved_with_wave(ss)))
     {
       if (active_channel->sound == sp) 
 	env_redisplay();
@@ -146,16 +147,16 @@ static bool within_selection_src = false;
 
 static void apply_enved(void)
 {
-  char *origin = NULL, *estr = NULL;
   if (active_env)
     {
       active_channel = current_channel();
       if (active_channel)
 	{
-	  set_sensitive(applyB, false);
-	  set_sensitive(apply2B, false);
-	  set_stock_button_label(cancelB, "Stop");
-	  force_update(cancelB);
+	  char *origin = NULL, *estr = NULL;
+	  set_sensitive(enved_apply_button, false);
+	  set_sensitive(enved_apply2_button, false);
+	  set_stock_button_label(enved_cancel_button, I_STOP);
+	  force_update(enved_cancel_button);
 	  switch (enved_target(ss))
 	    {
 	    case ENVED_AMPLITUDE:
@@ -166,17 +167,17 @@ static void apply_enved(void)
 				  (apply_to_selection) ? S_env_selection : S_env_channel);
 #else
 	      origin = mus_format("%s" PROC_OPEN "%s%s", 
-				  TO_PROC_NAME((apply_to_selection) ? S_env_selection : S_env_channel),
+				  to_proc_name((apply_to_selection) ? S_env_selection : S_env_channel),
 				  estr = env_to_string(active_env),
 				  (apply_to_selection) ? "" : PROC_SEP "0" PROC_SEP PROC_FALSE);
 #endif
 	      apply_env(active_channel, active_env, 0, 
-			CURRENT_SAMPLES(active_channel),
+			current_samples(active_channel),
 			apply_to_selection, 
 			origin, NULL,
-			C_TO_XEN_INT(AT_CURRENT_EDIT_POSITION), 0);
+			C_int_to_Xen_integer(AT_CURRENT_EDIT_POSITION), 0);
 	      /* calls update_graph, I think, but in short files that doesn't update the amp-env */
-	      if (enved_wave_p(ss)) env_redisplay();
+	      if (enved_with_wave(ss)) env_redisplay();
 	      if (estr) free(estr);
 	      if (origin) free(origin);
 	      break;
@@ -189,17 +190,17 @@ static void apply_enved(void)
 				  (apply_to_selection) ? S_filter_selection : S_filter_channel);
 #else
 	      origin = mus_format("%s" PROC_OPEN "%s" PROC_SEP "%d%s",
-				  TO_PROC_NAME((apply_to_selection) ? S_filter_selection : S_filter_channel),
+				  to_proc_name((apply_to_selection) ? S_filter_selection : S_filter_channel),
 				  estr = env_to_string(active_env), 
 				  enved_filter_order(ss),
 				  (apply_to_selection) ? "" : PROC_SEP "0" PROC_SEP PROC_FALSE);
 #endif
 	      apply_filter(active_channel, 
-			   (FIR_p) ? enved_filter_order(ss) : 0,
+			   (is_FIR) ? enved_filter_order(ss) : 0,
 			   active_env, 
 			   origin, NULL,
 			   apply_to_selection, NULL, NULL,
-			   C_TO_XEN_INT(AT_CURRENT_EDIT_POSITION), 0, false);
+			   C_int_to_Xen_integer(AT_CURRENT_EDIT_POSITION), 0, false);
 	      if (estr) free(estr);
 	      if (origin) free(origin);
 	      break;
@@ -213,16 +214,16 @@ static void apply_enved(void)
 		within_selection_src = true;
 		src_env_or_num(active_channel, max_env, 0.0, 
 			       false, "Enved: src", apply_to_selection, NULL,
-			       C_TO_XEN_INT(AT_CURRENT_EDIT_POSITION), 0);
+			       C_int_to_Xen_integer(AT_CURRENT_EDIT_POSITION), 0);
 		within_selection_src = false;
 		max_env = free_env(max_env);
-		if (enved_wave_p(ss)) env_redisplay();
+		if (enved_with_wave(ss)) env_redisplay();
 	      }
 	      break;
 	    }
-	  set_sensitive(applyB, true);
-	  set_sensitive(apply2B, true);
-	  set_stock_button_label(cancelB, "Go Away");
+	  set_sensitive(enved_apply_button, true);
+	  set_sensitive(enved_apply2_button, true);
+	  set_stock_button_label(enved_cancel_button, I_GO_AWAY);
 	}
     }
 }
@@ -232,8 +233,15 @@ static void env_redisplay_1(printing_t printing)
 {
   if (enved_dialog_is_active())
     {
-      if (printing == NOT_PRINTING)
-	ss->cr = MAKE_CAIRO(WIDGET_TO_WINDOW(drawer));	      
+      bool clear_cr = false;
+      if ((printing == NOT_PRINTING) && 
+	  (!(ss->cr)))
+	{
+	  /* we can get here from display_channel_data_with_size with an existing ss->cr */
+	  ss->cr = make_cairo(WIDGET_TO_WINDOW(enved_drawer));
+	  clear_cr = true;
+	}
+      if (!(ss->cr)) return;
       
       cairo_push_group(ss->cr);
       cairo_set_source_rgba(ss->cr, gc->bg_color->red, gc->bg_color->green, gc->bg_color->blue, gc->bg_color->alpha);
@@ -256,14 +264,14 @@ static void env_redisplay_1(printing_t printing)
       else 
 	{
 	  char *name = NULL;
-	  name = (char *)gtk_entry_get_text(GTK_ENTRY(textL));
+	  name = (char *)gtk_entry_get_text(GTK_ENTRY(enved_text_label));
 	  if (!name) name = (char *)"noname";
 
-	  if ((enved_wave_p(ss)) &&
+	  if ((enved_with_wave(ss)) &&
 	      (active_channel) &&
 	      (!(active_channel->squelch_update)))
 	    {
-	      if ((enved_target(ss) == ENVED_SPECTRUM) && (active_env) && (FIR_p) && (printing == NOT_PRINTING))
+	      if ((enved_target(ss) == ENVED_SPECTRUM) && (active_env) && (is_FIR) && (printing == NOT_PRINTING))
 		display_frequency_response(active_env, axis, gray_ap->ax, enved_filter_order(ss), enved_in_dB(ss));
 	      enved_show_background_waveform(axis, gray_ap, apply_to_selection, (enved_target(ss) == ENVED_SPECTRUM), NOT_PRINTING);
 	    }
@@ -272,9 +280,10 @@ static void env_redisplay_1(printing_t printing)
 
       cairo_pop_group_to_source(ss->cr);
       cairo_paint(ss->cr);
-      if (printing == NOT_PRINTING)
+      if ((printing == NOT_PRINTING) &&
+	  (clear_cr))
 	{
-	  FREE_CAIRO(ss->cr);
+	  free_cairo(ss->cr);
 	  ss->cr = NULL;
 	}
     }
@@ -296,7 +305,7 @@ void env_redisplay_with_print(void)
 void update_enved_background_waveform(chan_info *cp)
 {
   if ((enved_dialog_is_active()) &&
-      (enved_wave_p(ss)) &&
+      (enved_with_wave(ss)) &&
       (enved_target(ss) == ENVED_AMPLITUDE) &&
       (cp == active_channel) &&
       ((!apply_to_selection) || (selection_is_active_in_channel(cp))))
@@ -307,7 +316,7 @@ void update_enved_background_waveform(chan_info *cp)
 
 static void enved_filter_order_callback(GtkWidget *w, gpointer data)
 {
-  set_enved_filter_order(gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(orderL)));
+  set_enved_filter_order(gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(enved_order_label)));
 }
 
 
@@ -329,7 +338,7 @@ static gint unpost_genv_error(gpointer data)
 
 static void errors_to_genv_text(const char *msg, void *data)
 {
-  set_button_label(brktxtL, msg);
+  gtk_label_set_text(GTK_LABEL(brktxtL), msg);
   g_timeout_add_full(0, (guint32)5000, unpost_genv_error, NULL, NULL);
 }
 
@@ -350,7 +359,7 @@ static void text_field_activated(GtkWidget *w, gpointer context)
 	    {
 	      alert_envelope_editor(str, copy_env(active_env));
 	      add_or_edit_symbol(str, active_env);
-	      set_sensitive(saveB, false);
+	      set_sensitive(enved_save_button, false);
 	      env_redisplay(); /* updates label */
 	    }
 	  else 
@@ -373,9 +382,9 @@ static void text_field_activated(GtkWidget *w, gpointer context)
 	  active_env = copy_env(e);
 	  set_enved_env_list_top(0);
 	  prepare_env_edit(active_env);
-	  set_sensitive(saveB, true);
-	  set_sensitive(undoB, false);
-	  set_sensitive(revertB, false);
+	  set_sensitive(enved_save_button, true);
+	  set_sensitive(enved_undo_button, false);
+	  set_sensitive(enved_revert_button, false);
 	  env_redisplay();
 	  free_env(e);
 	}
@@ -383,16 +392,16 @@ static void text_field_activated(GtkWidget *w, gpointer context)
 }
 
 
-static void save_button_pressed(GtkWidget *w, gpointer context)
+static void enved_save_button_pressed(GtkWidget *w, gpointer context)
 {
   char *name = NULL;
   if (active_env == NULL) return;
-  name = (char *)gtk_entry_get_text(GTK_ENTRY(textL));
+  name = (char *)gtk_entry_get_text(GTK_ENTRY(enved_text_label));
   if ((!name) || (!(*name))) 
     name = (char *)"unnamed";
   alert_envelope_editor(name, copy_env(active_env));
   add_or_edit_symbol(name, active_env);
-  set_sensitive(saveB, false);
+  set_sensitive(enved_save_button, false);
   env_redisplay();
 }
 
@@ -414,7 +423,7 @@ static void undo_and_apply_enved_callback(GtkWidget *w, gpointer context)
       active_channel->squelch_update = true;
       undo_edit_with_sync(active_channel, 1);
       active_channel->squelch_update = false;
-      clear_minibuffer(active_channel->sound);
+      clear_status_area(active_channel->sound);
     }
   apply_enved();
   last_active_channel = active_channel;
@@ -423,12 +432,10 @@ static void undo_and_apply_enved_callback(GtkWidget *w, gpointer context)
 
 static void reflect_segment_state(void)
 {
-  if (enved_dialog)
-    {
-      widget_modify_bg(expB, GTK_STATE_NORMAL, (enved_style(ss) == ENVELOPE_EXPONENTIAL) ? ss->yellow : ss->basic_color);
-      widget_modify_bg(linB, GTK_STATE_NORMAL, (enved_style(ss) == ENVELOPE_LINEAR) ? ss->yellow : ss->basic_color);
-      if ((active_env) && (!(showing_all_envs))) env_redisplay();
-    }
+  if ((enved_dialog) &&
+      (active_env) && 
+      (!(showing_all_envs)))
+    env_redisplay();
 }
 
 
@@ -437,20 +444,19 @@ static void select_or_edit_env(int pos)
   if (showing_all_envs)
     {
       showing_all_envs = false;
-      set_button_label(showB, "view envs");
+      set_button_label(show_button, "view envs");
     }
   if (active_env) active_env = free_env(active_env);
   selected_env = position_to_env(pos);
   if (!selected_env) return;
   active_env = selected_env;
-  gtk_entry_set_text(GTK_ENTRY(textL), enved_all_names(pos));
+  gtk_entry_set_text(GTK_ENTRY(enved_text_label), enved_all_names(pos));
   set_enved_env_list_top(0);
   prepare_env_edit(active_env);
-  set_sensitive(undoB, false);
-  set_sensitive(revertB, false);
-  set_sensitive(saveB, false);
+  set_sensitive(enved_undo_button, false);
+  set_sensitive(enved_revert_button, false);
+  set_sensitive(enved_save_button, false);
   env_redisplay();
-  set_sensitive(deleteB, true);
 }
 
 
@@ -458,7 +464,7 @@ static void select_or_edit_env(int pos)
 
 static void clear_point_label(void)
 {
-  set_button_label(brktxtL, BLANK_LABEL);
+  gtk_label_set_text(GTK_LABEL(brktxtL), BLANK_LABEL);
 }
 
 
@@ -467,13 +473,13 @@ static char brkpt_buf[LABEL_BUFFER_SIZE];
 static void enved_display_point_label(mus_float_t x, mus_float_t y)
 {
   if ((enved_in_dB(ss)) && (min_dB(ss) < -60))
-    mus_snprintf(brkpt_buf, LABEL_BUFFER_SIZE, "%.3f : %.5f", x, y);
-  else mus_snprintf(brkpt_buf, LABEL_BUFFER_SIZE, "%.3f : %.3f", x, y);
-  set_button_label(brktxtL, brkpt_buf);
+    snprintf(brkpt_buf, LABEL_BUFFER_SIZE, "%.3f : %.5f", x, y);
+  else snprintf(brkpt_buf, LABEL_BUFFER_SIZE, "%.3f : %.3f", x, y);
+  gtk_label_set_text(GTK_LABEL(brktxtL), brkpt_buf);
 }
 
 
-static gboolean drawer_button_motion(GtkWidget *w, GdkEventMotion *ev, gpointer data)
+static gboolean enved_drawer_button_motion(GtkWidget *w, GdkEventMotion *ev, gpointer data)
 {
   int evx, evy;
   GdkModifierType state;
@@ -483,7 +489,7 @@ static gboolean drawer_button_motion(GtkWidget *w, GdkEventMotion *ev, gpointer
   if (BUTTON1_PRESSED(EVENT_STATE(ev)))
     {
       if (EVENT_IS_HINT(ev))
-	gdk_window_get_pointer(EVENT_WINDOW(ev), &evx, &evy, &state);
+	window_get_pointer(ev, &evx, &evy, &state);
       else
 	{
 	  evx = (int)(EVENT_X(ev));
@@ -506,7 +512,7 @@ static gboolean drawer_button_motion(GtkWidget *w, GdkEventMotion *ev, gpointer
 }
 
 
-static gboolean drawer_button_press(GtkWidget *w, GdkEventButton *ev, gpointer data)
+static gboolean enved_drawer_button_press(GtkWidget *w, GdkEventButton *ev, gpointer data)
 {
   ss->enved->down_time = EVENT_TIME(ev);
   ss->enved->env_dragged = false;
@@ -528,20 +534,21 @@ static gboolean drawer_button_press(GtkWidget *w, GdkEventButton *ev, gpointer d
       if (!active_env)
 	{
 	  active_env = default_env(1.0, 0.0);
+	  active_env->base = enved_base(ss);
 	  env_redisplay(); /* needed to get current_xs set up correctly */
 	}
       if (env_editor_button_press(ss->enved, (int)(EVENT_X(ev)), (int)(EVENT_Y(ev)), EVENT_TIME(ev), active_env))
 	env_redisplay();
       enved_display_point_label(ungrf_x(ss->enved->axis, EVENT_X(ev)), env_editor_ungrf_y_dB(ss->enved, (int)(EVENT_Y(ev))));
-      set_sensitive(saveB, true);
-      set_sensitive(undoB, true);
-      set_sensitive(revertB, true);
+      set_sensitive(enved_save_button, true);
+      set_sensitive(enved_undo_button, true);
+      set_sensitive(enved_revert_button, true);
     }
   return(false);
 }
 
 
-static gboolean drawer_button_release(GtkWidget *w, GdkEventButton *ev, gpointer data)
+static gboolean enved_drawer_button_release(GtkWidget *w, GdkEventButton *ev, gpointer data)
 {
   if (ignore_button_release)
     ignore_button_release = false;
@@ -558,7 +565,7 @@ static gboolean drawer_button_release(GtkWidget *w, GdkEventButton *ev, gpointer
 }
 
 
-static gboolean drawer_expose(GtkWidget *w, GdkEventExpose *ev, gpointer data)
+static gboolean enved_drawer_expose(GtkWidget *w, GdkEventExpose *ev, gpointer data)
 {
   env_window_width = widget_width(w);
   env_window_height = widget_height(w);
@@ -567,7 +574,7 @@ static gboolean drawer_expose(GtkWidget *w, GdkEventExpose *ev, gpointer data)
 }
 
 
-static gboolean drawer_resize(GtkWidget *w, GdkEventConfigure *ev, gpointer data)
+static gboolean enved_drawer_resize(GtkWidget *w, GdkEventConfigure *ev, gpointer data)
 {
   /* update display, can be either view of all envs or sequence of current envs */
   env_window_width = widget_width(w);
@@ -581,55 +588,34 @@ static void show_button_pressed(GtkWidget *w, gpointer context)
 {
   /* if show all (as opposed to show current), loop through loaded LV_LISTs */
   showing_all_envs = (!showing_all_envs);
-  set_button_label(showB, (showing_all_envs) ? "edit env" : "view envs");
+  set_button_label(show_button, (showing_all_envs) ? "edit env" : "view envs");
   env_redisplay();
 }
 
 
-static void selection_button_pressed(GtkWidget *w, gpointer context)
+static void enved_selection_button_pressed(GtkWidget *w, gpointer context)
 {
   apply_to_selection = (!apply_to_selection);
-  widget_modify_bg(selectionB, GTK_STATE_NORMAL, (apply_to_selection) ? ss->yellow : ss->basic_color);
-  set_sensitive(apply2B, true);
-  if ((enved_wave_p(ss)) && 
+  widget_modify_bg(enved_selection_button, GTK_STATE_NORMAL, (apply_to_selection) ? ss->yellow : ss->basic_color);
+  set_sensitive(enved_apply2_button, true);
+  if ((enved_with_wave(ss)) && 
       (!showing_all_envs)) 
     env_redisplay();
 }
 
 
-static void delete_button_pressed(GtkWidget *w, gpointer context)
-{
-  if (selected_env)
-    {
-      int i, len;
-      len = enved_all_envs_top();
-      for (i = 0; i < len; i++)
-	if (selected_env == enved_all_envs(i))
-	  {
-	    delete_envelope(enved_all_names(i));
-	    if (enved_all_envs_top() == 0) 
-	      set_sensitive(deleteB, false);
-	    if (active_env) active_env = free_env(active_env);
-	    selected_env = NULL;
-	    env_redisplay();
-	    break;
-	  }
-    }
-}
-
-
-static void revert_button_pressed(GtkWidget *w, gpointer context)
+static void enved_revert_button_pressed(GtkWidget *w, gpointer context)
 {
   revert_env_edit();
   if (active_env) active_env = free_env(active_env);
   active_env = enved_next_env();
   if (active_env == NULL)
-    text_field_activated(textL, NULL);
+    text_field_activated(enved_text_label, NULL);
   env_redisplay();
 }
 
 
-static void undo_button_pressed(GtkWidget *w, gpointer context)
+static void enved_undo_button_pressed(GtkWidget *w, gpointer context)
 {
   undo_env_edit();
   if (active_env) active_env = free_env(active_env);
@@ -638,7 +624,7 @@ static void undo_button_pressed(GtkWidget *w, gpointer context)
 }
 
 
-static void redo_button_pressed(GtkWidget *w, gpointer context)
+static void enved_redo_button_pressed(GtkWidget *w, gpointer context)
 {
   redo_env_edit();
   if (active_env) active_env = free_env(active_env);
@@ -649,19 +635,19 @@ static void redo_button_pressed(GtkWidget *w, gpointer context)
 
 static void reflect_apply_state(void)
 {
-  gtk_label_set_text(GTK_LABEL(nameL), env_names[enved_target(ss)]);
-  widget_modify_bg(ampB, GTK_STATE_NORMAL, (enved_target(ss) == ENVED_AMPLITUDE) ? ss->yellow : ss->basic_color);
-  widget_modify_bg(fltB, GTK_STATE_NORMAL, (enved_target(ss) == ENVED_SPECTRUM) ? ss->yellow : ss->basic_color);
-  widget_modify_bg(srcB, GTK_STATE_NORMAL, (enved_target(ss) == ENVED_SRATE) ? ss->yellow : ss->basic_color);
-  if ((!showing_all_envs) && (enved_wave_p(ss))) env_redisplay();
+  gtk_label_set_text(GTK_LABEL(enved_name_label), env_names[enved_target(ss)]);
+  widget_modify_bg(amp_button, GTK_STATE_NORMAL, (enved_target(ss) == ENVED_AMPLITUDE) ? ss->yellow : ss->basic_color);
+  widget_modify_bg(flt_button, GTK_STATE_NORMAL, (enved_target(ss) == ENVED_SPECTRUM) ? ss->yellow : ss->basic_color);
+  widget_modify_bg(src_button, GTK_STATE_NORMAL, (enved_target(ss) == ENVED_SRATE) ? ss->yellow : ss->basic_color);
+  if ((!showing_all_envs) && (enved_with_wave(ss))) env_redisplay();
 }
 
 
 static void flt_button_pressed(GtkWidget *w, gpointer context)
 {
   in_set_enved_target(ENVED_SPECTRUM);
-  old_clip_p = enved_clip_p(ss);
-  set_enved_clip_p(true);
+  old_clipping = enved_clipping(ss);
+  set_enved_clipping(true);
   reflect_apply_state();
 }
 
@@ -669,7 +655,7 @@ static void flt_button_pressed(GtkWidget *w, gpointer context)
 static void amp_button_pressed(GtkWidget *w, gpointer context)
 {
   if (enved_target(ss) == ENVED_SPECTRUM)
-    set_enved_clip_p(old_clip_p);
+    set_enved_clipping(old_clipping);
   in_set_enved_target(ENVED_AMPLITUDE);
   reflect_apply_state();
 }
@@ -678,7 +664,7 @@ static void amp_button_pressed(GtkWidget *w, gpointer context)
 static void src_button_pressed(GtkWidget *w, gpointer context)
 {
   if (enved_target(ss) == ENVED_SPECTRUM)
-    set_enved_clip_p(old_clip_p);
+    set_enved_clipping(old_clipping);
   in_set_enved_target(ENVED_SRATE);
   reflect_apply_state();
 }
@@ -686,12 +672,12 @@ static void src_button_pressed(GtkWidget *w, gpointer context)
 
 static void enved_reset(void)
 {
-  set_enved_clip_p(DEFAULT_ENVED_CLIP_P);
+  set_enved_clipping(DEFAULT_ENVED_CLIPPING);
   set_enved_style(ENVELOPE_LINEAR);
   set_enved_power(DEFAULT_ENVED_POWER);
   set_enved_base(DEFAULT_ENVED_BASE);
   set_enved_target(DEFAULT_ENVED_TARGET);
-  set_enved_wave_p(DEFAULT_ENVED_WAVE_P);
+  set_enved_with_wave(DEFAULT_ENVED_WITH_WAVE);
   set_enved_in_dB(DEFAULT_ENVED_IN_DB);
   set_enved_filter_order(DEFAULT_ENVED_FILTER_ORDER);
   if (active_env) active_env = free_env(active_env);
@@ -706,39 +692,32 @@ static void enved_reset(void)
 #endif
   set_enved_env_list_top(0);
   prepare_env_edit(active_env);
-  set_sensitive(saveB, true);
+  set_sensitive(enved_save_button, true);
   reflect_enved_style();
   env_redisplay();
 }
 
 
-static void reset_button_pressed(GtkWidget *w, gpointer context)
+static void enved_reset_button_pressed(GtkWidget *w, gpointer context)
 {
   enved_reset();
 }
 
 
-static void print_button_pressed(GtkWidget *w, gpointer context)
-{
-  ss->print_choice = PRINT_ENV;
-  file_print_callback(w, context);
-}
-
-
 static void env_browse_callback(const char *name, int row, void *data)
 {
   select_or_edit_env(row);
 }
 
 
-static void graph_button_callback(GtkWidget *w, gpointer context)
+static void enved_graph_button_callback(GtkWidget *w, gpointer context)
 {
-  in_set_enved_wave_p(TOGGLE_BUTTON_ACTIVE(w));
+  in_set_enved_with_wave(TOGGLE_BUTTON_ACTIVE(w));
   env_redisplay();
 }
 
 
-static void dB_button_callback(GtkWidget *w, gpointer context)
+static void enved_dB_button_callback(GtkWidget *w, gpointer context)
 {
   in_set_enved_in_dB(TOGGLE_BUTTON_ACTIVE(w));
   env_redisplay();
@@ -747,32 +726,7 @@ static void dB_button_callback(GtkWidget *w, gpointer context)
 
 static void clip_button_callback(GtkWidget *w, gpointer context)
 {
-  in_set_enved_clip_p(TOGGLE_BUTTON_ACTIVE(w));
-}
-
-
-static void exp_button_pressed(GtkWidget *w, gpointer context)
-{
-  set_enved_style(ENVELOPE_EXPONENTIAL);
-  if ((active_env) && (!(showing_all_envs)))
-    {
-      active_env->base = enved_base(ss);
-      set_sensitive(saveB, true);
-    }
-  reflect_segment_state();
-}
-
-
-static void lin_button_pressed(GtkWidget *w, gpointer context)
-{
-  set_enved_style(ENVELOPE_LINEAR);
-  if ((active_env) && (!(showing_all_envs)))
-    {
-      active_env->base = 1.0;
-      set_enved_base(1.0);
-      set_sensitive(saveB, true);
-    }
-  reflect_segment_state();
+  in_set_enved_clipping(TOGGLE_BUTTON_ACTIVE(w));
 }
 
 
@@ -785,7 +739,7 @@ static void make_base_label(mus_float_t bval)
   if (len < 32) len = 32;
 
   sfs = (char *)calloc(len, sizeof(char));
-  mus_snprintf(sfs, len, "%.3f", bval);
+  snprintf(sfs, len, "%.3f", bval);
 
   scale_len = (int)(enved_power(ss) + 3);
   if (scale_len < 32) scale_len = 32;
@@ -798,9 +752,17 @@ static void make_base_label(mus_float_t bval)
   free(buf);
 
   in_set_enved_base(bval);
-  if ((active_env) && (!(showing_all_envs))) 
+
+  if ((active_env) && 
+      (!(showing_all_envs))) 
     {
+      if (enved_save_button) set_sensitive(enved_save_button, true); /* what about undo/redo here? */
+
       active_env->base = enved_base(ss);
+      if (active_env->base == 1.0)
+	set_enved_style(ENVELOPE_LINEAR);
+      else set_enved_style(ENVELOPE_EXPONENTIAL);
+
       env_redisplay();
     }
 }
@@ -824,8 +786,6 @@ static void base_changed(mus_float_t val)
 	}
     }
   make_base_label(bval);
-  if ((active_env) && (enved_style(ss) == ENVELOPE_EXPONENTIAL)) 
-    set_sensitive(saveB, true); /* what about undo/redo here? */
 }
 
 
@@ -853,63 +813,44 @@ static void reflect_changed_base(mus_float_t val)
 }
 
 
-static void base_changed_callback(GtkAdjustment *adj, gpointer context)
+static void make_linear(GtkWidget *w, gpointer context)
 {
-  base_changed(ADJUSTMENT_VALUE(adj));
+  reflect_changed_base(1.0);
+  set_enved_style(ENVELOPE_LINEAR);
 }
 
 
-static void fir_button_pressed(GtkWidget *w, gpointer context)
+static void base_changed_callback(GtkAdjustment *adj, gpointer context)
 {
-  FIR_p = (!FIR_p);
-  set_button_label(firB, (FIR_p) ? "fir" : "fft");
-  if (enved_wave_p(ss)) env_redisplay();
+  base_changed(ADJUSTMENT_VALUE(adj));
 }
 
 
-static void reflect_sound_state(void)
+static gboolean fir_button_pressed(GtkWidget *w, GdkEventButton *ev, gpointer data)
 {
-  bool file_p;
-  file_p = (bool)(any_selected_sound());
-  set_sensitive(applyB, file_p);
-  set_sensitive(apply2B, file_p);
+  is_FIR = (!is_FIR);
+  gtk_label_set_text(GTK_LABEL(fir_button), (is_FIR) ? "fir" : "fft");
+  if (enved_with_wave(ss)) env_redisplay();
+  return(false);
 }
 
 
-static XEN reflect_file_in_enved(XEN reason)
+static void reflect_sound_state(void)
 {
-  if (enved_dialog) reflect_sound_state();
-  return(XEN_FALSE);
+  bool file_on;
+  file_on = (bool)(any_selected_sound());
+  set_sensitive(enved_apply_button, file_on);
+  set_sensitive(enved_apply2_button, file_on);
 }
 
-#ifdef XEN_ARGIFY_1
-  XEN_NARGIFY_1(reflect_file_in_enved_w, reflect_file_in_enved)
-#else
-  #define reflect_file_in_enved_w reflect_file_in_enved
-#endif
-
 
-static void enved_reflect_selection(bool on);
-
-static XEN enved_selection_handler(XEN xreason)
+static Xen reflect_file_in_enved(Xen hook_or_reason)
 {
-  int reason;
-  reason = XEN_TO_C_INT(xreason);
-  switch (reason)
-    {
-    case SELECTION_INACTIVE: enved_reflect_selection(false);                 break;
-    case SELECTION_ACTIVE:   enved_reflect_selection(true);                  break;
-    default:                 enved_reflect_selection(selection_is_active()); break;
-    }
-  return(XEN_FALSE);
+  if (enved_dialog) reflect_sound_state();
+  return(Xen_false);
 }
 
-#ifdef XEN_ARGIFY_1
-  XEN_NARGIFY_1(enved_selection_handler_w, enved_selection_handler)
-#else
-  #define enved_selection_handler_w enved_selection_handler
-#endif
-
+Xen_wrap_1_arg(reflect_file_in_enved_w, reflect_file_in_enved)
 
 #define BB_MARGIN 3
 
@@ -917,9 +858,13 @@ GtkWidget *create_envelope_editor(void)
 {
   if (!enved_dialog)
     {
-      GtkWidget *mainform, *helpB, *leftbox, *bottombox, *leftframe, *toprow, *bottomrow;
+      GtkWidget *mainform, *enved_help_button, *leftbox, *bottombox, *leftframe, *toprow, *bottomrow;
 
       enved_dialog = gtk_dialog_new();
+#if GTK_CHECK_VERSION(3, 14, 0)
+      gtk_window_set_transient_for(GTK_WINDOW(enved_dialog), GTK_WINDOW(MAIN_SHELL(ss)));
+#endif
+      add_dialog_style(enved_dialog);
       SG_SIGNAL_CONNECT(enved_dialog, "delete_event", delete_enved_dialog, NULL);
       gtk_window_set_title(GTK_WINDOW(enved_dialog), "Edit Envelope");
       sg_make_resizable(enved_dialog);
@@ -940,38 +885,36 @@ GtkWidget *create_envelope_editor(void)
       gc_set_background(ggc, ss->white);
       gc_set_foreground(ggc, ss->enved_waveform_color);
 
-      helpB = gtk_button_new_from_stock(GTK_STOCK_HELP);
-      gtk_widget_set_name(helpB, "dialog_button");
-
-      cancelB = sg_button_new_from_stock_with_label("Go Away", GTK_STOCK_QUIT);
-      gtk_widget_set_name(cancelB, "dialog_button");
-
-      applyB = gtk_button_new_from_stock(GTK_STOCK_APPLY);
-      gtk_widget_set_name(applyB, "dialog_button");
-
-      apply2B = sg_button_new_from_stock_with_label("Undo&Apply", GTK_STOCK_UNDO);
-      gtk_widget_set_name(apply2B, "dialog_button");
-
-      resetB = sg_button_new_from_stock_with_label("Reset", GTK_STOCK_REFRESH);
-      gtk_widget_set_name(resetB, "dialog_button");
-
-      gtk_box_pack_start(GTK_BOX(DIALOG_ACTION_AREA(enved_dialog)), applyB, false, true, 10);
-      gtk_box_pack_start(GTK_BOX(DIALOG_ACTION_AREA(enved_dialog)), apply2B, false, true, 10);
-      gtk_box_pack_start(GTK_BOX(DIALOG_ACTION_AREA(enved_dialog)), cancelB, false, true, 10);
-      gtk_box_pack_start(GTK_BOX(DIALOG_ACTION_AREA(enved_dialog)), resetB, false, true, 10);
-      gtk_box_pack_end(GTK_BOX(DIALOG_ACTION_AREA(enved_dialog)), helpB, false, true, 10);
-
-      SG_SIGNAL_CONNECT(cancelB, "clicked", dismiss_enved_callback, NULL);
-      SG_SIGNAL_CONNECT(applyB, "clicked", apply_enved_callback, NULL);
-      SG_SIGNAL_CONNECT(apply2B, "clicked", undo_and_apply_enved_callback, NULL);
-      SG_SIGNAL_CONNECT(resetB, "clicked", reset_button_pressed, NULL);
-      SG_SIGNAL_CONNECT(helpB, "clicked", help_enved_callback, NULL);
-
-      gtk_widget_show(cancelB);
-      gtk_widget_show(applyB);
-      gtk_widget_show(apply2B);
-      gtk_widget_show(resetB);
-      gtk_widget_show(helpB);
+      enved_help_button = gtk_dialog_add_button(GTK_DIALOG(enved_dialog), "Help", GTK_RESPONSE_NONE);
+      enved_reset_button = gtk_dialog_add_button(GTK_DIALOG(enved_dialog), "Clear graph", GTK_RESPONSE_NONE);
+      enved_cancel_button = gtk_dialog_add_button(GTK_DIALOG(enved_dialog), I_GO_AWAY, GTK_RESPONSE_NONE);
+      enved_apply2_button = gtk_dialog_add_button(GTK_DIALOG(enved_dialog), "Undo&Apply", GTK_RESPONSE_NONE);
+      enved_apply_button = gtk_dialog_add_button(GTK_DIALOG(enved_dialog), "Apply", GTK_RESPONSE_NONE);
+
+      gtk_widget_set_name(enved_help_button, "dialog_button");
+      gtk_widget_set_name(enved_cancel_button, "dialog_button");
+      gtk_widget_set_name(enved_apply_button, "dialog_button");
+      gtk_widget_set_name(enved_apply2_button, "dialog_button");
+      gtk_widget_set_name(enved_reset_button, "dialog_button");
+
+      SG_SIGNAL_CONNECT(enved_cancel_button, "clicked", dismiss_enved_callback, NULL);
+      SG_SIGNAL_CONNECT(enved_reset_button, "clicked", enved_reset_button_pressed, NULL);
+      SG_SIGNAL_CONNECT(enved_help_button, "clicked", help_enved_callback, NULL);
+      SG_SIGNAL_CONNECT(enved_apply2_button, "clicked", undo_and_apply_enved_callback, NULL);
+      SG_SIGNAL_CONNECT(enved_apply_button, "clicked", apply_enved_callback, NULL);
+
+#if GTK_CHECK_VERSION(3, 0, 0)
+      add_highlight_button_style(enved_cancel_button);
+      add_highlight_button_style(enved_apply_button);
+      add_highlight_button_style(enved_apply2_button);
+      add_highlight_button_style(enved_reset_button);
+      add_highlight_button_style(enved_help_button);
+#endif
+      gtk_widget_show(enved_cancel_button);
+      gtk_widget_show(enved_apply_button);
+      gtk_widget_show(enved_apply2_button);
+      gtk_widget_show(enved_reset_button);
+      gtk_widget_show(enved_help_button);
 
       mainform = gtk_hbox_new(false, 0); /* buttons + graph */
       gtk_box_pack_start(GTK_BOX(DIALOG_CONTENT_AREA(enved_dialog)), mainform, true, true, 0);
@@ -987,224 +930,280 @@ GtkWidget *create_envelope_editor(void)
       gtk_widget_show(leftbox);
 
       bottombox = gtk_vbox_new(false, 0);
-      gtk_box_pack_start(GTK_BOX(DIALOG_CONTENT_AREA(enved_dialog)), bottombox, false, false, 0);
+      gtk_box_pack_start(GTK_BOX(DIALOG_CONTENT_AREA(enved_dialog)), bottombox, false, false, 4);
       gtk_widget_show(bottombox);
 
-      drawer = gtk_drawing_area_new();
-      gtk_box_pack_start(GTK_BOX(mainform), drawer, true, true, 0);
-      gtk_widget_set_events(drawer, GDK_ALL_EVENTS_MASK);
-      widget_modify_bg(drawer, GTK_STATE_NORMAL, ss->white);
-      widget_modify_fg(drawer, GTK_STATE_NORMAL, ss->black);
-      gtk_widget_show(drawer);
-
-      showB = gtk_button_new_with_label("view envs");
-      gtk_button_set_relief(GTK_BUTTON(showB), GTK_RELIEF_HALF);
-      gtk_box_pack_start(GTK_BOX(leftbox), showB, false, false, BB_MARGIN);
-      SG_SIGNAL_CONNECT(showB, "clicked", show_button_pressed, NULL);
-      gtk_widget_show(showB);
-
-      saverow = gtk_hbox_new(false, BB_MARGIN);
-      gtk_box_pack_start(GTK_BOX(leftbox), saverow, false, false, BB_MARGIN);
-      gtk_widget_show(saverow);
-
-      saveB = gtk_button_new_with_label(" save ");
-      gtk_button_set_relief(GTK_BUTTON(saveB), GTK_RELIEF_HALF);
-      gtk_box_pack_start(GTK_BOX(saverow), saveB, true, true, BB_MARGIN);
-      SG_SIGNAL_CONNECT(saveB, "clicked", save_button_pressed, NULL);
-      gtk_widget_show(saveB);
-
-      printB = gtk_button_new_with_label(" print  ");
-      gtk_button_set_relief(GTK_BUTTON(printB), GTK_RELIEF_HALF);
-      gtk_box_pack_start(GTK_BOX(saverow), printB, true, true, BB_MARGIN);
-      SG_SIGNAL_CONNECT(printB, "clicked", print_button_pressed, NULL);
-      gtk_widget_show(printB);
-
-      revrow = gtk_hbox_new(false, 0);
-      gtk_box_pack_start(GTK_BOX(leftbox), revrow, false, false, BB_MARGIN);
-      gtk_widget_show(revrow);
-
-      revertB = gtk_button_new_with_label("revert ");
-      gtk_button_set_relief(GTK_BUTTON(revertB), GTK_RELIEF_HALF);
-      gtk_box_pack_start(GTK_BOX(revrow), revertB, true, true, BB_MARGIN);
-      SG_SIGNAL_CONNECT(revertB, "clicked", revert_button_pressed, NULL);
-      gtk_widget_show(revertB);
-
-      deleteB = gtk_button_new_with_label("delete");
-      gtk_button_set_relief(GTK_BUTTON(deleteB), GTK_RELIEF_HALF);
-      gtk_box_pack_start(GTK_BOX(revrow), deleteB, true, true, BB_MARGIN);
-      SG_SIGNAL_CONNECT(deleteB, "clicked", delete_button_pressed, NULL);
-      gtk_widget_show(deleteB);
+
+      enved_drawer = gtk_drawing_area_new();
+      gtk_box_pack_start(GTK_BOX(mainform), enved_drawer, true, true, 0);
+      gtk_widget_set_events(enved_drawer, GDK_ALL_EVENTS_MASK);
+      widget_modify_bg(enved_drawer, GTK_STATE_NORMAL, ss->white);
+      widget_modify_fg(enved_drawer, GTK_STATE_NORMAL, ss->black);
+      gtk_widget_show(enved_drawer);
+
+      show_button = gtk_button_new_with_label("view envs");
+      gtk_button_set_relief(GTK_BUTTON(show_button), GTK_RELIEF_HALF);
+      gtk_box_pack_start(GTK_BOX(leftbox), show_button, false, false, BB_MARGIN);
+      SG_SIGNAL_CONNECT(show_button, "clicked", show_button_pressed, NULL);
+#if GTK_CHECK_VERSION(3, 0, 0)
+      add_highlight_button_style(show_button);
+#endif
+      gtk_widget_show(show_button);
+
+      enved_save_button = gtk_button_new_with_label("define it");
+      gtk_button_set_relief(GTK_BUTTON(enved_save_button), GTK_RELIEF_HALF);
+      gtk_box_pack_start(GTK_BOX(leftbox), enved_save_button, false, false, BB_MARGIN);
+      SG_SIGNAL_CONNECT(enved_save_button, "clicked", enved_save_button_pressed, NULL);
+#if GTK_CHECK_VERSION(3, 0, 0)
+      add_highlight_button_style(enved_save_button);
+#endif
+      gtk_widget_show(enved_save_button);
+
+      enved_revert_button = gtk_button_new_with_label("revert ");
+      gtk_button_set_relief(GTK_BUTTON(enved_revert_button), GTK_RELIEF_HALF);
+      gtk_box_pack_start(GTK_BOX(leftbox), enved_revert_button, false, false, BB_MARGIN);
+      SG_SIGNAL_CONNECT(enved_revert_button, "clicked", enved_revert_button_pressed, NULL);
+#if GTK_CHECK_VERSION(3, 0, 0)
+      add_highlight_button_style(enved_revert_button);
+#endif
+      gtk_widget_show(enved_revert_button);
 
       unrow = gtk_hbox_new(false, 0);
       gtk_box_pack_start(GTK_BOX(leftbox), unrow, false, false, BB_MARGIN);
       gtk_widget_show(unrow);
 
-      undoB = gtk_button_new_with_label(" undo ");
-      gtk_button_set_relief(GTK_BUTTON(undoB), GTK_RELIEF_HALF);
-      gtk_box_pack_start(GTK_BOX(unrow), undoB, true, true, BB_MARGIN);
-      SG_SIGNAL_CONNECT(undoB, "clicked", undo_button_pressed, NULL);
-      gtk_widget_show(undoB);
-
-      redoB = gtk_button_new_with_label(" redo ");
-      gtk_button_set_relief(GTK_BUTTON(redoB), GTK_RELIEF_HALF);
-      gtk_box_pack_start(GTK_BOX(unrow), redoB, true, true, BB_MARGIN);
-      SG_SIGNAL_CONNECT(redoB, "clicked", redo_button_pressed, NULL);
-      gtk_widget_show(redoB);
+      enved_undo_button = gtk_button_new_with_label(" undo ");
+      gtk_button_set_relief(GTK_BUTTON(enved_undo_button), GTK_RELIEF_HALF);
+      gtk_box_pack_start(GTK_BOX(unrow), enved_undo_button, true, true, BB_MARGIN);
+      SG_SIGNAL_CONNECT(enved_undo_button, "clicked", enved_undo_button_pressed, NULL);
+#if GTK_CHECK_VERSION(3, 0, 0)
+      add_highlight_button_style(enved_undo_button);
+#endif
+      gtk_widget_show(enved_undo_button);
+
+      enved_redo_button = gtk_button_new_with_label(" redo ");
+      gtk_button_set_relief(GTK_BUTTON(enved_redo_button), GTK_RELIEF_HALF);
+      gtk_box_pack_start(GTK_BOX(unrow), enved_redo_button, true, true, BB_MARGIN);
+      SG_SIGNAL_CONNECT(enved_redo_button, "clicked", enved_redo_button_pressed, NULL);
+#if GTK_CHECK_VERSION(3, 0, 0)
+      add_highlight_button_style(enved_redo_button);
+#endif
+      gtk_widget_show(enved_redo_button);
 
       rbrow = gtk_hbox_new(false, 0);
       gtk_box_pack_start(GTK_BOX(leftbox), rbrow, false, false, BB_MARGIN);
       gtk_widget_show(rbrow);
 
-      ampB = gtk_button_new_with_label("amp");
-      gtk_button_set_relief(GTK_BUTTON(ampB), GTK_RELIEF_HALF);
-      gtk_box_pack_start(GTK_BOX(rbrow), ampB, true, true, BB_MARGIN);
-      SG_SIGNAL_CONNECT(ampB, "clicked", amp_button_pressed, NULL);
-      gtk_widget_show(ampB);
-
-      fltB = gtk_button_new_with_label("flt");
-      gtk_button_set_relief(GTK_BUTTON(fltB), GTK_RELIEF_HALF);
-      gtk_box_pack_start(GTK_BOX(rbrow), fltB, true, true, BB_MARGIN);
-      SG_SIGNAL_CONNECT(fltB, "clicked", flt_button_pressed, NULL);
-      gtk_widget_show(fltB);
-
-      srcB = gtk_button_new_with_label("src");
-      gtk_button_set_relief(GTK_BUTTON(srcB), GTK_RELIEF_HALF);
-      gtk_box_pack_start(GTK_BOX(rbrow), srcB, true, true, BB_MARGIN);
-      SG_SIGNAL_CONNECT(srcB, "clicked", src_button_pressed, NULL);
-      gtk_widget_show(srcB);
-
-      lerow = gtk_hbox_new(false, 0);
-      gtk_box_pack_start(GTK_BOX(leftbox), lerow, false, false, BB_MARGIN);
-      gtk_widget_show(lerow);
-
-      linB = gtk_button_new_with_label("lin");
-      gtk_button_set_relief(GTK_BUTTON(linB), GTK_RELIEF_HALF);
-      gtk_box_pack_start(GTK_BOX(lerow), linB, true, true, BB_MARGIN);
-      SG_SIGNAL_CONNECT(linB, "clicked", lin_button_pressed, NULL);
-      gtk_widget_show(linB);
+      amp_button = gtk_button_new_with_label("amp");
+      gtk_button_set_relief(GTK_BUTTON(amp_button), GTK_RELIEF_HALF);
+      gtk_box_pack_start(GTK_BOX(rbrow), amp_button, true, true, BB_MARGIN);
+      SG_SIGNAL_CONNECT(amp_button, "clicked", amp_button_pressed, NULL);
+#if GTK_CHECK_VERSION(3, 0, 0)
+      add_highlight_button_style(amp_button);
+#endif
+      gtk_widget_show(amp_button);
+
+      flt_button = gtk_button_new_with_label("flt");
+      gtk_button_set_relief(GTK_BUTTON(flt_button), GTK_RELIEF_HALF);
+      gtk_box_pack_start(GTK_BOX(rbrow), flt_button, true, true, BB_MARGIN);
+      SG_SIGNAL_CONNECT(flt_button, "clicked", flt_button_pressed, NULL);
+#if GTK_CHECK_VERSION(3, 0, 0)
+      add_highlight_button_style(flt_button);
+#endif
+      gtk_widget_show(flt_button);
+
+      src_button = gtk_button_new_with_label("src");
+      gtk_button_set_relief(GTK_BUTTON(src_button), GTK_RELIEF_HALF);
+      gtk_box_pack_start(GTK_BOX(rbrow), src_button, true, true, BB_MARGIN);
+      SG_SIGNAL_CONNECT(src_button, "clicked", src_button_pressed, NULL);
+#if GTK_CHECK_VERSION(3, 0, 0)
+      add_highlight_button_style(src_button);
+#endif
+      gtk_widget_show(src_button);
 
-      expB = gtk_button_new_with_label("exp");
-      gtk_button_set_relief(GTK_BUTTON(expB), GTK_RELIEF_HALF);
-      gtk_box_pack_start(GTK_BOX(lerow), expB, true, true, BB_MARGIN);
-      SG_SIGNAL_CONNECT(expB, "clicked", exp_button_pressed, NULL);
-      gtk_widget_show(expB);
 
       selrow = gtk_hbox_new(false, 0);
       gtk_box_pack_start(GTK_BOX(leftbox), selrow, false, false, BB_MARGIN);
       gtk_widget_show(selrow);
 
-      selectionB = gtk_button_new_with_label("selection");
-      gtk_button_set_relief(GTK_BUTTON(selectionB), GTK_RELIEF_HALF);
-      gtk_box_pack_start(GTK_BOX(selrow), selectionB, true, true, BB_MARGIN);
-      SG_SIGNAL_CONNECT(selectionB, "clicked", selection_button_pressed, NULL);
-      gtk_widget_show(selectionB);
+      enved_selection_button = gtk_button_new_with_label("selection");
+      gtk_button_set_relief(GTK_BUTTON(enved_selection_button), GTK_RELIEF_HALF);
+      gtk_box_pack_start(GTK_BOX(selrow), enved_selection_button, true, true, BB_MARGIN);
+      SG_SIGNAL_CONNECT(enved_selection_button, "clicked", enved_selection_button_pressed, NULL);
+#if GTK_CHECK_VERSION(3, 0, 0)
+      add_highlight_button_style(enved_selection_button);
+#endif
+      gtk_widget_show(enved_selection_button);
 
       env_list = slist_new_with_title("envs:", leftbox, NULL, 0, BOX_PACK);
       env_list->select_callback = env_browse_callback;
       if (enved_all_envs_top() > 0) make_scrolled_env_list();
 
+
       toprow = gtk_hbox_new(false, 0);
-      gtk_box_pack_start(GTK_BOX(bottombox), toprow, false, false, 6);
+      gtk_box_pack_start(GTK_BOX(bottombox), toprow, false, false, 0);
       gtk_widget_show(toprow);
 
       bottomrow = gtk_hbox_new(false, 0);
-      gtk_box_pack_start(GTK_BOX(bottombox), bottomrow, false, false, 4);
+      gtk_box_pack_start(GTK_BOX(bottombox), bottomrow, false, false, 0);
       gtk_widget_show(bottomrow);
 
-      nameL = gtk_label_new("amp env:");
-      gtk_box_pack_start(GTK_BOX(toprow), nameL, false, false, 0);
-      gtk_widget_show(nameL);
+      {
+	GtkWidget* sep;
+	sep = gtk_hseparator_new();
+	gtk_box_pack_end(GTK_BOX(DIALOG_CONTENT_AREA(enved_dialog)), sep, false, false, 8);
+	gtk_widget_show(sep);
+      }
+
+      #define LEFT_MARGIN 8
+
+      enved_name_label = gtk_label_new("amp env:");
+      widget_set_margin_left(enved_name_label, LEFT_MARGIN);
+      gtk_box_pack_start(GTK_BOX(toprow), enved_name_label, false, false, 0);
+      gtk_widget_show(enved_name_label);
 
-      textL = snd_entry_new(toprow, WITH_WHITE_BACKGROUND);
-      SG_SIGNAL_CONNECT(textL, "activate", text_field_activated, NULL);
+      enved_text_label = snd_entry_new_with_size(toprow, 28);
+      SG_SIGNAL_CONNECT(enved_text_label, "activate", text_field_activated, NULL);
 
-      brktxtL = gtk_button_new_with_label(BLANK_LABEL);
-      gtk_button_set_relief(GTK_BUTTON(brktxtL), GTK_RELIEF_NONE);
+      brktxtL = gtk_label_new(BLANK_LABEL);
       gtk_box_pack_start(GTK_BOX(toprow), brktxtL, false, false, 6);
       gtk_widget_show(brktxtL);
 
-      clipB = gtk_check_button_new_with_label("clip");
-      SG_SIGNAL_CONNECT(clipB, "toggled", clip_button_callback, NULL);
-      gtk_box_pack_start(GTK_BOX(toprow), clipB, false, false, 4);
-      gtk_widget_show(clipB);
 
-      graphB = gtk_check_button_new_with_label("wave");
-      SG_SIGNAL_CONNECT(graphB, "toggled", graph_button_callback, NULL);
-      gtk_box_pack_start(GTK_BOX(toprow), graphB, false, false, 4);
-      gtk_widget_show(graphB);
+      enved_dB_button = gtk_check_button_new_with_label("dB");
+      SG_SIGNAL_CONNECT(enved_dB_button, "toggled", enved_dB_button_callback, NULL);
+      gtk_box_pack_end(GTK_BOX(toprow), enved_dB_button, false, false, 4);
+      gtk_widget_show(enved_dB_button);
+
+      enved_graph_button = gtk_check_button_new_with_label("wave");
+      SG_SIGNAL_CONNECT(enved_graph_button, "toggled", enved_graph_button_callback, NULL);
+      gtk_box_pack_end(GTK_BOX(toprow), enved_graph_button, false, false, 4);
+      gtk_widget_show(enved_graph_button);
+
+      clip_button = gtk_check_button_new_with_label("clip");
+      SG_SIGNAL_CONNECT(clip_button, "toggled", clip_button_callback, NULL);
+      gtk_box_pack_end(GTK_BOX(toprow), clip_button, false, false, 4);
+      gtk_widget_show(clip_button);
 
-      dBB = gtk_check_button_new_with_label("dB");
-      SG_SIGNAL_CONNECT(dBB, "toggled", dB_button_callback, NULL);
-      gtk_box_pack_start(GTK_BOX(toprow), dBB, false, false, 4);
-      gtk_widget_show(dBB);
 
       baseLabel = gtk_label_new("exp:");
-      gtk_box_pack_start(GTK_BOX(bottomrow), baseLabel, false, false, 2);
+      widget_set_margin_left(baseLabel, LEFT_MARGIN);
+      gtk_box_pack_start(GTK_BOX(bottomrow), baseLabel, false, false, 4);
       gtk_widget_show(baseLabel);
 
       baseValue = gtk_label_new("1.000");
-      gtk_box_pack_start(GTK_BOX(bottomrow), baseValue, false, false, 2);
+      gtk_box_pack_start(GTK_BOX(bottomrow), baseValue, false, false, 4);
       gtk_widget_show(baseValue);
 
 
+      lerow = gtk_vbox_new(false, 0);
+      gtk_box_pack_start(GTK_BOX(bottomrow), lerow, true, true, 8);
+      gtk_widget_show(lerow);
+
+      {
+	GtkWidget* sep;
+	sep = gtk_vseparator_new();
+	gtk_box_pack_start(GTK_BOX(lerow), sep, false, false, 8);
+	gtk_widget_show(sep);
+      }
+
       baseAdj = (GtkAdjustment *)gtk_adjustment_new(0.5, 0.0, 1.0, 0.001, 0.01, .1);
       baseScale = gtk_hscrollbar_new(GTK_ADJUSTMENT(baseAdj));
       widget_modify_bg(baseScale, GTK_STATE_NORMAL, ss->position_color);
       SG_SIGNAL_CONNECT(baseAdj, "value_changed", base_changed_callback, NULL);
-      gtk_box_pack_start(GTK_BOX(bottomrow), baseScale, true, true, 4);
+      /* gtk_box_pack_start(GTK_BOX(bottomrow), baseScale, true, true, 4); */
+      gtk_box_pack_start(GTK_BOX(lerow), baseScale, true, true, 0);
       gtk_widget_show(baseScale);
 
+
+      {
+	/* try to center the linear button */
+	GtkWidget *hr, *rb, *lb;
+
+	hr = gtk_hbox_new(false, 0);
+	gtk_box_pack_start(GTK_BOX(lerow), hr, false, false, 4);
+	gtk_widget_show(hr);
+
+	rb = gtk_label_new("");
+	gtk_box_pack_start(GTK_BOX(hr), rb, true, true, 2);
+	gtk_widget_show(rb);
+
+	lb = gtk_label_new("");
+	gtk_box_pack_end(GTK_BOX(hr), lb, true, true, 2);
+	gtk_widget_show(lb);
+
+	lin_button = gtk_button_new_with_label("1.0");
+	gtk_box_pack_start(GTK_BOX(hr), lin_button, false, false, 4);
+	SG_SIGNAL_CONNECT(lin_button, "clicked", make_linear, NULL);
+#if GTK_CHECK_VERSION(3, 0, 0)
+	add_center_button_style(lin_button); 
+#endif
+	gtk_widget_show(lin_button);
+      }
+
       orderAdj = (GtkAdjustment *)gtk_adjustment_new(20, 2, 100000, 2, 10, 0);
-      orderL = gtk_spin_button_new(GTK_ADJUSTMENT(orderAdj), 0.0, 0);
-      gtk_box_pack_end(GTK_BOX(bottomrow), orderL, false, false, 4);
-      gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(orderL), true);
+      enved_order_label = gtk_spin_button_new(GTK_ADJUSTMENT(orderAdj), 0.0, 0);
+      gtk_box_pack_end(GTK_BOX(bottomrow), enved_order_label, false, false, 4);
+      gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(enved_order_label), true);
       SG_SIGNAL_CONNECT(orderAdj, "value_changed", enved_filter_order_callback, NULL);
-      SG_SIGNAL_CONNECT(orderL, "enter_notify_event", spin_button_focus_callback, NULL);
-      SG_SIGNAL_CONNECT(orderL, "leave_notify_event", spin_button_unfocus_callback, NULL);
-      gtk_widget_show(orderL);
-
-      firB = gtk_button_new_with_label((FIR_p) ? "fir" : "fft");
-      SG_SIGNAL_CONNECT(firB, "clicked", fir_button_pressed, NULL);
-      gtk_box_pack_end(GTK_BOX(bottomrow), firB, false, false, 4);
-      gtk_widget_show(firB);
+      SG_SIGNAL_CONNECT(enved_order_label, "enter_notify_event", spin_button_focus_callback, NULL);
+      SG_SIGNAL_CONNECT(enved_order_label, "leave_notify_event", spin_button_unfocus_callback, NULL);
+      gtk_widget_show(enved_order_label);
+
+      /* fir_button = gtk_button_new_with_label((is_FIR) ? "fir" : "fft"); */
+      /* SG_SIGNAL_CONNECT(eb, "clicked", fir_button_pressed, NULL); */
+      {
+	GtkWidget *eb;
+	
+	eb = gtk_event_box_new();
+	gtk_box_pack_end(GTK_BOX(bottomrow), eb, false, false, 4);
+	widget_set_margin_left(eb, 8);
+	widget_modify_bg(eb, GTK_STATE_NORMAL, ss->basic_color);
+	gtk_widget_set_events(eb, GDK_BUTTON_PRESS_MASK);
+	SG_SIGNAL_CONNECT(eb, "button_press_event", fir_button_pressed, NULL);
+	gtk_widget_show(eb);
+
+	fir_button = gtk_label_new("fir");
+	gtk_container_add(GTK_CONTAINER(eb), fir_button);
+	gtk_widget_show(fir_button);
+      }
 
       gtk_widget_show(mainform);
       gtk_widget_show(enved_dialog);
 
       axis = (axis_info *)calloc(1, sizeof(axis_info));
       axis->ax = (graphics_context *)calloc(1, sizeof(graphics_context));
-      axis->ax->wn = WIDGET_TO_WINDOW(drawer);
-      axis->ax->w = drawer;
+      axis->ax->wn = WIDGET_TO_WINDOW(enved_drawer);
+      axis->ax->w = enved_drawer;
       axis->ax->gc = gc;
       axis->ax->current_font = AXIS_NUMBERS_FONT(ss);
 
       gray_ap = (axis_info *)calloc(1, sizeof(axis_info));
       gray_ap->ax = (graphics_context *)calloc(1, sizeof(graphics_context));
       gray_ap->graph_active = true;
-      gray_ap->ax->wn = WIDGET_TO_WINDOW(drawer);
-      gray_ap->ax->w = drawer;
+      gray_ap->ax->wn = WIDGET_TO_WINDOW(enved_drawer);
+      gray_ap->ax->w = enved_drawer;
       gray_ap->ax->gc = ggc;
       gray_ap->ax->current_font = AXIS_NUMBERS_FONT(ss);
 
-      SG_SIGNAL_CONNECT(drawer, DRAW_SIGNAL, drawer_expose, NULL);
-      SG_SIGNAL_CONNECT(drawer, "configure_event", drawer_resize, NULL);
-      SG_SIGNAL_CONNECT(drawer, "button_press_event", drawer_button_press, NULL);
-      SG_SIGNAL_CONNECT(drawer, "button_release_event", drawer_button_release, NULL);
-      SG_SIGNAL_CONNECT(drawer, "motion_notify_event", drawer_button_motion, NULL);
+      SG_SIGNAL_CONNECT(enved_drawer, DRAW_SIGNAL, enved_drawer_expose, NULL);
+      SG_SIGNAL_CONNECT(enved_drawer, "configure_event", enved_drawer_resize, NULL);
+      SG_SIGNAL_CONNECT(enved_drawer, "button_press_event", enved_drawer_button_press, NULL);
+      SG_SIGNAL_CONNECT(enved_drawer, "button_release_event", enved_drawer_button_release, NULL);
+      SG_SIGNAL_CONNECT(enved_drawer, "motion_notify_event", enved_drawer_button_motion, NULL);
 
       if (enved_all_envs_top() == 0)
-	set_sensitive(showB, false);
-      set_sensitive(revertB, false);
-      set_sensitive(deleteB, false);
-      set_sensitive(undoB, false);
-      set_sensitive(redoB, false);
-      set_sensitive(saveB, false);
+	set_sensitive(show_button, false);
+      set_sensitive(enved_revert_button, false);
+      set_sensitive(enved_undo_button, false);
+      set_sensitive(enved_redo_button, false);
+      set_sensitive(enved_save_button, false);
       if (!(selection_is_active())) 
-	set_sensitive(selectionB, false);
+	set_sensitive(enved_selection_button, false);
 
-      set_toggle_button(clipB, enved_clip_p(ss), false, NULL);
-      set_toggle_button(graphB, enved_wave_p(ss), false, NULL);
-      set_toggle_button(dBB, enved_in_dB(ss), false, NULL);
+      set_toggle_button(clip_button, enved_clipping(ss), false, NULL);
+      set_toggle_button(enved_graph_button, enved_with_wave(ss), false, NULL);
+      set_toggle_button(enved_dB_button, enved_in_dB(ss), false, NULL);
 
       reflect_apply_state();
       reflect_segment_state();
@@ -1212,13 +1211,12 @@ GtkWidget *create_envelope_editor(void)
 
       set_dialog_widget(ENVED_DIALOG, enved_dialog);
 
-      XEN_ADD_HOOK(ss->snd_open_file_hook, reflect_file_in_enved_w, "enved-file-open-handler", "enved dialog's file-open-hook handler");
-      XEN_ADD_HOOK(ss->snd_selection_hook, enved_selection_handler_w, "enved-selection-handler", "enved dialog's selection-hook handler");
+      Xen_add_to_hook_list(ss->snd_open_file_hook, reflect_file_in_enved_w, "enved-file-open-handler", "enved dialog's file-open-hook handler");
     }
   else raise_dialog(enved_dialog);
 
-  env_window_width = widget_width(drawer);
-  env_window_height = widget_height(drawer);
+  env_window_width = widget_width(enved_drawer);
+  env_window_height = widget_height(enved_drawer);
   active_channel = current_channel();
   env_redisplay();
 
@@ -1226,10 +1224,10 @@ GtkWidget *create_envelope_editor(void)
 }
 
 
-void set_enved_clip_p(bool val) 
+void set_enved_clipping(bool val) 
 {
-  in_set_enved_clip_p(val); 
-  if (enved_dialog) set_toggle_button(clipB, val, false, NULL);
+  in_set_enved_clipping(val); 
+  if (enved_dialog) set_toggle_button(clip_button, val, false, NULL);
 }
 
 
@@ -1246,17 +1244,17 @@ void set_enved_target(enved_target_t val)
 }
 
 
-void set_enved_wave_p(bool val) 
+void set_enved_with_wave(bool val) 
 {
-  in_set_enved_wave_p(val); 
-  if (enved_dialog) set_toggle_button(graphB, val, false, NULL);
+  in_set_enved_with_wave(val); 
+  if (enved_dialog) set_toggle_button(enved_graph_button, val, false, NULL);
 }
 
 
 void set_enved_in_dB(bool val) 
 {
   in_set_enved_in_dB(val); 
-  if (enved_dialog) set_toggle_button(dBB, val, false, NULL);
+  if (enved_dialog) set_toggle_button(enved_dB_button, val, false, NULL);
 }
 
 
@@ -1278,13 +1276,13 @@ void set_enved_filter_order(int order)
   if ((order > 0) && (order < 2000))
     {
       if (order & 1) 
-	in_set_enved_filter_order(order + 1);
-      else in_set_enved_filter_order(order);
+	{in_set_enved_filter_order(order + 1);}
+      else {in_set_enved_filter_order(order);}
       if (enved_dialog)
 	{
-	  widget_int_to_text(orderL, enved_filter_order(ss));
+	  widget_int_to_text(enved_order_label, enved_filter_order(ss));
 	  if ((enved_target(ss) == ENVED_SPECTRUM) && 
-	      (enved_wave_p(ss)) && 
+	      (enved_with_wave(ss)) && 
 	      (!showing_all_envs)) 
 	    env_redisplay();
 	}
@@ -1292,11 +1290,11 @@ void set_enved_filter_order(int order)
 }
 
 
-static void enved_reflect_selection(bool on)
+void enved_reflect_selection(bool on)
 {
   if ((enved_dialog) && (!within_selection_src))
     {
-      set_sensitive(selectionB, on);
+      set_sensitive(enved_selection_button, on);
       if ((apply_to_selection) && (!on))
 	{
 	  apply_to_selection = false;
@@ -1306,9 +1304,9 @@ static void enved_reflect_selection(bool on)
 	{
 	  apply_to_selection = true;
 	}
-      widget_modify_bg(selectionB, GTK_STATE_NORMAL, (apply_to_selection) ? ss->yellow : ss->basic_color);
+      widget_modify_bg(enved_selection_button, GTK_STATE_NORMAL, (apply_to_selection) ? ss->yellow : ss->basic_color);
       if ((enved_target(ss) != ENVED_SPECTRUM) && 
-	  (enved_wave_p(ss)) && 
+	  (enved_with_wave(ss)) && 
 	  (!showing_all_envs)) 
 	env_redisplay();
     }
@@ -1317,32 +1315,31 @@ static void enved_reflect_selection(bool on)
 
 void color_enved_waveform(color_info *pix)
 {
-  ss->enved_waveform_color = pix;
   if (enved_dialog)
     {
       gc_set_foreground(ggc, pix);
-      if ((enved_wave_p(ss)) && (enved_dialog)) env_redisplay();
+      if ((enved_with_wave(ss)) && (enved_dialog)) env_redisplay();
     }
 }
 
 
-static XEN g_enved_envelope(void)
+static Xen g_enved_envelope(void)
 {
   #define H_enved_envelope "(" S_enved_envelope "): current envelope editor displayed (active) envelope"
   return(env_to_xen(active_env));
 }
 
 
-static XEN g_set_enved_envelope(XEN e)
+static Xen g_set_enved_envelope(Xen e)
 {
-  XEN_ASSERT_TYPE(XEN_LIST_P(e) || XEN_STRING_P(e) || XEN_SYMBOL_P(e), e, XEN_ONLY_ARG, S_setB S_enved_envelope, "a list, symbol, or string");
+  Xen_check_type(Xen_is_list(e) || Xen_is_string(e) || Xen_is_symbol(e), e, 1, S_set S_enved_envelope, "a list, symbol, or string");
   if (active_env) active_env = free_env(active_env);
-  if ((XEN_STRING_P(e)) || (XEN_SYMBOL_P(e)))
-    active_env = name_to_env((XEN_STRING_P(e)) ? XEN_TO_C_STRING(e) : XEN_SYMBOL_TO_C_STRING(e));
+  if ((Xen_is_string(e)) || (Xen_is_symbol(e)))
+    active_env = name_to_env((Xen_is_string(e)) ? Xen_string_to_C_string(e) : Xen_symbol_to_C_string(e));
   else active_env = xen_to_env(e);
-  if ((!active_env) && (!(XEN_LIST_P(e))))
-    XEN_ERROR(NO_SUCH_ENVELOPE,
-	      XEN_LIST_2(C_TO_XEN_STRING(S_setB S_enved_envelope ": bad envelope arg: ~A"),
+  if ((!active_env) && (!(Xen_is_list(e))))
+    Xen_error(NO_SUCH_ENVELOPE,
+	      Xen_list_2(C_string_to_Xen_string(S_set S_enved_envelope ": bad envelope arg: ~A"),
 			 e));
   if (enved_dialog) 
     env_redisplay();
@@ -1350,40 +1347,33 @@ static XEN g_set_enved_envelope(XEN e)
 }
 
 
-static XEN g_enved_filter(void)
+static Xen g_enved_filter(void)
 {
-  #define H_enved_filter "(" S_enved_filter "): envelope editor FIR/FFT filter choice (#t: FIR)"
-  return(C_TO_XEN_BOOLEAN(FIR_p));
+  #define H_enved_filter "(" S_enved_filter "): envelope editor FIR/FFT filter choice (" PROC_TRUE ": FIR)"
+  return(C_bool_to_Xen_boolean(is_FIR));
 }
 
 
-static XEN g_set_enved_filter(XEN type)
+static Xen g_set_enved_filter(Xen type)
 {
-  XEN_ASSERT_TYPE(XEN_BOOLEAN_P(type), type, XEN_ONLY_ARG, S_setB S_enved_filter, "boolean");
-  FIR_p = XEN_TO_C_BOOLEAN(type);
-  if (firB)
-    set_button_label(firB, (FIR_p) ? "fir" : "fft");
+  Xen_check_type(Xen_is_boolean(type), type, 1, S_set S_enved_filter, "boolean");
+  is_FIR = Xen_boolean_to_C_bool(type);
+  if (fir_button)
+    gtk_label_set_text(GTK_LABEL(fir_button), (is_FIR) ? "fir" : "fft");
   return(type);
 }
 
 
-#ifdef XEN_ARGIFY_1
-XEN_NARGIFY_0(g_enved_filter_w, g_enved_filter)
-XEN_NARGIFY_1(g_set_enved_filter_w, g_set_enved_filter)
-XEN_NARGIFY_0(g_enved_envelope_w, g_enved_envelope)
-XEN_NARGIFY_1(g_set_enved_envelope_w, g_set_enved_envelope)
-#else
-#define g_enved_filter_w g_enved_filter
-#define g_set_enved_filter_w g_set_enved_filter
-#define g_enved_envelope_w g_enved_envelope
-#define g_set_enved_envelope_w g_set_enved_envelope
-#endif
+Xen_wrap_no_args(g_enved_filter_w, g_enved_filter)
+Xen_wrap_1_arg(g_set_enved_filter_w, g_set_enved_filter)
+Xen_wrap_no_args(g_enved_envelope_w, g_enved_envelope)
+Xen_wrap_1_arg(g_set_enved_envelope_w, g_set_enved_envelope)
 
 void g_init_gxenv(void)
 {
-  XEN_DEFINE_PROCEDURE_WITH_SETTER(S_enved_filter, g_enved_filter_w, H_enved_filter,
-				   S_setB S_enved_filter, g_set_enved_filter_w,  0, 0, 1, 0);
-  XEN_DEFINE_PROCEDURE_WITH_SETTER(S_enved_envelope, g_enved_envelope_w, H_enved_envelope,
-				   S_setB S_enved_envelope, g_set_enved_envelope_w,  0, 0, 1, 0);
+  Xen_define_dilambda(S_enved_filter, g_enved_filter_w, H_enved_filter,
+				   S_set S_enved_filter, g_set_enved_filter_w,  0, 0, 1, 0);
+  Xen_define_dilambda(S_enved_envelope, g_enved_envelope_w, H_enved_envelope,
+				   S_set S_enved_envelope, g_set_enved_envelope_w,  0, 0, 1, 0);
 }