xmenus.c

speech signal process tools

		if(mo->proc && mo->name && *mo->name) {

		  item = find_menu_item(allops, mo->name);
	  
		  if (item != MENU_ITEM_NULL) 
		    xv_set(item,
			   MENU_VALUE,	    mo,
			   0);
		  else
		    xv_set(allops,
			   MENU_STRING_ITEM, mo->name, mo,
			   0);
		}
	      }
	    }
	    mol = mol->next;
	  }
	  if(debug_level)
	    fprintf(stderr,"DISPLAY %s\n",xv_get(mi, MENU_STRING));
	  return(allops);
	} else {
	  sprintf(notice_msg, "Problems in make_op_list %d.", allops);
	  show_notice(0, notice_msg);
	}
      }
      break;
    case MENU_DISPLAY_DONE:
      if(debug_level)
	fprintf(stderr,"DISPLAY_DONE %s\n",xv_get(mi, MENU_STRING));
      break;
    case MENU_NOTIFY:
      if(debug_level)
	fprintf(stderr,"NOTIFY: %s\n",xv_get(mi, MENU_STRING));
      break;
    case MENU_NOTIFY_DONE:
      if(debug_level)
	fprintf(stderr,"NOTIFY_DONE %s\n",xv_get(mi, MENU_STRING));
      break;
    }
    return(allops);
  } else
    show_notice(1, "Bad client data in make_op_list().");
  return(0);
}

/*********************************************************************/
Menuop *search_all_menus_but(excluded, item_name)
     char *excluded, *item_name;
{
  Menuop  *find_operator(), *found = NULL, *get_null_op();
  Moplist  *menu_get_op_lists(), *mol = menu_get_op_lists();

  if(item_name && *item_name && excluded && *excluded) {
    while(mol) {
      if(strcmp(mol->name,excluded) &&
	 (found = find_operator(mol->reserve_ops,item_name)))
	return(found);
      mol = mol->next;
    }

    sprintf(notice_msg,
	    "Can't find operator (%s) in search_all_menus_but(%s).",
	    item_name, excluded);
    show_notice(1, notice_msg);
  }

  return(get_null_op());

}

/*********************************************************************/
Menuop *find_op_list(name)
     char *name;
{
  if(name && *name) {
    Moplist *mol = menu_get_op_lists();

    while(mol) {
      if(!strcmp(mol->name, name))
	return(mol->first_op);
      mol = mol->next;
    }
  }
  return(NULL);
}

/*********************************************************************/
Menuop *find_op_in_list(opname, listname)
     char *opname, *listname;
{
  if(opname && *opname) {
    Menuop *mo = find_op_list(listname);
    
    while(mo) {
      if(!strcmp(mo->name, opname))
	return(mo);
      mo = mo->next;
    }
  }
  return(NULL);
}
    
/*********************************************************************/
Menu make_window_menu(menuname, but_menu, mid_ops, left_ops)
    char		*menuname;
    Menuop		*but_menu, *mid_ops, *left_ops;
{
  Menu	menu,
  mb = MENU_NULL;
  struct named_menu	*menus;
  char		*name;
  Menuop		*mo;
  int			n;
  Button_items *bl, *br;

  bl = (Button_items*)malloc(sizeof(Button_items));
  br = (Button_items*)malloc(sizeof(Button_items));
  bl->name = savestring(menuname);
  bl->ops = (Menu)NULL;
  br->name = savestring(menuname);
  br->ops = (Menu)NULL;

  menu = make_generic_menu(but_menu, do_menu);

  mb = xv_create(XV_NULL, MENU,
		 MENU_ITEM,
		 MENU_GEN_PULLRIGHT_ITEM,    "middle",   make_op_list,
		 MENU_CLIENT_DATA, br,
		 0,
		 MENU_ITEM,
		 MENU_GEN_PULLRIGHT_ITEM,    "left",	make_op_list,
		 MENU_CLIENT_DATA, bl,
		 0,
		 0);
  name = "Button Modes";
  wave_submenu = mb;

  for (n = 0; menl[n].name && strcmp(menl[n].name, menuname); )
    n++;
  if (menl[n].name && (menus = menl[n].submenus)) {
    menus[0].name = name;
    *menus[0].menu = wave_submenu;
  }
    
  if (wave_submenu != MENU_NULL)
    xv_set(menu,
	   MENU_PULLRIGHT_ITEM,	name, wave_submenu,
	   MENU_PULLRIGHT_DELTA,	30,
	   0);

  return menu;
}

/***********************************************************************/
Menu 
make_wave_menu()
{
    return make_window_menu("wave", &right_but_menu,
			    aux_but_ops, aux_but_ops);
}

/***********************************************************************/
void menu_change(strold, strnew, val, menuname)
     char	*strold, *strnew;
     Xv_opaque	val;
     char	*menuname;
{
  int		n;
  Menu	menu;
  Menu_item   item;

  if(menuname) {
    if(!*menuname || !strcmp(menuname, "all"))
      menuname = NULL;
    else
      if(*menuname && !strcmp(menuname, "none"))
	return;
  }

  for(n = 0; menl[n].name && menl[n].menu; n++)
    if((!menuname || !strcmp(menuname, menl[n].name))
       && (menu = *menl[n].menu) != MENU_NULL) {
      if(strold && *strold) {

	item = find_menu_item(menu, strold);

	if(strnew && *strnew) {
	  if (item != MENU_ITEM_NULL) 
	    xv_set(item,
		   MENU_STRING,	    savestring(strnew),
		   MENU_NOTIFY_PROC,   do_menu,
		   MENU_VALUE,	    val,
		   0);
	  else
	    xv_set(menu,
		   MENU_ITEM,
		   MENU_STRING,	savestring(strnew),
		   MENU_NOTIFY_PROC,	do_menu,
		   MENU_VALUE,		val,
		   0,
		   0);
	} else {
	  if(item != MENU_ITEM_NULL) {
	    xv_set(menu,
		   MENU_REMOVE_ITEM,   item,
		   0);
	    dt_xv_destroy(6,item);
	  }
	}
      }
      else
	if(strnew && *strnew)
	  xv_set(menu,
		 MENU_ITEM,
		 MENU_STRING,	savestring(strnew),
		 MENU_NOTIFY_PROC,	do_menu,
		 MENU_VALUE,		val,
		 0,
		 0);
    }
}

/*********************************************************************/
void
menu_clear(menuname)
    char	*menuname;
{
  int		i, n;
  Menu	menu;
  Menu_item	item;

  if(menuname && (!*menuname || !strcmp(menuname, "all")))
    menuname = NULL;

  for(n = 0; menl[n].name && menl[n].menu; n++)
    if((!menuname || !strcmp(menuname, menl[n].name))
       && (menu = *menl[n].menu) != MENU_NULL) {
      for(i = (int) xv_get(menu, MENU_NITEMS); i >= 1; i--) {
	item = (Menu_item) xv_get(menu, MENU_NTH_ITEM, i);
	xv_set(menu,
	       MENU_REMOVE_ITEM,   item,
	       0);
	if(item != MENU_ITEM_NULL)
	  dt_xv_destroy(7,item);
      }
    }
}

/*********************************************************************/
char *meth_save_menus(ob, str)
     Object *ob;
     char *str;
{
  static char menuname[50], output[NAMELEN];
  static Selector s2 = {"menu", "%s", menuname, NULL},
                  s1 = {"output", "%s", output, &s2};
  int		i, n, didone = 0, ni;
  Menu	menu;
  Menu_item	item;
  FILE *of;
  extern char ok[], null[];

  CHECK_QUERY(str, &s1)

  strcpy(menuname,"all");
  *output = 0;
  get_args(str, &s1);
  if(*output) {
    char scrat[NAMELEN];
    Menuop *mo;

    (void) build_filename(scrat, "", output); 

    if((of = fopen(scrat, "w"))) {
      for(n = 0; menl[n].name && menl[n].menu; n++)
	if((!strcmp(menuname, "all") || !strcmp(menuname, menl[n].name))
	   && (menu = *menl[n].menu) != MENU_NULL) {
	  for(ni = (int) xv_get(menu, MENU_NITEMS), i = 1; i <= ni; i++) {
	    item = (Menu_item) xv_get(menu, MENU_NTH_ITEM, i);
	    if(item && (mo = (Menuop*)xv_get(item, MENU_VALUE))) {
	      char *mn = (char*)xv_get(item, MENU_STRING);
	      if(mn) {
		if(!didone)
		  fprintf(of,"delete_all_items menu %s\n", menuname);
		didone = TRUE;
		if(strcmp(mn,"Button Modes"))
		  fprintf(of,"add_waves menu %s name \"%s\" op %s\n",
			  menl[n].name,mn,mo->name);
		else
		  fprintf(of, "add_waves menu %s submenu t\n",menl[n].name);
	      }
	    }
	  }
	}
      if(didone)
	fprintf(of,"return\n");
      fclose(of);
      return(ok);
    } else {
      sprintf(notice_msg, "Can't open %s for output in meth_save_menus().",
	      output);
      show_notice(1, notice_msg);
    }
  } else
    show_notice(1, "Output file must be specified in meth_save_menus().");
  return(null);
}

/*********************************************************************/
int
add_button_submenu(name, menuname)
    char	*name, *menuname;
{
  int		n;
  struct named_menu
    *menus;
  Menu	menu, submenu;
  Menu_item	item;

  if (menuname && (!*menuname || !strcmp(menuname, "all")))
    menuname = NULL;

  for (n = 0; menl[n].name && menl[n].menu; n++)
    if ((!menuname || !strcmp(menuname, menl[n].name))
	&& (menu = *menl[n].menu) != MENU_NULL
	&& (menus = menl[n].submenus)
	&& (menus[0].menu)
	&& (submenu = *menus[0].menu) != MENU_NULL) {

      if (!(name && *name))
	name = menus[0].name;

      if (name && *name) {
	if ((item = find_menu_item(menu, name)) != MENU_ITEM_NULL) {
	  xv_set(item,
		 MENU_NOTIFY_PROC,	(Xv_opaque (*)())  NULL,
		 MENU_PULLRIGHT,		submenu,
		 MENU_PULLRIGHT_DELTA,	30,
		 0);
	} else {
	  if (name != menus[0].name)
	    name = savestring(name);

	  xv_set(menu,
		 MENU_PULLRIGHT_ITEM,	name, submenu,		
		 MENU_PULLRIGHT_DELTA,	30,
		 0);
	}
      }
    }
}

/*********************************************************************/
menu_get_n(me, mo)
     Menu me;
     Menuop *mo;
{
  if(me && mo) {
    int i;
    Menu_item item;
    for(i = (int) xv_get(me, MENU_NITEMS); i >= 1; i--) {
	item = (Menu_item) xv_get(me, MENU_NTH_ITEM, i);
	if(mo == (Menuop*)xv_get(item, MENU_VALUE))
	  return(i);
      }
  }
  return(-1);

}

/*********************************************************************/
void menu_operate(canvas, event, arg)
     Canvas canvas;
     Event *event;
     caddr_t arg;
{
  int menu_def;
  Menuop *mo;
  Menu me = (Menu) xv_get(canvas, WIN_MENU);
  
  mo = (Menuop*) xv_get(canvas, XV_KEY_DATA, menu_item_key);
  if ((menu_def = menu_get_n(me, mo)) < 0)
    menu_def = 1;	/* last selected item no longer exists */
  xv_set(me,
	 MENU_DEFAULT, menu_def,
	 0);

  menu_show(me, canvas, event, NULL);
}

/*********************************************************************/
void 
e_play_window(canvas, event, arg)
     Canvas canvas;
     Event *event;
     caddr_t arg;
{
  View *v;
  
  SINGLE_HIT {
    v = (View *)xv_get(canvas, WIN_CLIENT_DATA);
    play_file(get_playable_signal(v), v->start_time, ET(v));
  }
}

/*********************************************************************/
void 
e_play_between_marks(canvas, event, arg)
     Canvas canvas;
     Event *event;
     caddr_t arg;
{
  View *v;
  
  SINGLE_HIT {
    v = (View *)xv_get(canvas, WIN_CLIENT_DATA);
    play_file(get_playable_signal(v), v->lmarker_time, v->rmarker_time);
  }  
}

/*********************************************************************/
void 
e_play_file(canvas, event, arg)
     Canvas canvas;
     Event *event;
     caddr_t arg;
{
  SINGLE_HIT {
    View *v;
    Signal *s;
    
    v = (View *)xv_get(canvas, WIN_CLIENT_DATA);
    if((s = get_playable_signal(v)))
      play_file(s, s->start_time, s->end_time); /* should use SIG_END_TIME() */
  }
}

/*********************************************************************/
void 
e_play_from_cursor(canvas, event, arg)
     Canvas canvas;
     Event *event;
     caddr_t arg;
{
  View *v;
  
  v = (View *)xv_get(canvas, WIN_CLIENT_DATA);
  SINGLE_HIT
    play_file(get_playable_signal(v), v->cursor_time, v->sig->end_time); /* should use SIG_END_TIME() */
}

/*********************************************************************/
void 
e_page_ahead(canvas, event, arg)
     Canvas canvas;
     Event *event;
     caddr_t arg;
{
  SINGLE_HIT {
    View *v = (View *)xv_get(canvas, WIN_CLIENT_DATA);
    Signal *s = v->sig;
    
    if(s && v)
      page(v, s, v->start_time + v->page_step);
  }
  return;
}

/*********************************************************************/
void 
e_page_back(canvas, event, arg)
     Canvas canvas;
     Event *event;
     caddr_t arg;
{
  SINGLE_HIT {
    View *v = (View *)xv_get(canvas, WIN_CLIENT_DATA);
    Signal *s = v->sig;
    
    if(s && v)
      page(v, s, v->start_time - v->page_step);
  }
  return;
}

/*********************************************************************/
void 
e_output_bitmap(canvas, event, arg)
     Canvas canvas;
     Event *event;
     caddr_t arg;
{
  return;
}

/*********************************************************************/
void
e_forward_window(canvas, event, arg) 
     Canvas canvas;
     Event *event;
     caddr_t arg;
{
  SINGLE_HIT {
    double end_time;

    View *v = (View *)xv_get(canvas, WIN_CLIENT_DATA);
    Signal *s = v->sig;
    
    /* note ET sensitive to PIX_PER_CM (see Objects.h) */
    
    if(s && v)
      page(v, s, ET(v));
  }

}


/*********************************************************************/
void
e_backward_window(canvas, event, arg) 
     Canvas canvas;
     Event *event;
     caddr_t arg;
{
  SINGLE_HIT {
    View *v = (View *)xv_get(canvas, WIN_CLIENT_DATA);
    Signal *s = v->sig;
    double width;
    
    /* note ET sensitive to PIX_PER_CM (see Objects.h) */
    
    width = ET(v) - v->start_time;
    
    if(s && v)