xmenus.c

speech signal process tools

      page(v, s, (v->start_time) - width);
  }
}

/*********************************************************************/
void
e_zoom_full_out(canvas, event, arg)
     Canvas canvas;
     Event *event;
     caddr_t arg;
{
  SINGLE_HIT {
    View *v;
    static double time;
    
    v = (View *)xv_get(canvas, WIN_CLIENT_DATA);
    
    zoom_view(v,v->cursor_time, ref_size/(ET(v) - v->start_time));
  }
} 

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

/*********************************************************************/
void 
e_zoom_in(canvas, event, arg)
     Canvas canvas;
     Event *event;
     caddr_t arg;
{
  SINGLE_HIT {
    View *v;
    
    v = (View *)xv_get(canvas, WIN_CLIENT_DATA);
    
    zoom_view(v,v->cursor_time,v->zoom_ratio);
  }
}

/*********************************************************************/
void 
e_blow_up(canvas, event, arg)
     Canvas canvas;
     Event *event;
     caddr_t arg;
{
  View *v;
  extern int zoom_ganged;
  int holdit;

  v = (View *)xv_get(canvas, WIN_CLIENT_DATA);
  if(event_id(event) != LOC_DRAG) {
    holdit = zoom_ganged;
    zoom_ganged = 0;
    if(event_is_down(event))
      zoom_view(v,v->cursor_time,0.1);
    else
      zoom_view(v,v->cursor_time,10.0);
    zoom_ganged = holdit;
  } else
    transform_xy(v, event_x(event), event_y(event));
}

/*********************************************************************/
void 
e_blow_up_call_function(canvas, event, arg)
     Canvas canvas;
     Event *event;
     caddr_t arg;
{
  View *v;
  extern int zoom_ganged;
  int holdit;

  v = (View *)xv_get(canvas, WIN_CLIENT_DATA);
    
  if(event_id(event) != LOC_DRAG) {
    holdit = zoom_ganged;
    zoom_ganged = 0;
    if(event_is_down(event))
      zoom_view(v,v->cursor_time,0.1);
    else {
      zoom_view(v,v->cursor_time,10.0);
      if(blowup_op && blowup_op->proc) {
	event_set_down(event);
	blowup_op->proc(canvas, event, blowup_op->data);
      }
    }
    zoom_ganged = holdit;
  } else
    transform_xy(v, event_x(event), event_y(event));
}

/*********************************************************************/
void 
e_zoom_out(canvas, event, arg)
     Canvas canvas;
     Event *event;
     caddr_t arg;
{
  SINGLE_HIT {
    View *v;
    
    v = (View *)xv_get(canvas, WIN_CLIENT_DATA);
    
    zoom_view(v,v->cursor_time,1.0/v->zoom_ratio);
  }
}


/*********************************************************************/
void 
e_align_views(canvas, event, arg)
     Canvas canvas;
     Event *event;
     caddr_t arg;
{
  View *v;
  Object *obj;

  v = (View *)xv_get(canvas, WIN_CLIENT_DATA);
  if (!v || !v->sig || !(obj = (Object *)v->sig->obj))  return;
  
  SINGLE_HIT do_align_views(obj,v);
}

/*********************************************************************/
void 
e_save_segment(canvas, event, arg)
     Canvas canvas;
     Event *event;
     caddr_t arg;
{
  SINGLE_HIT {
    View *v, *v2;
    extern int edit_ganged;
    Signal *s, *s2;
    double start,duration;
    extern char outputname[];
    char next[200];
    int itsok = TRUE;

    v2 = v = (View *)xv_get(canvas, WIN_CLIENT_DATA);
    start = v->lmarker_time;
    duration = v->rmarker_time - v->lmarker_time;
    if(!save_segment(v->sig,start,duration)) itsok = FALSE;
    if(itsok) {
      get_output_file_names(outputname, next);
      update_filename_display(next);
    }

    if(edit_ganged) {
      s = v->sig;
      s2 = ((Object*)(s->obj))->signals;
      while(s2) {
	if((s2 != s) && (s2->views) && (s2->views->sig == s2)) {
	  if(!save_segment(s2,start,duration)) itsok = FALSE;
	  if(itsok) {
	    get_output_file_names(outputname, next);
	    update_filename_display(next);
	  }
	}
	s2 = s2->others;
      }
    }
  }
  return;
}



/*********************************************************************/
void 
e_insert_file(canvas, event, arg)
     Canvas canvas;
     Event *event;
     caddr_t arg;
{
  SINGLE_HIT {
    View *v;
    Signal *s, *s2;
    double start,end;
  
    v = (View *)xv_get(canvas, WIN_CLIENT_DATA);
    paste(v->sig,v->cursor_time);
  }
  return;
}

/*********************************************************************/
void
e_kill(canvas, event, arg)
    Canvas  canvas;
    Event   *event;
    caddr_t arg;
{
  SINGLE_HIT {
    Frame   frame;

    frame = (Frame) xv_get(canvas, XV_OWNER);
    xv_set(frame,
		FRAME_NO_CONFIRM, TRUE,
		0);
    dt_xv_destroy_safe(8,frame);
  }
}

/*********************************************************************/
void 
e_delete_segment(canvas, event, arg)
     Canvas canvas;
     Event *event;
     caddr_t arg;
{
  SINGLE_HIT  {
    View *v, *v2;
    extern int edit_ganged;
    Signal *s, *s2;
    double start,end;
  
    v2 = v = (View *)xv_get(canvas, WIN_CLIENT_DATA);
    start = v->lmarker_time;
    end = v->rmarker_time;
    do_deletions(v,start,end);
    if(edit_ganged) {
      s = v->sig;
      s2 = ((Object*)(s->obj))->signals;
      while(s2) {
	if((s2 != s) && (s2->views) && (s2->views->sig == s2))
	  do_deletions(s2->views,start,end);
	s2 = s2->others;
      }
    }
  }
  return;
}


/*********************************************************************/
void 
e_wb_spectrogram(canvas, event, arg)
     Canvas canvas;
     Event *event;
     caddr_t arg;
{
  View *v;

  v = (View *)xv_get(canvas, WIN_CLIENT_DATA);
  
  SINGLE_HIT spectrogram(v->sig,"wideband",v->lmarker_time,v->rmarker_time,NULL);
}

/*********************************************************************/
void 
c_print_graphic(canvas, event, arg)
     Canvas canvas;
     Event *event;
     caddr_t arg;
{
  SINGLE_HIT e_print_graphic(canvas, event, arg);
}

/*********************************************************************/
void 
e_print_ensemble(canvas, event, arg)
    Canvas  canvas;
    Event   *event;
    caddr_t arg;
{
  View *v;
  Object *obj;

  v = (View *) xv_get(canvas, WIN_CLIENT_DATA);
  if (!v || !v->sig || !(obj = (Object *) v->sig->obj)) return;
  
  SINGLE_HIT do_print_ensemble(obj);
}

/*********************************************************************/
void 
e_nb_spectrogram(canvas, event, arg)
     Canvas canvas;
     Event *event;
     caddr_t arg;
{
  View *v;

  v = (View *)xv_get(canvas, WIN_CLIENT_DATA);
  
  SINGLE_HIT spectrogram(v->sig,"narrowband",v->lmarker_time,v->rmarker_time,NULL);
}

/*********************************************************************/
void 
e_up_down_move_marks(canvas, event, arg)
     Canvas canvas;
     Event *event;
     caddr_t arg;
{
  View *v;

  v = (View *)xv_get(canvas, WIN_CLIENT_DATA);
  if(event_id(event) != LOC_DRAG) {
    if(!event_shift_is_down(event))
      move_markers(v, v->cursor_time, event_is_down(event));
    else
      move_ord_markers(v, event_x(event), event_y(event), event_is_down(event));
  } else
    transform_xy(v, event_x(event), event_y(event));

  if (write_common && event_is_up(event)) 
    markers_to_common(v);
}

/*********************************************************************/
void 
e_move_closest_mark(canvas, event, arg)
     Canvas canvas;
     Event *event;
     caddr_t arg;
{
  View *v = (View *)xv_get(canvas, WIN_CLIENT_DATA);

  if(event_is_down(event)) {
    if(event_shift_is_down(event)) {
      int do_top = 1, y = event_y(event), yt, yb, x = event_x(event);

      v->cursor_channel = v->tmarker_chan;
      yt = v->yval_to_y(v, v->tmarker_yval);
      v->cursor_channel = v->bmarker_chan;
      yb = v->yval_to_y(v, v->bmarker_yval);

      if(iabs(yt - y) > iabs(yb - y))
	do_top = 0;
      v->cursor_channel = v->xy_to_chan(v,x,y);
      move_ord_markers(v, x, y, do_top);
    } else {
      double time = v->cursor_time;
      if(fabs(v->lmarker_time - time) < fabs(v->rmarker_time - time))
	move_markers(v, time, 1);
      else
	move_markers(v, time, 0);
    }
  }

  if (write_common && event_is_up(event)) 
    markers_to_common(v);
}

/*********************************************************************/
void
e_repeat_previous(canvas, event, arg)
    Canvas	canvas;
    Event	*event;
    caddr_t	arg;
{
    Menuop *mo;

    SINGLE_HIT {
      mo = (Menuop*) xv_get(canvas, XV_KEY_DATA, menu_item_key);
      if(mo && mo->proc)
	mo->proc(canvas, event, mo->data);
    }
}

/*********************************************************************/
void
e_exec_waves(canvas, event, arg)
    Canvas	canvas;
    Event	*event;
    caddr_t	arg;
{
    extern char	*dispatch(),
		*receiver_prefixed();
    extern void exec_waves();

    if (debug_level)
	fprintf(stderr, "e_exec_waves: command \"%s\"\n", (char *) arg);

    SINGLE_HIT exec_waves((char *) arg);
}

/**************************************************************/
char **get_ops(mop)
     Menuop *mop;
{
  Menuop *mo = mop;
  int no = 0;
  char **wopl = NULL, **sort_a_list();
  
  while(mo) {
    no++;
    mo = mo->next;
  }
  if(no) {
    wopl = (char**) malloc(sizeof(char**) * (no+1));
    no = 0;
    while(mop) {

      if(mop->name && mop->name[0] && mop->proc)
	wopl[no++] = mop->name;

      mop = mop->next;
    }
    wopl[no] = NULL;
  }
  return(sort_a_list(wopl));
}

/**************************************************************/
char **get_full_op_list()
{
  char **wops = NULL;
  char **fop = NULL, **sort_a_list(), **uniq_list(), **fopp = NULL;
  int n = 0, ns = 0;
  Moplist  *menu_get_op_lists(), *mol = menu_get_op_lists();

  while(mol) {
    if((wops = get_ops(mol->first_op))) {

      n = 0;
      while(wops[n]) n++;
      
      ns += n;
      
      if(!fop)
	fop = (char**)malloc(sizeof(char**) * (ns+1));
      else
	fop = (char**)realloc(fop, sizeof(char**) * (ns+1));

      fopp = fop + ns - n;

      for(n=0; wops && wops[n]; n++)
	*fopp++ = wops[n];

      free(wops);

      *fopp = NULL;
    }
    mol = mol->next;
  }
  return(uniq_list(sort_a_list(fop)));
}

/**************************************************************/
char *pack_up_list_items(ol)
     char **ol;
{
  static char *the_list = NULL;
  static int llen = 0;

  if(ol) {
    int i, slen, j;
    for(i = 0, slen = 0; ol[i]; i++)
      slen += strlen(ol[i]) + 3;

    slen++;
    
    if(slen > llen) {
      if(the_list)
	free(the_list);
      the_list = NULL;
      llen = 0;
      if(!(the_list = malloc(slen))) {
	show_notice(1 ," allocation failure in pack_up_list_items().");
	return(NULL);
      } else
	if(debug_level)
	  fprintf(stderr,"Allocated %d bytes in pack_up_list_items()\n",slen);
     
      llen = slen;
    }
    for(j=0, *the_list = 0; j < i; j++)
      if(strchr(ol[j], ' '))	/* embedded space? */
	sprintf(the_list + strlen(the_list), "\"%s\" ", ol[j]);
      else
	sprintf(the_list + strlen(the_list), "%s ", ol[j]);

    free(ol);
    return(the_list);
  }
  return(NULL);
}

/**************************************************************/
char *get_string_list(op_type)
     char *op_type;
{
  static char *the_list = NULL;
  static int llen = 0;
  char **ol;
  extern char **waves_get_commands(), **object_get_commands(),
              **view_get_variable_names(), **get_new_files_list(),
              **get_objects_list();

  if(!strcmp(op_type,"view"))
    ol = get_full_op_list();

  if(!strcmp(op_type,"waves"))
    ol = waves_get_commands();

  if(!strcmp(op_type,"object"))
    ol = object_get_commands();

  if(!strcmp(op_type,"settables"))
    ol = get_ops(view_get_settable_list());

  if(!strcmp(op_type,"variables"))
    ol = view_get_variable_names();

  if(!strcmp(op_type,"new_files"))
    ol = get_new_files_list();

  if(!strcmp(op_type,"objects")) 
   ol = get_objects_list();

  return(pack_up_list_items(ol));

}