uif_piano.c

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

  GtkAdjustment *adj;

  seq_set_preset (uipiano_chan, preset);

  (*uipiano_ctrl_vals)[uipiano_chan][UIMIDI_PSET] = preset;

  widg = gtk_object_get_data (GTK_OBJECT (ui_main_window), "SPBpset");
  adj = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (widg));
  gtk_signal_handler_block_by_func (GTK_OBJECT (adj),
				    uipiano_pset_value_changed, widg);
  gtk_spin_button_set_value (GTK_SPIN_BUTTON (widg), (float)preset);
  gtk_signal_handler_unblock_by_func (GTK_OBJECT (adj),
				      uipiano_pset_value_changed, widg);
}

/* refresh current bank and preset controls
   hack for OSS AWE driver, blasted thing resets bank:preset to 0:0
   after some wavetable operations (not sure which) */
void
uipiano_refresh_bank_preset (void)
{
  seq_set_bank (uipiano_chan, (*uipiano_ctrl_vals)[uipiano_chan][UIMIDI_BANK]);
  seq_set_preset (uipiano_chan,(*uipiano_ctrl_vals)[uipiano_chan][UIMIDI_PSET]);
}

/* dummy routines to put in uipiano_ctrl_parms.func[] */
static void
uipiano_set_bank_dummy (gint chan, gint bank)
{
  uipiano_set_bank (bank);
}

static void
uipiano_set_preset_dummy (gint chan, gint preset)
{
  uipiano_set_preset (preset);
}

/* this routine handles the computer keyboard control of the piano, to get
around the inability to turn off key auto repeat (except for the entire X
session). It does this by checking for a subsequent press event (in the GDK
event queue) after a release key event is received, if the press event matches
the same key that was just released, then both events are ignored. Notice the
nasty hack to get around my inability to get gdk_event_peek() to work,
which comes into play if the second event is actually unrelated to the expected
auto repeat key press event */
gboolean
uipiano_cb_key_event (GtkWidget * widg, GdkEventKey * event, gint press)
{
  GdkEvent *pevent;
  guint8 i;
  guint8 key;
  guint8 note;

  if (event->state & (GDK_CONTROL_MASK | GDK_MOD1_MASK))
    return (FALSE);

  key = gdk_keyval_to_lower (event->keyval);
  for (i = 0; i < UIPIANO_TOTAL_NUMKEYS; i++)
    {
      if (key == uipiano_keytable[i])
	{
	  note = i;
	  if (i >= UIPIANO_LOW_NUMKEYS)
	    note = note - UIPIANO_LOW_NUMKEYS + 12;
	  note += (*uipiano_ctrl_vals)[uipiano_chan][UIMIDI_OCTAVE] * 12;
	  if (note > 127)
	    break;
	  if (press)
	    {
	      seq_note_on (uipiano_chan, note,
			  (*uipiano_ctrl_vals)[uipiano_chan]
			   [UIMIDI_VELOCITY_ON]);
	      piano_note_on (PIANO (uipiano_widg), note);
	    }
	  else
	    {			/* release event */
	      if (gdk_events_pending ())
		{
		  /* agghh! gdk_event_peek doesn't work! */
		  pevent = gdk_event_get ();
		  /* check if event is not actually what we expected */
		  if (pevent && (pevent->type != GDK_KEY_PRESS
		      || ((GdkEventKey *) (pevent))->keyval != event->keyval))
		    {
		      gdk_event_put (pevent);	/* put event back, oops */
		      gdk_event_free (pevent);
		    }
		  else if (pevent)
		    {
		      gdk_event_free (pevent);
		      break;	/* release is an auto repeat event */
		    }
		}
	      seq_note_off (uipiano_chan, note,
			    (*uipiano_ctrl_vals)[uipiano_chan]
			    [UIMIDI_VELOCITY_OFF]);
	      piano_note_off (PIANO (uipiano_widg), note);
	    }		/* release event */
	  break;
	}
    }
  return (FALSE);
}

static void
uipiano_cb_note_on (Piano * piano, guint keynum)
{
  seq_note_on (uipiano_chan, keynum,
	       (*uipiano_ctrl_vals)[uipiano_chan][UIMIDI_VELOCITY_ON]);
  piano_note_on (PIANO (uipiano_widg), keynum);
}

static void
uipiano_cb_note_off (Piano * piano, guint keynum)
{
  seq_note_off (uipiano_chan, keynum,
		(*uipiano_ctrl_vals)[uipiano_chan][UIMIDI_VELOCITY_OFF]);
  piano_note_off (PIANO (uipiano_widg), keynum);
}

void
uipiano_create_controls (void)
{
  GtkWidget *opt;
  GtkWidget *menu;
  GtkWidget *item;
  GtkWidget *spbtn;
  GtkWidget *hscale;
  GtkWidget *widg;
  GtkObject *adj;
  GtkAdjustment *radj;
  gint i, chan;

  widg = gtk_object_get_data (GTK_OBJECT (ui_main_window), "SPBchan");
  radj = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (widg));
  gtk_signal_connect (GTK_OBJECT (radj), "value-changed",
		      uipiano_chan_value_changed, widg);
  widg = gtk_object_get_data (GTK_OBJECT (ui_main_window), "SPBbank");
  radj = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (widg));
  gtk_signal_connect (GTK_OBJECT (radj), "value-changed",
		      uipiano_bank_value_changed, widg);
  widg = gtk_object_get_data (GTK_OBJECT (ui_main_window), "SPBpset");
  radj = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (widg));
  gtk_signal_connect (GTK_OBJECT (radj), "value-changed",
		      uipiano_pset_value_changed, widg);

  opt = gtk_object_get_data (GTK_OBJECT (ui_main_window), "OPTctrl");

  gtk_option_menu_remove_menu (GTK_OPTION_MENU (opt));

  menu = gtk_menu_new ();

  uipiano_ctrl_vals = g_malloc (16 * UIMIDI_CTRL_COUNT * sizeof (gint));

  /* set to default values for controls in all MIDI channels */
  for (chan = 0; chan < 16; chan++)
    for (i = 0; i < UIMIDI_CTRL_COUNT; i++)
      (*uipiano_ctrl_vals)[chan][i] = uipiano_ctrl_parms[i].def;

  for (i = 0; i < UIMIDI_CTRL_COUNT; i++)
    {
      /* set control */
      if (uipiano_ctrl_parms[i].func)
	(*uipiano_ctrl_parms[i].func)(uipiano_chan, (*uipiano_ctrl_vals)[0][i]);

      /* create menu item */
      if (uipiano_ctrl_parms[i].name)
	{
	  item = gtk_menu_item_new_with_label (_(uipiano_ctrl_parms[i].name));
	  gtk_widget_show (item);
	  gtk_menu_append (GTK_MENU (menu), item);
	}
    }

  gtk_option_menu_set_menu (GTK_OPTION_MENU (opt), menu);
  gtk_option_menu_set_history (GTK_OPTION_MENU (opt), 0);

  gtk_signal_connect (GTK_OBJECT (menu), "selection-done",
		      (GtkSignalFunc)uipiano_cb_control_selection_done, NULL);

  adj = gtk_adjustment_new (100.0, 0.0, 127.0, 1.0, 10.0, 0.0);

  spbtn = gtk_object_get_data (GTK_OBJECT (ui_main_window), "SPBctrl");
  gtk_spin_button_set_adjustment (GTK_SPIN_BUTTON (spbtn),
				  GTK_ADJUSTMENT (adj));

  uipiano_adj_changed_handler =
    gtk_signal_connect (GTK_OBJECT (adj), "value-changed",
			(GtkSignalFunc)uipiano_cb_control_value_changed, opt);

  hscale = gtk_object_get_data (GTK_OBJECT (ui_main_window), "HSCctrl");
  gtk_range_set_adjustment (GTK_RANGE (hscale), GTK_ADJUSTMENT (adj));

  uipiano_update_spin_button (0);
}

void
uipiano_set_all_controls (void)
{
  gint i;

  for (i = 0; i < UIMIDI_CTRL_COUNT; i++)
    if (uipiano_ctrl_parms[i].func)
      (*uipiano_ctrl_parms[i].func)(uipiano_chan,
				    (*uipiano_ctrl_vals)[uipiano_chan][i]);
}

static void
uipiano_cb_control_selection_done (GtkWidget * menu)
{
  GtkWidget *mnuitem;
  gint index;

  mnuitem = gtk_menu_get_active (GTK_MENU (menu));
  index = g_list_index (GTK_MENU_SHELL (menu)->children, mnuitem);

  uipiano_update_spin_button (index);
}

static void
uipiano_cb_control_value_changed (GtkWidget * adj, GtkWidget *opmenu)
{
  gint ndx;
  gint val;

  UTIL_OPMENU_INDEX (ndx, opmenu);

  val = (gint)(GTK_ADJUSTMENT (adj)->value + 0.5);

  (*uipiano_ctrl_vals)[uipiano_chan][ndx] = val;

  if (uipiano_ctrl_parms[ndx].func)
    (*uipiano_ctrl_parms[ndx].func)(uipiano_chan, val);
}

static void
uipiano_update_spin_button (gint ctrlindex)
{
  GtkWidget *widg;
  GtkAdjustment *adj;

  widg = gtk_object_get_data (GTK_OBJECT (ui_main_window), "SPBctrl");
  adj = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (widg));

  adj->lower = uipiano_ctrl_parms[ctrlindex].lo;
  adj->upper = uipiano_ctrl_parms[ctrlindex].hi;
  adj->value = (*uipiano_ctrl_vals)[uipiano_chan][ctrlindex];

  gtk_signal_handler_block (GTK_OBJECT (adj), uipiano_adj_changed_handler);

  gtk_adjustment_changed (adj);
  gtk_adjustment_value_changed (adj);

  gtk_signal_handler_unblock (GTK_OBJECT (adj),
			      uipiano_adj_changed_handler);
}

static void
uipiano_chan_value_changed (GtkAdjustment *adj, GtkWidget *spb)
{
  gint val;

  val = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spb));
  uipiano_set_chan (val);
}

static void
uipiano_bank_value_changed (GtkAdjustment *adj, GtkWidget *spb)
{
  gint val;

  val = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spb));
  uipiano_set_bank (val);
}

static void
uipiano_pset_value_changed (GtkAdjustment *adj, GtkWidget *spb)
{
  gint val;

  val = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spb));
  uipiano_set_preset (val);
}