uif_sfont.c

A GTK sound font editor. Sound font files are used to synthesize instruments from audio samples for

      sfdo_group (_("New instrument"));
      dofunc_noitem_save (SFTREE_NODE_REF (node)->itemid);
      sfdo_done ();
    }

  gtk_widget_destroy (instwin);
}

/* modify sample parameters (name, rate, fine tune) */
void
uisf_modify_sample (void)
{
  SFItemID itemid;
  GtkCTreeNode *node;
  SFSample *sam;
  GtkWidget *samwin;

  if (!(itemid = sftree_get_selection_single ())) return;
  if (!(node = SFTREE_LOOKUP_ITEMID (itemid))) return;
  if (SFTREE_NODE_REF (node)->type != NODE_SAMPLE) return;

  sam = (SFSample *) (((GSList *) (SFTREE_NODE_REF (node)->dptr))->data);

  if (util_activate_unique_dialog ("newmod_sam", sam->itemid)) return;

  samwin = uisf_create_sample_config_dialog (_("Rename Sample"), sam->name,
					     sam->samplerate, sam->pitchadj,
					     uisf_cb_modify_sample_cbfunc);
  util_register_unique_dialog (samwin, "newmod_sam", sam->itemid);

  gtk_object_set_data (GTK_OBJECT (samwin), "itemid", GINT_TO_POINTER (itemid));
  gtk_widget_show (samwin);
}

GtkWidget *
uisf_create_sample_config_dialog (gchar *title, gchar *name, guint32 samplerate,
				  gint8 pitchadj, GtkSignalFunc cbfunc)
{
  GtkWidget *samwin;
  GtkWidget *entry;
  GtkWidget *widg;
  gint ndx;
  gchar *s;

  samwin = create_samwin ();

  gtk_window_set_title (GTK_WINDOW (samwin), title);
  gtk_object_set_data (GTK_OBJECT (samwin), "cbfunc", cbfunc);

  entry = gtk_object_get_data (GTK_OBJECT (samwin), "ENname");
  gtk_entry_set_text (GTK_ENTRY (entry), name);

  /* if samplerate is specified (not 0), display rate and fine tuning options */
  if (samplerate != 0)
    {
      /* display sample rate and fine tune settings */
      widg = gtk_object_get_data (GTK_OBJECT (samwin), "settings");
      gtk_widget_show (widg);

      switch (samplerate)
	{
	case 44100: ndx = 0; break;
	case 22050: ndx = 1; break;
	case 11025: ndx = 2; break;
	default:
	  ndx = 3;
	  widg = gtk_object_get_data (GTK_OBJECT (samwin), "ENcustom");
	  s = g_strdup_printf ("%d", samplerate);
	  gtk_entry_set_text (GTK_ENTRY (widg), s);
	  g_free (s);
	}

      widg = gtk_object_get_data (GTK_OBJECT (samwin), "OPrate");
      gtk_option_menu_set_history (GTK_OPTION_MENU (widg), ndx);

      widg = gtk_object_get_data (GTK_OBJECT (samwin), "SPBftune");
      gtk_spin_button_set_value (GTK_SPIN_BUTTON (widg), (float)pitchadj);
    }

  return (samwin);
}

void
uisf_cb_modify_sample_okay (GtkButton * button, GtkWidget * samwin)
{
  gchar *name;
  void (*cbfunc) (GtkWidget * samwin);
  GtkWidget *widg;
  gint ndx, rate;

  /* Sample name is valid? */
  widg = gtk_object_get_data (GTK_OBJECT (samwin), "ENname");
  name = gtk_entry_get_text (GTK_ENTRY (widg));
  if (!strlen (name))
    {
      util_quick_popup (_("Sample name is required"), NULL);
      return;
    }

  gtk_object_get_data (GTK_OBJECT (samwin), "settings");
  if (GTK_WIDGET_VISIBLE (widg))
    {
      widg = gtk_object_get_data (GTK_OBJECT (samwin), "OPrate");

      /* macro stores selected item index into ndx */
      UTIL_OPMENU_INDEX (ndx, widg);

      if (ndx == 3)
	{
	  widg = gtk_object_get_data (GTK_OBJECT (samwin), "ENcustom");
	  rate = atoi (gtk_entry_get_text (GTK_ENTRY (widg)));

	  if (rate < SF_MIN_SAMPLERATE || rate > SF_MAX_SAMPLERATE)
	    {
	      util_quick_popup (_("Sample rate is out of bounds"), NULL);
	      return;
	    }
	}
    }

  cbfunc = gtk_object_get_data (GTK_OBJECT (samwin), "cbfunc");

  if (cbfunc)
    (*cbfunc) (samwin);
  else
    gtk_widget_destroy (samwin);
}

static void
uisf_cb_modify_sample_cbfunc (GtkWidget * samwin)
{
  SFItemID itemid;
  GtkWidget *widg;
  GtkCTreeNode *node, *nptr;
  SFTreeRef *ref;
  UISFont *uisf;
  GSList *psam;
  GList *match;
  SFSample *sam;
  gchar *name;
  gint ndx;

  itemid = GPOINTER_TO_INT (gtk_object_get_data (GTK_OBJECT (samwin),"itemid"));
  if (!(node = SFTREE_LOOKUP_ITEMID (itemid)))
    {
      gtk_widget_destroy (samwin);
      return;
    }

  ref = SFTREE_NODE_REF (node);
  psam = ref->dptr;
  sam = (SFSample *) (psam->data);

  uisf = SFTREE_UPFIND_UISF (node);

  widg = gtk_object_get_data (GTK_OBJECT (samwin), "ENname");
  name = gtk_entry_get_text (GTK_ENTRY (widg));

  if (sfont_find_sample (uisf->sf, name, sam))
    {
      util_quick_popup (_("A sample already exists with that name"), NULL);
      return;
    }

  sfont_set_namestr (uisf->sf, sam->name, name);
  sftree_set_tree_node_label (node, name);

  nptr = uisf->nodes->inst;	/* instrument branch of tree */

  /* find all instrument zone references to this instrument */
  match = gtk_ctree_find_all_by_row_data_custom (sftree_widg, nptr, psam,
    (GCompareFunc) uisf_find_izone_by_sample_compare);

  g_list_foreach (match, (GFunc) sftree_set_tree_node_label, name);
  g_list_free (match);

  /* get sample rate parameter */
  widg = gtk_object_get_data (GTK_OBJECT (samwin), "OPrate");
  UTIL_OPMENU_INDEX (ndx, widg); /* macro stores selected item index into ndx */

  switch (ndx)
    {
    case 0: sam->samplerate = 44100; break;
    case 1: sam->samplerate = 22050; break;
    case 2: sam->samplerate = 11025; break;
    case 3:
      widg = gtk_object_get_data (GTK_OBJECT (samwin), "ENcustom");
      sam->samplerate = atoi (gtk_entry_get_text (GTK_ENTRY (widg)));
      break;
    }

  /* get the fine tunning parameter */
  widg = gtk_object_get_data (GTK_OBJECT (samwin), "SPBftune");
  sam->pitchadj = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (widg));

  gtk_widget_destroy (samwin);
}

/* pop a dialog to confirm delete of sf item */
void
uisf_dialog_sfitem_delete (void)
{
  SFItemID itemid;
  GtkCTreeNode *node;
  GSList *p, *p2, *p3;
  UISFont *uisf;
  SFPreset *pset;
  SFInst *inst;
  SFSample *sam;
  SFZone *z;
  VBnkItem *vbitem;
  gchar *s;
  gchar keystr[8];
  gint refcount = 0;

  if (!(itemid = sftree_get_selection_single ())) return;
  if (!(node = SFTREE_LOOKUP_ITEMID (itemid))) return;
  p = SFTREE_NODE_REF (node)->dptr;

  switch (SFTREE_NODE_REF (node)->type)
    {
    case NODE_PRESET:
      pset = (SFPreset *) (p->data);
      s = g_strdup_printf (_("Delete preset \"%03d-%03d %s\"?"), pset->bank,
	pset->prenum, pset->name);
      break;
    case NODE_PZONE:
      z = (SFZone *) (p->data);
      s = g_strdup_printf (_("Delete preset zone \"%s\"?"),
	z->instsamp ? ((SFInst *) (z->instsamp->data))->
	name : _("Global Zone"));
      break;
    case NODE_INST:
      inst = (SFInst *) (p->data);
      uisf = SFTREE_UPFIND_UISF (node);

      /* get preset list for this instrument's sfont */
      p2 = uisf->sf->preset;

      /* count the number of preset references to this instrument */
      while (p2)
	{			/* traverse presets */
	  p3 = ((SFPreset *) (p2->data))->zone;
	  while (p3)
	    {			/* traverse preset zones */
	      if (((SFZone *) (p3->data))->instsamp == p)
		refcount++;
	      p3 = g_slist_next (p3);
	    }
	  p2 = g_slist_next (p2);
	}

      s =
	g_strdup_printf (_("Delete instrument \"%s\" (%d preset references)?"),
			 inst->name,
	refcount);
      break;
    case NODE_IZONE:
      z = (SFZone *) (p->data);
      s = g_strdup_printf (_("Delete instrument zone \"%s\"?"),
	z->instsamp ? ((SFSample *) (z->instsamp->data))->
	name : _("Global Zone"));
      break;
    case NODE_SAMPLE:
      sam = (SFSample *) (p->data);
      uisf = SFTREE_UPFIND_UISF (node);

      /* get instrument list for this samples's sfont */
      p2 = uisf->sf->inst;

      /* count the number of instrument references to this sample */
      while (p2)
	{			/* traverse instruments */
	  p3 = ((SFInst *) (p2->data))->zone;
	  while (p3)
	    {			/* traverse instrument zones */
	      if (((SFZone *) (p3->data))->instsamp == p)
		refcount++;
	      p3 = g_slist_next (p3);
	    }
	  p2 = g_slist_next (p2);
	}

      s =
	g_strdup_printf (_("Delete sample \"%s\" (%d instrument references)?"),
			 sam->name,
	refcount);
      break;
    case NODE_VBNK_MAP:
      vbitem = (VBnkItem *) (p->data);

      if (vbitem->map.keynote >= 0)
	sprintf (keystr, " [%03d]", vbitem->map.keynote);
      else keystr[0] = '\0';

      s = g_strdup_printf (_("Delete virtual bank map \"%03d-%03d%s\"?"),
			   vbitem->map.bank, vbitem->map.psetnum,
			   keystr);
      break;
    default:
      return;
      break;
    }

  util_quick_popup (s, _("OK"), uisf_cb_sfitem_delete_okay,
		    GINT_TO_POINTER (itemid),
		    _("Cancel"), NULL, NULL, NULL);
  g_free (s);
}

/* user confirmed sound font item delete */
static void
uisf_cb_sfitem_delete_okay (gpointer data, GtkWidget *popdog)
{
  SFItemID itemid = GPOINTER_TO_INT (data);

  if (itemid)
    uisf_sfitem_delete (itemid);

  gtk_widget_destroy (popdog);
}

/* create global zone for preset/inst */
void
uisf_item_global_zone (void)
{
  SFItemID itemid;
  GtkCTreeNode *node, *n;
  UISFont *uisf;
  SFTreeRef *ref;
  SFPreset *pset;
  SFInst *inst;

  if (!(itemid = sftree_get_selection_single ())) return;
  if (!(node = SFTREE_LOOKUP_ITEMID (itemid))) return;

  ref = SFTREE_NODE_REF (node);

  if (ref->type == NODE_PRESET)
    {
      pset = ((GSList *) (ref->dptr))->data;

      if (pset->zone && !(((SFZone *) (pset->zone->data))->instsamp))
	{
	  util_quick_popup (_("Preset already has a Global Zone"), NULL);
	  return;
	}
    }
  else if (ref->type == NODE_INST)
    {
      inst = ((GSList *) (ref->dptr))->data;

      if (inst->zone && !(((SFZone *) (inst->zone->data))->instsamp))
	{
	  util_quick_popup (_("Instrument already has a Global Zone"), NULL);
	  return;
	}
    }
  else return;			/* not INST or PRESET */

  /* find sound font node that owns target preset */
  uisf = SFTREE_UPFIND_UISF (node);

  if (ref->type == NODE_PRESET)
    {
      sfont_new_preset_zone (uisf->sf, pset, NULL);
      n = sftree_add_pzone (pset->zone, node, SFTREE_NODE_APPEND);

      /* save undo state */
      sfdo_group (_("Preset global zone"));
      dofunc_noitem_save (SFTREE_NODE_REF (n)->itemid);
      sfdo_done ();
    }
  else
    {
      sfont_new_inst_zone (uisf->sf, inst, NULL);
      n = sftree_add_izone (inst->zone, node, SFTREE_NODE_APPEND);

      /* save undo state */
      sfdo_group (_("Instrument global zone"));
      dofunc_noitem_save (SFTREE_NODE_REF (n)->itemid);
      sfdo_done ();
    }
}

void
uisf_find (void)
{
  SFItemID itemid;
  GtkCTreeNode *node = NULL;
  GtkWidget *findwin;
  GtkWidget *opmenu;
  GtkWidget *menu;
  GtkWidget *mitem;
  GtkWidget *btn;
  SFTreeRef *ref;
  UISFont *uisf, *startuisf;
  GList *p;
  gint type, i, index;

  /* don't care if it doesn't exist.. Will just do a default find window */
  if ((itemid = sftree_get_selection_single ()))
    node = SFTREE_LOOKUP_ITEMID (itemid);

  if (util_activate_unique_dialog ("findwin", 0)) return;

  findwin = create_findwin ();
  util_register_unique_dialog (findwin, "findwin", 0);

  opmenu = gtk_object_get_data (GTK_OBJECT (findwin), "OPtype");
  menu = gtk_option_menu_get_menu (GTK_OPTION_MENU (opmenu));
  gtk_signal_connect (GTK_OBJECT (menu), "selection-done",
    (GtkSignalFunc) uisf_cb_find_optype_selection_done, findwin);

  btn = gtk_object_get_data (GTK_OBJECT (findwin), "BTNsearch");
  gtk_signal_connect (GTK_OBJECT (btn), "clicked",
    (GtkSignalFunc) uisf_cb_find_search, findwin);

  btn = gtk_object_get_data (GTK_OBJECT (findwin), "BTNclose");
  gtk_signal_connect_object (GTK_OBJECT (btn), "clicked",
    (GtkSignalFunc) gtk_widget_destroy, GTK_OBJECT (findwin));

  btn = gtk_object_get_data (GTK_OBJECT (findwin), "BTNcancel");
  gtk_signal_connect_object (GTK_OBJECT (btn), "clicked",
    (GtkSignalFunc) gtk_widget_destroy, GTK_OBJECT (findwin));

  startuisf = NULL;
  if (node)
    {			/* if an initial node was specified for search hints */
      startuisf = SFTREE_UPFIND_UISF (node);	/* sfont to start in */
      ref = SFTREE_NODE_REF (node);
      i = ref->type;

      if (i == NODE_INSTROOT || i == NODE_INST)
	type = 1;
      else if (i == NODE_SAMPLEROOT || i == NODE_USER || i == NODE_ROM
	|| i == NODE_SAMPLE) type = 2;
      else
	type = 0;

      /* set type of node to search for from hint node */
      opmenu = gtk_object_get_data (GTK_OBJECT (findwin), "OPtype");
      gtk_option_menu_set_history (GTK_OPTION_MENU (opmenu), type);
    }

  if (uisf_sfonts)
    {				/* load menu of sound font file names */
      opmenu = gtk_object_get_data (GTK_OBJECT (findwin), "OPfile");
      menu = gtk_option_menu_get_menu (GTK_OPTION_MENU (opmenu));

      index = 0;
      i = 1;
      p = uisf_sfonts;
      while (p)
	{
	  uisf = (UISFont *) (p->data);

	  if (uisf == startuisf)
	    index = i;

	  mitem = gtk_menu_item_new_with_label (g_basename (uisf->sf->fname));
	  ref = SFTREE_NODE_REF (uisf->nodes->sfont);
	  gtk_object_set_data (GTK_OBJECT (mitem), "sfitemid",
	    GINT_TO_POINTER (ref->itemid));
	  gtk_widget_show (mitem);
	  gtk_menu_append (GTK_MENU (menu), mitem);

	  i++;
	  p = g_list_next (p);
	}

      gtk_option_menu_set_history (GTK_OPTION_MENU (opmenu), index);
    }

  gtk_widget_show (findwin);
}

static void
uisf_cb_find_optype_selection_done (GtkWidget * menu, GtkWidget * findwin)
{