uif_sfont.c

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

/* load virtual bank sound font dependencies */
void
uisf_vbank_load_depends (VBnkData *vbnk)
{
  GList *found, *notfound, *p, *p2;
  gchar *path;

  vbank_find_unloaded_sfonts (vbnk, &found, NULL);

  p = found;
  while (p)			/* loop over located sound fonts */
    {
      path = (gchar *)(p->data);

      /* see if sound font is NOT already loaded */
      if (!(uisf_find_sfont_by_fname (path, NULL)))
	{
	  if (!uisf_load_sfont (path)) /* load sound font */
	    logit (LogBad, _("Failed to load sound font '%s' for virtual bank"),
		  path);
	}

      p2 = p;
      p = g_list_next (p);

      g_free (path);		/* free path string */
      found = g_list_remove_link (found, p2); /* remove and free GList item */
      g_list_free_1 (p2);
    }

  g_list_foreach (notfound, (GFunc)g_free, NULL);
  g_list_free (notfound);
}


/***---        Sound Font NODE level interactive routines        ---***/


void
uisf_item_properties (void)
{
  SFItemID itemid;
  GtkCTreeNode *node;
  SFTreeRef *ref;

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

  ref = SFTREE_NODE_REF (node);

  switch (ref->type)
    {
    case NODE_SFONT:
      uisf_sfont_info ();
      break;
    case NODE_PRESET:
      uisf_newmod_preset (FALSE);
      break;
    case NODE_INST:
      uisf_newmod_inst (FALSE);
      break;
    case NODE_SAMPLE:
      uisf_modify_sample ();
      break;
    default:
      break;
    }
}

void
uisf_newmod_preset (gboolean create)
{
  SFItemID itemid;
  GtkCTreeNode *node;
  SFTreeRef *ref;
  gboolean melodic = TRUE;
  UISFont *uisf;
  SFPreset *pset;
  GtkWidget *psetwin;
  gint bank, prenum;
  gchar *name, *title;
  SFItemID uniitemid;

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

  if (create)
    {
      if (sftree_find_parent_by_type (node, NODE_PERCUSS))
	melodic = FALSE;	/* is node hint under percussion branch? */

      uisf = SFTREE_UPFIND_UISF (node);

      uniitemid = uisf->sf->itemid; /* use SF itemid for unique dialog key */

      sfont_find_free_preset (uisf->sf, &bank, &prenum, melodic);
      title = _("New Preset");
      name = "";
    }
  else
    {
      if (ref->type != NODE_PRESET) return;

      pset = (SFPreset *)(((GSList *)(ref->dptr))->data);
      uniitemid = pset->itemid;
      title = _("Modify Preset");
      name = pset->name;
      bank = pset->bank;
      prenum = pset->prenum;
    }

  if (util_activate_unique_dialog ("newmod_pset", uniitemid))
    return;

  psetwin = uisf_create_preset_config_dialog (title, name, bank, prenum,
					      uisf_cb_newmod_preset_cbfunc);

  util_register_unique_dialog (psetwin, "newmod_pset", uniitemid);

  gtk_object_set_data (GTK_OBJECT (psetwin), "itemid", GINT_TO_POINTER(itemid));
  gtk_object_set_data (GTK_OBJECT (psetwin), "create",
		       GINT_TO_POINTER (create));

  gtk_widget_show (psetwin);
}

GtkWidget *
uisf_create_preset_config_dialog (gchar *title, gchar *name, guint8 bank,
				  guint8 prenum, GtkSignalFunc cbfunc)
{
  GtkWidget *psetwin;
  GtkWidget *entry;
  GtkWidget *btn;

  psetwin = create_presetwin ();	/* create preset config window */

  gtk_window_set_title (GTK_WINDOW (psetwin), title);

  /* call back function for preset window */
  gtk_object_set_data (GTK_OBJECT (psetwin), "cbfunc", cbfunc);

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

  btn = gtk_object_get_data (GTK_OBJECT (psetwin), "SPBbank");
  gtk_spin_button_set_value (GTK_SPIN_BUTTON (btn), bank);

  btn = gtk_object_get_data (GTK_OBJECT (psetwin), "SPBprenum");
  gtk_spin_button_set_value (GTK_SPIN_BUTTON (btn), prenum);

  /* set state of melodic/percussion radio buttons and bank # */
  btn = gtk_object_get_data (GTK_OBJECT (psetwin), "RADmelod");
  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (btn), (bank != 128));

  return (psetwin);
}

/* glade_interface.c references this function */
void
uisf_cb_newmod_preset_type_toggled (GtkToggleButton * togglebutton,
  GtkWidget * presetwin)
{
  GtkWidget *rad;
  GtkWidget *spb;

  rad = gtk_object_get_data (GTK_OBJECT (presetwin), "RADmelod");
  spb = gtk_object_get_data (GTK_OBJECT (presetwin), "SPBbank");

  if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (rad)))
    {
      gtk_widget_set_sensitive (GTK_WIDGET (spb), TRUE);
      gtk_spin_button_set_value (GTK_SPIN_BUTTON (spb), 0.0);
    }
  else
    {
      gtk_widget_set_sensitive (GTK_WIDGET (spb), FALSE);
      gtk_spin_button_set_value (GTK_SPIN_BUTTON (spb), 128.0);
    }
}

/* glade_interface.c references this function */
void
uisf_cb_newmod_preset_okay (GtkButton * button, GtkWidget * psetwin)
{
  gchar *name;
  guint8 bank;
  guint8 prenum;
  void (*cbfunc) (GtkWidget * psetwin);

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

  /* bank # is valid? */
  bank =
    gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (gtk_object_get_data
      (GTK_OBJECT (psetwin), "SPBbank")));

  if (bank > 128)
    {
      util_quick_popup (_("Invalid bank #, must be 0-128"), NULL);
      return;
    }

  /* preset # is valid? */
  prenum =
    gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (gtk_object_get_data
      (GTK_OBJECT (psetwin), "SPBprenum")));

  if (prenum > 127)
    {
      util_quick_popup (_("Invalid preset #, must be 0-127"), NULL);
      return;
    }

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

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

/* Processes user input for new or modified preset */
static void
uisf_cb_newmod_preset_cbfunc (GtkWidget * psetwin)
{
  SFItemID itemid;
  GtkCTreeNode *node;
  SFTreeRef *ref;
  GSList *p;
  gboolean create;
  SFPreset *pset;
  UISFont *uisf;
  gchar *name;
  guint8 bank, prenum;
  gboolean expanded;

  /* node only set if modifying preset, NULL if new */
  itemid = GPOINTER_TO_INT (gtk_object_get_data (GTK_OBJECT(psetwin),"itemid"));
  if (!(node = SFTREE_LOOKUP_ITEMID (itemid)))
    {
      gtk_widget_destroy (psetwin);
      return;
    }

  uisf = SFTREE_UPFIND_UISF (node);

  create =
    GPOINTER_TO_INT (gtk_object_get_data (GTK_OBJECT (psetwin), "create"));

  if (!create)
    {
      ref = SFTREE_NODE_REF (node);
      p = ref->dptr;
      pset = (SFPreset *) (p->data);
    }
  else
    pset = NULL;

  /* load user input values */
  name =
    gtk_entry_get_text (GTK_ENTRY (gtk_object_get_data (GTK_OBJECT (psetwin),
	"ENname")));
  bank =
    gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (gtk_object_get_data
      (GTK_OBJECT (psetwin), "SPBbank")));
  prenum =
    gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (gtk_object_get_data
      (GTK_OBJECT (psetwin), "SPBprenum")));

  /* look for conflicting preset (exclude itself from the search) */
  if ((p = sfont_find_preset (uisf->sf, name, bank, prenum, pset)))
    {
      SFPreset *pr = (SFPreset *) (p->data);
      if (pr->prenum == prenum && pr->bank == bank)
	util_quick_popup (_("A preset with that bank # and preset # exists"),
	  NULL);
      else
	util_quick_popup (_("A preset with that name exists"), NULL);
      return;
    }

  if (pset)
    {				/* Modified preset? */
      expanded = GTK_CTREE_ROW (node)->expanded; /* save expanded state */
      SFTREE_FREEZE ();
      SFTREE_REMOVE_NODE (node);

      sfont_set_namestr (uisf->sf, pset->name, name);
      pset->bank = bank;
      pset->prenum = prenum;
      uisf->sf->preset = g_slist_remove (uisf->sf->preset, pset);
      sfont_add_preset (uisf->sf, pset);
      node = sftree_add_preset_sorted (g_slist_find (uisf->sf->preset, pset),
	uisf->nodes);

      /* restore expanded state */
      if (expanded) gtk_ctree_expand (GTK_CTREE (sftree_widg), node);
      SFTREE_THAW ();
    }
  else
    {				/* ?: No, its new */
      pset = sfont_new_preset (uisf->sf, name, bank, prenum);
      node = sftree_add_preset_sorted (g_slist_find (uisf->sf->preset, pset),
	uisf->nodes);

      /* save undo state */
      sfdo_group (_("New preset"));
      dofunc_noitem_save (SFTREE_NODE_REF (node)->itemid);
      sfdo_done ();
    }

  gtk_widget_destroy (psetwin);
}

/*  name or rename an instrument 
    if create == TRUE then new instrument, rename otherwise */
void
uisf_newmod_inst (gboolean create)
{
  SFItemID itemid;
  GtkCTreeNode *node;
  SFTreeRef *ref;
  GtkWidget *instwin;
  SFInst *inst;
  gchar *title, *name;
  SFItemID uniitemid;

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

  if (create)
    {
      UISFont *uisf = SFTREE_UPFIND_UISF (node);
      uniitemid = uisf->sf->itemid;
      title = _("New Instrument");
      name = "";
    }
  else
    {
      if (ref->type != NODE_INST) return;

      title = _("Rename Instrument");
      inst = (SFInst *) (((GSList *)(ref->dptr))->data);
      uniitemid = inst->itemid;
      name = inst->name;
    }

  if (util_activate_unique_dialog ("newmod_inst", uniitemid)) return;

  instwin = uisf_create_inst_config_dialog (title, name,
					    uisf_cb_newmod_inst_cbfunc);

  util_register_unique_dialog (instwin, "newmod_inst", uniitemid);

  gtk_object_set_data (GTK_OBJECT (instwin), "itemid", GINT_TO_POINTER(itemid));
  gtk_object_set_data (GTK_OBJECT (instwin), "create",
		       GINT_TO_POINTER (create));

  gtk_widget_show (instwin);
}

GtkWidget *
uisf_create_inst_config_dialog (gchar * title, gchar * name,
				GtkSignalFunc cbfunc)
{
  GtkWidget *instwin;
  GtkWidget *entry;

  instwin = create_instwin ();

  gtk_window_set_title (GTK_WINDOW (instwin), title);
  gtk_object_set_data (GTK_OBJECT (instwin), "cbfunc", cbfunc);
  entry = gtk_object_get_data (GTK_OBJECT (instwin), "ENname");
  gtk_entry_set_text (GTK_ENTRY (entry), name);

  return (instwin);
}

void
uisf_cb_newmod_inst_okay (GtkButton * button, GtkWidget * instwin)
{
  gchar *name;
  void (*cbfunc) (GtkWidget * instwin);

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

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

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

/* user confirmed name or rename of instrument */
static void
uisf_cb_newmod_inst_cbfunc (GtkWidget * instwin)
{
  SFItemID itemid;
  GtkCTreeNode *node, *nptr;
  gboolean create;
  SFTreeRef *ref;
  UISFont *uisf;
  GSList *pinst;
  GList *match;
  SFInst *inst;
  gchar *name;

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

  create =
    GPOINTER_TO_INT (gtk_object_get_data (GTK_OBJECT (instwin), "create"));

  if (!create)
    {
      ref = SFTREE_NODE_REF (node);
      pinst = ref->dptr;
      inst = (SFInst *) (pinst->data);
    }
  else
    inst = NULL;

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

  uisf = SFTREE_UPFIND_UISF (node);

  /* check for duplicates (exclude inst from search) */
  if (sfont_find_inst (uisf->sf, name, inst))
    {
      util_quick_popup (_("An instrument with that name exists"), NULL);
      return;
    }

  if (inst)
    {				/* rename instrument? */
      sfont_set_namestr (uisf->sf, inst->name, name);
      sftree_set_tree_node_label (node, name);

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

      /* find all preset zone references to this instrument */
      match = gtk_ctree_find_all_by_row_data_custom (sftree_widg, nptr, pinst,
	(GCompareFunc) uisf_find_pzone_by_inst_compare);

      g_list_foreach (match, (GFunc) sftree_set_tree_node_label, name);
      g_list_free (match);
    }
  else
    {				/* ? : No, new instrument */
      inst = sfont_new_inst (uisf->sf, name);
      node = sftree_add_inst (g_slist_find (uisf->sf->inst, inst), uisf->nodes,
		       SFTREE_NODE_APPEND);

      /* save undo state */