xmethods.c

speech signal process tools

  Object *o;
  
  while(o = program.next)    kill_object(o);
  
  return(TRUE);
}

/**********************************************************************/
char *
  meth_make_panel(ob, args)
Object	*ob;
char	*args;
{
  extern int	def_panel_loc_x, def_panel_loc_y;
  static int	loc_x, loc_y, cols, quit, panel_choice, choice_horiz;
  static char	input_file[200], panel_name[50],
  panel_title[100], icon_title[50];
  static Selector
    a7 = {"quit_button", "%d", (char *) &quit,    NULL},
    a6 = {"columns",     "%d", (char *) &cols,    &a7},
    a5 = {"loc_y",      "%d", (char *) &loc_y,   &a6},
    a4 = {"loc_x",      "%d", (char *) &loc_x,   &a5},
    a3 = {"icon_title",  "#qstr", icon_title,    &a4},
    a2 = {"title",      "#qstr", panel_title,    &a3},
    a1b = {"choice_horiz",      "%d", (char*)&choice_horiz,    &a2},
    a1a = {"panel_choice",      "%d", (char*)&panel_choice,    &a1b},
    a1 = {"name",      "%s", panel_name,    &a1a},
    a0 = {"file",      "%s", input_file,    &a1};
  
  input_file[0] = '\0';
  panel_name[0] = '\0';
  panel_title[0] = '\0';
  icon_title[0] = '\0';
  loc_x = def_panel_loc_x;
  loc_y = def_panel_loc_y;
  panel_choice = 0;
  choice_horiz = 0;
  cols = 10;
  quit = 0;
  CHECK_QUERY(args, &a0)
    if (get_args(args, &a0)) {
      if (FIND_WAVES_MENU(input_file, input_file))
	if(make_auxpanel(input_file, panel_name, quit, cols,
			 panel_title, icon_title, loc_x, loc_y, panel_choice,
			 choice_horiz)) 
	  return ok;
    }
  return null;
}

/**********************************************************************/
do_something(cmd)
     char *cmd;
{
  if(cmd && *cmd) {
    strip_trailing_spaces(cmd);
    
    if(!strcmp(dispatch(receiver_prefixed(cmd)), ok))
      return(TRUE);
  }
  return(FALSE);
}

/**********************************************************************/
char *meth_make_add_op_panel(ob, args)
Object	*ob;
char	*args;
{
  extern int	def_panel_loc_x, def_panel_loc_y;
  static int	loc_x, loc_y, ops_win, vars_win;
  static char   panel_name[50],
  help_file[NAMELEN];
  static Selector
    a7 = {"show_ops", "%d", (char *) &ops_win,    NULL},
    a6 = {"show_vars",     "%d", (char *) &vars_win,    &a7},
    a5 = {"loc_y",      "%d", (char *) &loc_y,   &a6},
    a4 = {"loc_x",      "%d", (char *) &loc_x,   &a5},
    a3 = {"help_file",  "#qstr", help_file,    &a4};
  
  help_file[0] = '\0';
  loc_x = def_panel_loc_x;
  loc_y = def_panel_loc_y;
  ops_win = vars_win = 0;

  CHECK_QUERY(args, &a3)
    get_args(args, &a3);
  if(make_add_op_panel(help_file, loc_x, loc_y, ops_win, vars_win, do_something))
	return ok;
  return null;
}

/**********************************************************************/
char *
  meth_close_panel(ob, args)
Object	*ob;
char	*args;
{
  static char	panel_name[50];
  static int inv;
  static Selector
    a0 = {"name",   "%s",   panel_name,     NULL},
    a1 = {"invisible", "%d", (char*)&inv, &a0};

  inv = 0;
  panel_name[0] = '\0';
  CHECK_QUERY(args, &a1)
  if (get_args(args, &a1) && close_auxpanel(panel_name, inv))
    return ok;
  else return null;
}

/**********************************************************************/
char *
  meth_open_panel(ob, args)
Object	*ob;
char	*args;
{
  static char	panel_name[50];
  static Selector
    a0 = {"name",   "%s",   panel_name,	NULL};
  
  panel_name[0] = '\0';
  CHECK_QUERY(args, &a0)
  if (get_args(args, &a0) && open_auxpanel(panel_name))
    return ok;
  else return null;
}

/**********************************************************************/
char *
  meth_kill_panel(ob, args)
Object	*ob;
char	*args;
{
  static char	panel_name[50];
  static Selector
    a0 = {"name",   "%s",   panel_name,	NULL};
  
  panel_name[0] = '\0';
  CHECK_QUERY(args, &a0)
  if (get_args(args, &a0) && kill_auxpanel(panel_name))
    return ok;
  else return null;
}

/***********************************************************************/
char *meth_add_waves(ob, args)
     Object	    *ob;
     char	    *args;
{
  extern void	    e_exec_waves();
  extern Menuop   *wave_get_ops();
  
  static char	    name[50];
  static char	    command[100];
  static char	    menu[50];
  static char	    builtin[50];
  static char	    submenu[50];
  static Selector
    a4 = {"submenu", "#qstr", submenu, NULL},
    a3 = {"builtin", "#strq", builtin, &a4},
    a2 = {"menu",	 "%s",	  menu,	   &a3},
    a1b = {"command", "#strq",  command, &a2},
    a1 = {"op", "#strq",  builtin, &a1b},
    a0 = {"name",	 "#qstr", name,	   &a1};
  
  *name = '\0';
  *command = '\0';
  strcpy(menu,"all");
  *builtin = '\0';
  *submenu = '\0';

  CHECK_QUERY(args, &a0)
  (void) get_args(args, &a0);
  
  if(debug_level) {
    fprintf(stderr,
	    "%s: name \"%s\" menu \"%s\" builtin \"%s\" submenu \"%s\"\n",
	    "meth_add_waves", name, menu, builtin, submenu);
    fprintf(stderr, "\tcommand \"%s\"\n", command);
  }
  
  if(!!*command + !!*builtin + !!*submenu > 1) {
    sprintf(notice_msg, 
	    "%s: can specify only one of command, builtin, and submenu.",
	    "meth_add_waves");
    show_notice(1, notice_msg);
    return null;
  }
  
  if(*command) {

    menu_change(name, name,
		new_menuop(menu, name, e_exec_waves, savestring(command)),
		menu);
    return ok;
  }
  
  if(*builtin) {
    Menuop	*m, *find_op_in_list();
    char    *namep = (*name) ? name : builtin;

    if((!strcmp(menu,"all") || !strcmp(menu,"wave")) &&
       ((m = find_op_in_list(builtin, "wave")) ||
	(m = find_op_in_list(builtin, "all"))) && m->proc)
      menu_change(namep, namep, m, "wave");

    if((!strcmp(menu,"all") || !strcmp(menu,"spect")) &&
       ((m = find_op_in_list(builtin, "spect")) ||
	(m = find_op_in_list(builtin, "all"))) && m->proc)
      menu_change(namep, namep, m, "spect");
    
      return ok;
  }
  
  if(*submenu) {
    if(add_button_submenu(name, menu))
      return ok;
  }
  
  return null;
}

/**********************************************************************/
char *meth_open_ctlwin(ob, str)
     Object *ob;
     char *str;
{
  CHECK_QUERY(str,NULL)

    if (daddy) {
    xv_set(daddy, FRAME_CLOSED, FALSE, 0);  
    xv_set(daddy, XV_SHOW, TRUE, 0); 
   return ok;
  }
  else return null;
}

/**********************************************************************/
char *meth_close_ctlwin(ob, str)
     Object *ob;
     char *str;
{
  static int invisible = 0;
  static Selector  a2 = {"invisible", "%d", (char*)&invisible, NULL};
  Frame fr;
  
  invisible = 0;
  CHECK_QUERY(str, &a2)
    get_args(str, &a2);

  if (daddy) {
    xv_set(daddy, FRAME_CLOSED, TRUE, 0); 
    if(invisible)
      xv_set(daddy, XV_SHOW, FALSE, 0); 
    return ok;
  }
  else return null;
}


/**********************************************************************/
char *meth_make_object(ob,args)
     Object *ob;
     char *args;
{
  extern double ref_size, ref_start;
  extern int def_w_width, def_w_height, next_x, next_y;
  extern char objectname[], inputname[], active_ids[], active_numbers[];
  Object *o;
  Signal *s;
  View *v;
  int oline;
  static Selector
    a11 = {"identifiers", "#strq", active_ids, &g1}, /* note linkage to globals!*/
    a10 = {"numbers", "#strq", active_numbers, &a11},
    a9 = {"duration", "%lf", (char *) &ref_size, &a10},
    a8 = {"start", "%lf", (char *) &ref_start, &a9},
    a7 = {"width", "%d", (char *) &new_width, &a8},
    a6 = {"height", "%d", (char *) &new_height, &a7},
    a5 = {"loc_y", "%d", (char *) &next_y, &a6},
    a4 = {"loc_x", "%d", (char *) &next_x, &a5},
    a1 = {"name", "%s", objectname, &a4},
    a0 = {"file", "%s", inputname, &a1};
  
  oline = line_type;
  *active_ids = *active_numbers = 0;
  new_width = new_height = 0;
  CHECK_QUERY(args,&a0)
    if (get_args(args,&a0)) {
      post_set_process();
      if (*inputname) {
	(void)apply_waves_input_path(inputname,inputname);
	panel_set_value(newFile_item,inputname);
	create_new_signal_view(inputname);
	new_width = new_height = 0;
	if ((o = find_object(objectname))
	    && (s = find_signal(o,inputname))
	    && (v = s->views))
	  set_active_channels(v);
      }
      *active_ids = *active_numbers = 0;
      line_type = oline;
      return(ok);
    }
  line_type = oline;
  new_width = new_height = 0;
  *active_ids = *active_numbers = 0;
  return(null);
}

/***********************************************************************/
insert_mark(o, mark)
     Object *o;
     register Marks *mark;
{
  register Marks *ma;
  
  if(! (ma = o->marks)) {
    o->marks = mark;
    return TRUE;
  }
  if(ma->time >= mark->time) {
    if((ma->time == mark->time) && (ma->color == mark->color))
      return(FALSE);
    o->marks = mark;
    mark->next = ma;
    return(TRUE);
  }
  while( ma->next && (ma->next->time < mark->time)) ma = ma->next;
  while( ma->next && ma->next->time == mark->time) {
    if(ma->next->color == mark->color) return(FALSE);
    ma = ma->next;
  }
  mark->next = ma->next;
  ma->next = mark;
  return(TRUE);
}

/***********************************************************************/
object_enter_mark(o,time,color)
     Object *o;
     double time;
     int color;
{
  Marks *mark, *new_mark();
  
  if(! (mark = new_mark(time, color))) {
    fprintf(stderr,"Can't allocate another mark structure!\n");
    return(FALSE);
  }
  
  if(! insert_mark(o, mark)) {
    free((char *)mark);
    return;
  }
  object_xor_mark(o, time, color);
}

/***********************************************************************/
Marks *
  new_mark(time, color)
double time;
int color;
{
  Marks *m;
  
  if( ! (m = (Marks *)malloc(sizeof(Marks)))) return(NULL);
  
  m->next = NULL;
  m->time = time;
  m->color = color;
  return(m);
}


/***********************************************************************/
kill_all_marks(o)
     Object *o;
{
  Marks *m, *m2;
  
  if(o && (m = o->marks)) {
    while(m2 = m) {
      object_xor_mark(o,m->time, m->color);
      m = m->next;
      free((char *)m2);
    }
    o->marks = NULL;
  }
}

/***********************************************************************/
object_kill_mark(o, time, color)
     Object *o;
     double time;
     int color;
{
  Marks *ma, *map = NULL;
  
  if((ma = o->marks)) {
    while(ma) {
      if((ma->time == time) && (ma->color == color)) {
	object_xor_mark(o, time, color);
	if(ma == o->marks)
	  o->marks = ma->next;
	else
	  map->next = ma->next;
	free((char *)ma);
	return(TRUE);
      }
      map = ma;
      ma = ma->next;
    }
  }
  return(FALSE);
}

/***********************************************************************/
char *meth_chdir(o,str)
     Object *o;
     char *str;
{
  static char path[NAMELEN];
  static Selector a0 = {"path", "%s", path, NULL};

  *path = 0;
  CHECK_QUERY(str,&a0)
  get_args(str,&a0);
  if(*path) {
    char scrat[NAMELEN];
    (void)build_filename(scrat,"", path);
    if( !chdir(scrat))
      return(ok);
  }
  return(null);
}

/***********************************************************************/
char *meth_setenv(o,str)
     Object *o;
     char *str;
{
  static char *val, var[MAXPATHLEN];
  static int specsiz = 0;
  static Selector a0 = {"variable", "%s", var, NULL},
                  a1 = {"value", "#strq", NULL, &a0};
  int nc;

  if(str && strlen(str)) {
    if((nc = strlen(str)) > (specsiz)) {
      if(val)
	free(val);
      if(!(val = malloc(nc+1))) {
	show_notice(1, "Allocation problems in meth_putenv().");
	specsiz = 0;
	return(null);
      }
      specsiz = nc;
      a1.dest = val;
    }
    *val = *var = 0;
    CHECK_QUERY(str,&a1)
      get_args(str,&a1);
    if(*var) {
#if defined(SONY_RISC) || defined(CONVEX)
      setenv(var,val,1);
#else
      char *tch = malloc(strlen(val)+strlen(var)+3); /* NOTE that this is a memory leak! */
      sprintf(tch,"%s=%s",var,val);
      putenv(tch);
#endif
      return(ok);
    }
  }
  return(null);
}

/***********************************************************************/
char *meth_get(o,str)
Object *o;
char *str;
{
  static char attr[20], file[MAXPATHLEN], foutput[MAXPATHLEN], func[MAXPATHLEN],
  aname[MES_BUF_SIZE];
  static int id = 0;
  static Selector
    a2 = {"output", "%s", foutput, NULL},
    a1b = {"aname", "#strq", aname, &a2},
    a1 = {"attributes", "%s", attr, &a1b},
    a0b = {"function", "%s", func, &a1},
    a0 = {"file", "%s", file, &a0b},
    am1 = {"return_id", "%d", (char*)&id, &a0};
  static char reply[200];
  static char *oblock = NULL;
  static int oblocksize = 0;
  char scrat[MAXPATHLEN];
  double start, seccm;
  Frame frm;
  Rect  rec;
  FILE *fp = stdout, *fopen();
  Signal *s;
  View *v;
  
  id = 0;
  *aname = *foutput = *file = *func = 0;
  strcpy(attr,"view");
  CHECK_QUERY(str, &am1)
    if(get_args(str,&am1)) {
    
    if(*foutput && (*foutput != '-')) {
      /* expand any environment variables */