Imported Upstream version 16.1

1 files changed, 109 insertions, 117 deletions

diff --git a/snd-menu.c b/snd-menu.c
index e8e99dc..584d632 100644
--- a/snd-menu.c
+++ b/snd-menu.c
@@ -8,11 +8,11 @@ void edit_menu_update(void)
   /* called when the "Edit" top level menu is clicked -- make sure all items reflect current Snd state */
   snd_info *selected_sp = NULL, *any_sp = NULL;
   chan_info *cp = NULL;
-  bool selection_p = false, region_p = false, file_p = false, undoable_edit_p = false, redoable_edit_p = false;
+  bool has_selection = false, has_region = false, file_open = false, has_undoable_edit = false, has_redoable_edit = false;
   selected_sp = selected_sound();
   if (selected_sp) 
     {
-      file_p = true;
+      file_open = true;
       cp = any_selected_channel(selected_sp);
       any_sp = selected_sp;
     }
@@ -22,38 +22,42 @@ void edit_menu_update(void)
       if (any_sp)
 	{
 	  cp = any_selected_channel(any_sp);
-	  file_p = true;
+	  file_open = true;
 	}
     }
-  selection_p = selection_is_active();
-  region_p = region_ok(region_list_position_to_id(0));
+  has_selection = selection_is_active();
+  has_region = region_ok(region_list_position_to_id(0));
   if (cp)
     {
-      undoable_edit_p = (cp->edit_ctr > 0);
-      redoable_edit_p = (!(((cp->edit_ctr + 1) == cp->edit_size) || 
+      has_undoable_edit = (cp->edit_ctr > 0);
+      has_redoable_edit = (!(((cp->edit_ctr + 1) == cp->edit_size) || 
 			   (!(cp->edits[cp->edit_ctr + 1]))));
     }
   
   /* is there an open sound? */
-  set_sensitive(edit_header_menu, file_p);
-  set_sensitive(edit_find_menu, file_p);
-  set_sensitive(edit_select_all_menu, file_p);
+  set_sensitive(edit_header_menu, file_open);
+#if HAVE_EXTENSION_LANGUAGE
+  set_sensitive(edit_find_menu, file_open);
+#endif
+  set_sensitive(edit_select_all_menu, file_open);
 
   /* is there an active selection? */
-  set_sensitive(edit_cut_menu, selection_p);
-  set_sensitive(edit_play_menu, selection_p);
-  set_sensitive(edit_mix_menu, selection_p);
-  set_sensitive(edit_save_as_menu, selection_p);
-  set_sensitive(edit_unselect_menu, selection_p);
+  set_sensitive(edit_cut_menu, has_selection);
+#if WITH_AUDIO
+  set_sensitive(edit_play_menu, has_selection);
+#endif
+  set_sensitive(edit_mix_menu, has_selection);
+  set_sensitive(edit_save_as_menu, has_selection);
+  set_sensitive(edit_unselect_menu, has_selection);
 
   /* is there an undoable edit? */
-  set_sensitive(edit_undo_menu, undoable_edit_p);
+  set_sensitive(edit_undo_menu, has_undoable_edit);
 
   /* is there a redoable edit? */
-  set_sensitive(edit_redo_menu, redoable_edit_p);
+  set_sensitive(edit_redo_menu, has_redoable_edit);
 
   /* does paste make any sense? */
-  set_sensitive(edit_paste_menu, (file_p) && (selection_p || region_p));  
+  set_sensitive(edit_paste_menu, (file_open) && (has_selection || has_region));  
  
   /* make sure edit-header menu option label correctly reflects current selected sound header type */
   if (any_sp)
@@ -93,7 +97,7 @@ void view_menu_update(void)
   set_menu_label(view_zero_menu, (show_y_zero(ss)) ? "Hide Y = 0" : "Show Y = 0");
 
   /* verbose cursor label */
-  set_menu_label(view_cursor_menu, (verbose_cursor(ss)) ? "Silent cursor" : "Verbose cursor");
+  set_menu_label(view_cursor_menu, (with_verbose_cursor(ss)) ? "Silent cursor" : "Verbose cursor");
 
 #if HAVE_EXTENSION_LANGUAGE
   /* inset graph label */
@@ -113,44 +117,49 @@ void view_menu_update(void)
   set_sensitive(view_all_axes_unlabelled_menu,    show_axes(ss) != SHOW_ALL_AXES_UNLABELLED);
   set_sensitive(view_bare_x_axis_menu,            show_axes(ss) != SHOW_BARE_X_AXIS);
 
-#if HAVE_EXTENSION_LANGUAGE
+#if HAVE_EXTENSION_LANGUAGE && USE_MOTIF
   /* make sure listener menu option label correctly reflects current listener state */
   set_menu_label(view_listener_menu, (listener_is_visible()) ? "Hide listener" : "Show listener");
 #endif
 
   set_menu_label(view_controls_menu, (in_show_controls(ss)) ? "Hide controls" : "Show controls");
 
-  /* set_sensitive(view_files_menu, get_view_files_end() >= 0); */
+#if USE_GTK
+  set_sensitive(view_files_menu, view_files_has_files());
+#endif
 
   /* zoom focus style */
   set_sensitive(view_focus_left_menu,   zoom_focus_style(ss) != ZOOM_FOCUS_LEFT);
   set_sensitive(view_focus_right_menu,  zoom_focus_style(ss) != ZOOM_FOCUS_RIGHT);
   set_sensitive(view_focus_middle_menu, zoom_focus_style(ss) != ZOOM_FOCUS_MIDDLE);
   set_sensitive(view_focus_active_menu, zoom_focus_style(ss) != ZOOM_FOCUS_ACTIVE);
+
+  /* grid menu label */
+  set_menu_label(view_grid_menu, (show_grid(ss) == WITH_GRID) ? "Without grid" : "With grid");
 }
 
 
 void file_menu_update(void)
 {
   snd_info *any_sp = NULL;
-  bool file_p = false, edits_p = false;
+  bool file_open = false, has_edits = false;
 
   any_sp = any_selected_sound();
   if (any_sp)
     {
-      edits_p = has_unsaved_edits(any_sp);
-      file_p = true;
+      has_edits = has_unsaved_edits(any_sp);
+      file_open = true;
     }
 
-  set_sensitive(file_close_menu, file_p);
-  set_sensitive(file_print_menu, file_p);
-  set_sensitive(file_mix_menu, file_p);
-  set_sensitive(file_insert_menu, file_p);
-  set_sensitive(file_save_as_menu, file_p);
-  set_sensitive(file_update_menu, file_p);
+  set_sensitive(file_close_menu, file_open);
+  set_sensitive(file_print_menu, file_open);
+  set_sensitive(file_mix_menu, file_open);
+  set_sensitive(file_insert_menu, file_open);
+  set_sensitive(file_save_as_menu, file_open);
+  set_sensitive(file_update_menu, file_open);
 
-  set_sensitive(file_save_menu, edits_p);
-  set_sensitive(file_revert_menu, edits_p);
+  set_sensitive(file_save_menu, has_edits);
+  set_sensitive(file_revert_menu, has_edits);
 
   if (ss->active_sounds > 1)
     activate_widget(file_close_all_menu);
@@ -177,7 +186,7 @@ static void file_update(snd_info *sp)
       ((sp->need_update) || 
        (file_write_date(sp->filename) != sp->write_date)))
     {
-      redirect_everything_to(printout_to_minibuffer, (void *)sp);
+      redirect_everything_to(printout_to_status_area, (void *)sp);
       snd_update(sp);
       redirect_everything_to(NULL, NULL);
     }
@@ -204,24 +213,12 @@ void revert_file_from_menu(void)
 }
 
 
-void save_options_from_menu(void)
-{
-  const char *filename;
-  filename = save_options_in_prefs();
-  if (filename)
-    {
-      if (any_selected_sound())
-	report_in_minibuffer(any_selected_sound(), "saved options in %s", filename);
-    }
-}
-
-
-static bool save_state_error_p = false;
+static bool has_save_state_error = false;
 
 static void save_state_from_menu_error_handler(const char *msg, void *ignore)
 {
   snd_warning_without_format(msg);
-  save_state_error_p = true;
+  has_save_state_error = true;
 }
 
 
@@ -229,14 +226,14 @@ void save_state_from_menu(void)
 {
   if (save_state_file(ss))
     {
-      save_state_error_p = false;
+      has_save_state_error = false;
       redirect_everything_to(save_state_from_menu_error_handler, NULL);
       save_state(save_state_file(ss));
       redirect_everything_to(NULL, NULL);
-      if (!save_state_error_p)
+      if (!has_save_state_error)
 	{
 	  if (any_selected_sound())
-	    report_in_minibuffer(any_selected_sound(), "saved state in %s", save_state_file(ss));
+	    status_report(any_selected_sound(), "saved state in %s", save_state_file(ss));
 	}
     }
   else 
@@ -249,17 +246,17 @@ void save_state_from_menu(void)
 
 /* ---------------- extlang tie-ins ---------------- */
 
-static XEN snd_no_such_menu_error(const char *caller, XEN id)
+static Xen snd_no_such_menu_error(const char *caller, Xen id)
 {
-  XEN_ERROR(XEN_ERROR_TYPE("no-such-menu"),
-	    XEN_LIST_3(C_TO_XEN_STRING("~A: no such menu, ~A"),
-		       C_TO_XEN_STRING(caller),
+  Xen_error(Xen_make_error_type("no-such-menu"),
+	    Xen_list_3(C_string_to_Xen_string("~A: no such menu, ~A"),
+		       C_string_to_Xen_string(caller),
 		       id));
-  return(XEN_FALSE);
+  return(Xen_false);
 }
 
 
-static XEN *menu_functions = NULL;
+static Xen *menu_functions = NULL;
 static int *menu_functions_loc = NULL;
 static int callbacks_size = 0;
 static int callb = 0;
@@ -270,22 +267,22 @@ static int make_callback_slot(void)
 {
   int old_callb, i;
   for (i = 0; i < callb; i++)
-    if (XEN_FALSE_P(menu_functions[i]))
+    if (Xen_is_false(menu_functions[i]))
       return(i);
   if (callbacks_size == callb)
     {
       callbacks_size += CALLBACK_INCR;
       if (callb == 0)
 	{
-	  menu_functions = (XEN *)calloc(callbacks_size, sizeof(XEN));
-	  for (i = 0; i < callbacks_size; i++) menu_functions[i] = XEN_UNDEFINED;
+	  menu_functions = (Xen *)calloc(callbacks_size, sizeof(Xen));
+	  for (i = 0; i < callbacks_size; i++) menu_functions[i] = Xen_undefined;
 	  menu_functions_loc = (int *)calloc(callbacks_size, sizeof(int));
 	  for (i = 0; i < callbacks_size; i++) menu_functions_loc[i] = NOT_A_GC_LOC;
 	}
       else 
 	{
-	  menu_functions = (XEN *)realloc(menu_functions, callbacks_size * sizeof(XEN));
-	  for (i = callbacks_size - CALLBACK_INCR; i < callbacks_size; i++) menu_functions[i] = XEN_UNDEFINED;
+	  menu_functions = (Xen *)realloc(menu_functions, callbacks_size * sizeof(Xen));
+	  for (i = callbacks_size - CALLBACK_INCR; i < callbacks_size; i++) menu_functions[i] = Xen_undefined;
 	  menu_functions_loc = (int *)realloc(menu_functions_loc, callbacks_size * sizeof(int));
 	  for (i = callbacks_size - CALLBACK_INCR; i < callbacks_size; i++) menu_functions_loc[i] = NOT_A_GC_LOC;
 	}
@@ -296,7 +293,7 @@ static int make_callback_slot(void)
 }
 
 
-static void add_callback(int slot, XEN callback)
+static void add_callback(int slot, Xen callback)
 {
   if ((slot >= 0) && (slot < callbacks_size))
     {
@@ -311,23 +308,23 @@ void unprotect_callback(int slot)
   /* called only if menu is being removed */
   if ((slot >= 0) && (slot < callbacks_size))
     {
-      if (XEN_PROCEDURE_P(menu_functions[slot]))
+      if (Xen_is_procedure(menu_functions[slot]))
 	{
 	  snd_unprotect_at(menu_functions_loc[slot]);
 	  menu_functions_loc[slot] = NOT_A_GC_LOC;
 	}
-      menu_functions[slot] = XEN_FALSE;  /* not XEN_UNDEFINED -- need a way to distinguish "no callback" from "recyclable slot" */
+      menu_functions[slot] = Xen_false;  /* not Xen_undefined -- need a way to distinguish "no callback" from "recyclable slot" */
     }
 }
 
 
-static XEN gl_add_to_main_menu(XEN label, XEN callback)
+static Xen gl_add_to_main_menu(Xen label, Xen callback)
 {
   #define H_add_to_main_menu "(" S_add_to_main_menu " label :optional callback): adds label to the main (top-level) menu, returning its index"
   int slot = -1;
-  XEN_ASSERT_TYPE(XEN_STRING_P(label), label, XEN_ARG_1, S_add_to_main_menu, "a string");
+  Xen_check_type(Xen_is_string(label), label, 1, S_add_to_main_menu, "a string");
   slot = make_callback_slot();
-  if (XEN_BOUND_P(callback))
+  if (Xen_is_bound(callback))
     {
       char *err;
       err = procedure_ok(callback, 0, S_add_to_main_menu, "menu callback", 2);
@@ -335,119 +332,114 @@ static XEN gl_add_to_main_menu(XEN label, XEN callback)
 	add_callback(slot, callback);
       else 
 	{
-	  XEN errm;
-	  errm = C_TO_XEN_STRING(err);
+	  Xen errm;
+	  errm = C_string_to_Xen_string(err);
 	  free(err);
 	  return(snd_bad_arity_error(S_add_to_main_menu, errm, callback));
 	}
     }
-  else menu_functions[slot] = XEN_UNDEFINED;
-  return(C_TO_XEN_INT(g_add_to_main_menu((char *)XEN_TO_C_STRING(label), slot)));
+  else menu_functions[slot] = Xen_undefined;
+  return(C_int_to_Xen_integer(g_add_to_main_menu((char *)Xen_string_to_C_string(label), slot)));
 }
 
 
-static XEN gl_add_to_menu(XEN menu, XEN label, XEN callback, XEN gpos)
+static Xen gl_add_to_menu(Xen menu, Xen label, Xen callback, Xen gpos)
 {
   #define H_add_to_menu "(" S_add_to_menu " menu label func :optional position): adds label to menu (a main menu index), invokes \
 func (a function of no args) when the new menu is activated. Returns the new menu label widget."
 
+#if (!USE_NO_GUI)
   widget_t result;
   char *errmsg = NULL;
 
-  XEN_ASSERT_TYPE(XEN_STRING_P(label) || XEN_FALSE_P(label), label, XEN_ARG_2, S_add_to_menu, "a string");
-  XEN_ASSERT_TYPE(XEN_INTEGER_P(menu), menu, XEN_ARG_1, S_add_to_menu, "an integer");
-  XEN_ASSERT_TYPE(XEN_PROCEDURE_P(callback) || XEN_FALSE_P(callback), callback, XEN_ARG_3, S_add_to_menu, "a procedure");
-  XEN_ASSERT_TYPE(XEN_INTEGER_IF_BOUND_P(gpos), gpos, XEN_ARG_4, S_add_to_menu, "an integer");
+  Xen_check_type(Xen_is_string(label) || Xen_is_false(label), label, 2, S_add_to_menu, "a string");
+  Xen_check_type(Xen_is_integer(menu), menu, 1, S_add_to_menu, "an integer");
+  Xen_check_type(Xen_is_procedure(callback) || Xen_is_false(callback), callback, 3, S_add_to_menu, "a procedure");
+  Xen_check_type(Xen_is_integer_or_unbound(gpos), gpos, 4, S_add_to_menu, "an integer");
 
-  /* fprintf(stderr, "add-to-menu %s\n", XEN_AS_STRING(XEN_CAR(callback))); */
+  /* fprintf(stderr, "add-to-menu %s\n", Xen_object_to_C_string(Xen_car(callback))); */
 
-  if (XEN_PROCEDURE_P(callback))
+  if (Xen_is_procedure(callback))
     errmsg = procedure_ok(callback, 0, S_add_to_menu, "menu callback", 3);
   if (errmsg == NULL)
     {
       int slot = -1, m, position = -1;
 
-      m = XEN_TO_C_INT(menu);
+      m = Xen_integer_to_C_int(menu);
       if (m < 0)
 	return(snd_no_such_menu_error(S_add_to_menu, menu));
 
-      if (XEN_PROCEDURE_P(callback)) slot = make_callback_slot();
-      if (XEN_INTEGER_P(gpos)) position = XEN_TO_C_INT(gpos);
+      if (Xen_is_procedure(callback)) slot = make_callback_slot();
+      if (Xen_is_integer(gpos)) position = Xen_integer_to_C_int(gpos);
 
       result = g_add_to_menu(m,
-			     (XEN_FALSE_P(label)) ? NULL : XEN_TO_C_STRING(label),
+			     (Xen_is_false(label)) ? NULL : Xen_string_to_C_string(label),
 			     slot,
 			     position);
-#if (!USE_NO_GUI)
       if (result == NULL)
 	return(snd_no_such_menu_error(S_add_to_menu, menu));
-#endif
-      if (XEN_PROCEDURE_P(callback)) add_callback(slot, callback);
+      if (Xen_is_procedure(callback)) add_callback(slot, callback);
     }
   else 
     {
-      XEN errm;
-      errm = C_TO_XEN_STRING(errmsg);
+      Xen errm;
+      errm = C_string_to_Xen_string(errmsg);
       free(errmsg);
       return(snd_bad_arity_error(S_add_to_menu, errm, callback));
     }
-  return(XEN_WRAP_WIDGET(result));
+  return(Xen_wrap_widget(result));
+#else
+  return(Xen_false);
+#endif
 }
 
 
-void g_snd_callback(int callb)
+void g_menu_callback(int callb)
 {
-  if ((callb >= 0) && (XEN_BOUND_P(menu_functions[callb])))
-    XEN_CALL_0(menu_functions[callb], "menu callback func");
+  if ((callb >= 0) && (Xen_is_bound(menu_functions[callb])))
+    Xen_call_with_no_args(menu_functions[callb], "menu callback func");
 }
 
 
-static XEN gl_remove_from_menu(XEN menu, XEN label)
+static Xen gl_remove_from_menu(Xen menu, Xen label)
 {
   #define H_remove_from_menu "(" S_remove_from_menu " menu label): removes menu item label from menu"
   int m;
 
-  XEN_ASSERT_TYPE(XEN_STRING_P(label), label, XEN_ARG_2, S_remove_from_menu, "a string");
-  XEN_ASSERT_TYPE(XEN_INTEGER_P(menu), menu, XEN_ARG_1, S_remove_from_menu, "an integer");
+  Xen_check_type(Xen_is_string(label), label, 2, S_remove_from_menu, "a string");
+  Xen_check_type(Xen_is_integer(menu), menu, 1, S_remove_from_menu, "an integer");
 
-  m = XEN_TO_C_INT(menu);
+  m = Xen_integer_to_C_int(menu);
   if (m < 0) 
     return(snd_no_such_menu_error(S_remove_from_menu, menu));
-  return(C_TO_XEN_INT(g_remove_from_menu(m, XEN_TO_C_STRING(label))));
+  return(C_int_to_Xen_integer(g_remove_from_menu(m, Xen_string_to_C_string(label))));
 }
 
 
-static XEN g_main_menu(XEN which)
+static Xen g_main_menu(Xen which)
 {
   #define H_main_menu "(" S_main_menu " menu): the top-level menu widget referred to by menu"
   int which_menu;
 
-  XEN_ASSERT_TYPE(XEN_INTEGER_P(which), which, XEN_ONLY_ARG, S_main_menu, "an integer");
-  which_menu = XEN_TO_C_INT(which);
+  Xen_check_type(Xen_is_integer(which), which, 1, S_main_menu, "an integer");
+  which_menu = Xen_integer_to_C_int(which);
   if ((which_menu < 0) || (which_menu >= MAX_MAIN_MENUS))
-    XEN_ERROR(XEN_ERROR_TYPE("no-such-menu"),
-	      XEN_LIST_2(C_TO_XEN_STRING(S_main_menu ": no such menu, ~A"),
+    Xen_error(Xen_make_error_type("no-such-menu"),
+	      Xen_list_2(C_string_to_Xen_string(S_main_menu ": no such menu, ~A"),
 			 which));
-  return(XEN_WRAP_WIDGET(menu_widget(which_menu)));
+  return(Xen_wrap_widget(menu_widget(which_menu)));
 }
 
 
-#ifdef XEN_ARGIFY_1
-XEN_ARGIFY_2(gl_add_to_main_menu_w, gl_add_to_main_menu)
-XEN_ARGIFY_4(gl_add_to_menu_w, gl_add_to_menu)
-XEN_NARGIFY_2(gl_remove_from_menu_w, gl_remove_from_menu)
-XEN_NARGIFY_1(g_main_menu_w, g_main_menu)
-#else
-#define gl_add_to_main_menu_w gl_add_to_main_menu
-#define gl_add_to_menu_w gl_add_to_menu
-#define gl_remove_from_menu_w gl_remove_from_menu
-#define g_main_menu_w g_main_menu
-#endif
+Xen_wrap_2_optional_args(gl_add_to_main_menu_w, gl_add_to_main_menu)
+Xen_wrap_4_optional_args(gl_add_to_menu_w, gl_add_to_menu)
+Xen_wrap_2_args(gl_remove_from_menu_w, gl_remove_from_menu)
+Xen_wrap_1_arg(g_main_menu_w, g_main_menu)
 
 void g_init_menu(void)
 {
-  XEN_DEFINE_PROCEDURE(S_add_to_main_menu,  gl_add_to_main_menu_w,  1, 1, 0, H_add_to_main_menu);
-  XEN_DEFINE_PROCEDURE(S_add_to_menu,       gl_add_to_menu_w,       3, 1, 0, H_add_to_menu);
-  XEN_DEFINE_PROCEDURE(S_remove_from_menu,  gl_remove_from_menu_w,  2, 0, 0, H_remove_from_menu);
-  XEN_DEFINE_PROCEDURE(S_main_menu,         g_main_menu_w,          1, 0, 0, H_main_menu);
+  Xen_define_procedure(S_add_to_main_menu,  gl_add_to_main_menu_w,  1, 1, 0, H_add_to_main_menu);
+  Xen_define_procedure(S_add_to_menu,       gl_add_to_menu_w,       3, 1, 0, H_add_to_menu);
+  Xen_define_procedure(S_remove_from_menu,  gl_remove_from_menu_w,  2, 0, 0, H_remove_from_menu);
+  Xen_define_procedure(S_main_menu,         g_main_menu_w,          1, 0, 0, H_main_menu);
 }