uif_pianospan.c

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

  ptrstrip_set_pointer (PTRSTRIP (pianospan_ptrstrip), 0, -1);

  gtk_signal_handler_unblock_by_func (GTK_OBJECT (pianospan_ptrstrip),
			    (GtkSignalFunc) pianospan_cb_ptrstrip_change, NULL);
}

void
pianospan_update_rootkey_ptrstrip (void)
{
  SFGenAmount *amt;
  gint xpos;

  if (uisf_selected_elem_type == NODE_INST && uisf_selected_zone)
    {				/* inst root key override */
      amt = sfont_gen_get (uisf_selected_zone, Gen_OverrideRootKey);
      if (amt)
	xpos = piano_key_to_xpos (amt->sword);
      else
	xpos = 0;
    }
  else if (uisf_selected_elem_type == NODE_SAMPLE)
    {				/* sample root key */
      xpos = piano_key_to_xpos (((SFSample *) uisf_selected_elem)->origpitch);
    }
  else return;			/* not izone or sample selection! */

  gtk_signal_handler_block_by_func (GTK_OBJECT (pianospan_ptrstrip),
			    (GtkSignalFunc) pianospan_cb_ptrstrip_change, NULL);

  ptrstrip_set_pointer (PTRSTRIP (pianospan_ptrstrip), 0, xpos);

  gtk_signal_handler_unblock_by_func (GTK_OBJECT (pianospan_ptrstrip),
			    (GtkSignalFunc) pianospan_cb_ptrstrip_change, NULL);
}

static void
pianospan_cb_scrollbar_automatic (GtkAdjustment * adj, GtkWidget * scrollbar)
{
  if (GTK_WIDGET_VISIBLE (scrollbar))
    {
      if ((adj->upper - adj->lower) <= adj->page_size)
	{
	  gtk_widget_hide (scrollbar);
	}
    }
  else
    {
      if ((adj->upper - adj->lower) > adj->page_size)
	{
	  gtk_widget_show (scrollbar);
	}
    }
}

static void
pianospan_cb_piano_vel_range_hadj (GtkAdjustment * padj, GtkAdjustment * radj)
{
  gtk_adjustment_set_value (radj, padj->value);
}

static void
pianospan_cb_ptrstrip_change (GtkWidget * ptrstrip, guint ptrndx)
{
  gint keynum;
  gint ptrxpos, newxpos;
  SFGenAmount amt, *getamt;
  GtkPSPtr *psptr;

  if (ptrndx != 0 || !(PTRSTRIP (ptrstrip)->pointers)) return;

  /* we want first pointer */
  psptr = (GtkPSPtr *) (PTRSTRIP (ptrstrip)->pointers->data);
  ptrxpos = psptr->xpos;

  /* get current value of root key */
  if (uisf_selected_elem_type == NODE_INST && uisf_selected_zone)
    {				/* -- inst root key override */

      /* ptr at very left hand side of the pointer bar disables rootkey
         override, which means the rootkey from the sample is used */
      if (ptrxpos > 3)
	{			/* NO, ptr is not far left */
	  keynum = piano_xpos_to_key (ptrxpos);
	  newxpos = piano_key_to_xpos (keynum);
	}
      else
	{			/* YES, ptr is at far left */
	  keynum = -1;
	  newxpos = 0;
	}

      getamt = sfont_gen_get (uisf_selected_zone, Gen_OverrideRootKey);

      /* check if new keynum is different then old */
      if ((!getamt && keynum == -1) || (getamt && getamt->sword == keynum))
	{
	  /* new keynum is the same as old, stop signal propagation */
	  gtk_signal_emit_stop_by_name (GTK_OBJECT (ptrstrip),
	    "pointer_change");
	}
      else
	{			/* keynum is different then old, so update it */
	  amt.sword = keynum;	/* set the override root key gen */
	  sfont_gen_set (uisf_selected_uisfont->sf, uisf_selected_zone,
	    Gen_OverrideRootKey, amt, FALSE);

	  /* notify wavetable of change */
	  if (uisf_selected_elem_type == NODE_PRESET)
	    {
	      wtbl_sfitem_changed (((SFPreset *)uisf_selected_elem)->itemid,
				   WTBL_ITEM_CHANGE);
	    }
	  else
	    {
	      wtbl_sfitem_changed (((SFInst *)uisf_selected_elem)->itemid,
				 WTBL_ITEM_CHANGE);
	    }
	}
    }
  else if (uisf_selected_elem_type == NODE_SAMPLE)
    {				/* -- sample root key */
      keynum = piano_xpos_to_key (ptrxpos);
      newxpos = piano_key_to_xpos (keynum);

      if (keynum == ((SFSample *) uisf_selected_elem)->origpitch)
	{
	  /* new keynum is the same as old, stop signal propagation */
	  gtk_signal_emit_stop_by_name (GTK_OBJECT (ptrstrip),
	    "pointer_change");
	}
      else
	{
	  ((SFSample *) uisf_selected_elem)->origpitch = keynum;

	  /* notify wavetable of change */
	  wtbl_sfitem_changed (((SFSample *)uisf_selected_elem)->itemid,
			       WTBL_ITEM_CHANGE);
	}
    } else return;		/* not instrument or sample selection! */

  psptr->xpos = newxpos;	/* lock the ptr to key centers */
}

void
pianospan_draw_velocity_bar (void)
{
  gint i, i2, lastlevel = 0;
  float levelinc, level = 0.0;
  gint rval, gval, bval;
  float rf, gf, bf, rinc, ginc, binc;

  rval = velbar_scolor[0];
  gval = velbar_scolor[1];
  bval = velbar_scolor[2];

  rf = (float) rval;
  gf = (float) gval;
  bf = (float) bval;

  rinc = (float) (velbar_ecolor[0] - rval + 1) / PIANO_DEFAULT_SIZEX;
  ginc = (float) (velbar_ecolor[1] - gval + 1) / PIANO_DEFAULT_SIZEX;
  binc = (float) (velbar_ecolor[2] - bval + 1) / PIANO_DEFAULT_SIZEX;

  /* 128 steps for 128 levels of velocity */
  levelinc = 128.0 / PIANO_DEFAULT_SIZEX;

  /* draw a single line of the velocity bar */
  for (i = 0, i2 = 0; i < PIANO_DEFAULT_SIZEX; i++, i2 += 3)
    {
      velbar_linebuf[i2] = rval;
      velbar_linebuf[i2 + 1] = gval;
      velbar_linebuf[i2 + 2] = bval;

      if (lastlevel != (int) level)
	{
	  lastlevel = (int) level;
	  rval = (int) rf;
	  gval = (int) gf;
	  bval = (int) bf;
	}

      level += levelinc;
      rf += rinc;
      gf += ginc;
      bf += binc;
    }

  /* duplicate the line for each row */
  for (i = 0; i < PIANO_DEFAULT_SIZEY; i++)
    gtk_preview_draw_row (GTK_PREVIEW (pianospan_velbar), velbar_linebuf,
      0, i, PIANO_DEFAULT_SIZEX);
}

GtkWidget *
pianospan_create (void)
{
  GtkWidget *box_main, *vbox, *box;
  GtkWidget *view;
  GtkWidget *hscrollbar, *vscrollbar;
  GtkAdjustment *hadj, *vadj;

  /* main outer box */
  box_main = gtk_hbox_new (FALSE, 0);
  gtk_widget_show (box_main);

  /* everything cept the vertical scrollbar goes in here */
  vbox = gtk_vbox_new (FALSE, 0);
  gtk_widget_show (vbox);
  gtk_box_pack_start (GTK_BOX (box_main), vbox, TRUE, TRUE, 0);

  /* horizontal scrollbar controls both viewports */
  hscrollbar = gtk_hscrollbar_new (NULL);
  gtk_widget_show (hscrollbar);
  hadj = gtk_range_get_adjustment (GTK_RANGE (hscrollbar));
  gtk_signal_connect (GTK_OBJECT (hadj), "changed",
    GTK_SIGNAL_FUNC (pianospan_cb_scrollbar_automatic), hscrollbar);

  /* piano viewport */
  view = gtk_viewport_new (NULL, NULL);
  gtk_viewport_set_hadjustment (GTK_VIEWPORT (view), GTK_ADJUSTMENT (hadj));
  gtk_container_border_width (GTK_CONTAINER (view), 0);
  gtk_viewport_set_shadow_type (GTK_VIEWPORT (view), GTK_SHADOW_OUT);
  gtk_widget_show (GTK_WIDGET (view));
  gtk_box_pack_start (GTK_BOX (vbox), view, FALSE, FALSE, 0);

  pianospan_view_box = gtk_vbox_new (FALSE, 0);
  gtk_widget_show (GTK_WIDGET (pianospan_view_box));
  gtk_container_add (GTK_CONTAINER (view), pianospan_view_box);

  pianospan_ptrstrip = ptrstrip_new ();
  gtk_widget_set_usize (pianospan_ptrstrip, PIANO_DEFAULT_SIZEX, -1);
  ptrstrip_new_pointer (PTRSTRIP (pianospan_ptrstrip), -1);
  gtk_signal_connect (GTK_OBJECT (pianospan_ptrstrip), "pointer_change",
    (GtkSignalFunc) pianospan_cb_ptrstrip_change, NULL);
  gtk_widget_show (pianospan_ptrstrip);
  gtk_box_pack_start (GTK_BOX (pianospan_view_box), pianospan_ptrstrip,
    FALSE, FALSE, 0);

  /* create the piano widget */
  uipiano_create ();
  gtk_widget_show (uipiano_widg);
  gtk_box_pack_start (GTK_BOX (pianospan_view_box), uipiano_widg,
    FALSE, FALSE, 0);

  /* create box to pack preview in so it stays left justified */
  pianospan_velbar_box = gtk_hbox_new (FALSE, 0);
  /* ref velocity bar box cuz we ain't packin' it now */
  gtk_widget_ref (pianospan_velbar_box);
  gtk_widget_show (pianospan_velbar_box);

  /* create the velocity widget */
  pianospan_velbar = gtk_preview_new (GTK_PREVIEW_COLOR);
  gtk_preview_size (GTK_PREVIEW (pianospan_velbar), PIANO_DEFAULT_SIZEX,
    PIANO_DEFAULT_SIZEY);
  gtk_preview_set_expand (GTK_PREVIEW (pianospan_velbar), FALSE);

  /* load velocity bar start and end colors from preferences */
  if (!smurfcfg_parse_hashcolor (smurfcfg_get_val (SMURFCFG_VELBAR_SCOLOR)->
      v_string, velbar_scolor))
    {
      velbar_scolor[0] = 0;
      velbar_scolor[1] = 0;
      velbar_scolor[2] = 0x40;
    }
  if (!smurfcfg_parse_hashcolor (smurfcfg_get_val (SMURFCFG_VELBAR_ECOLOR)->
      v_string, velbar_ecolor))
    {
      velbar_ecolor[0] = 0;
      velbar_ecolor[1] = 0;
      velbar_ecolor[2] = 0xFF;
    }

  /* allocate buffer space for one line of velocity bar */
  velbar_linebuf = g_new (guchar, PIANO_DEFAULT_SIZEX * 3);
  pianospan_draw_velocity_bar ();
  gtk_widget_show (pianospan_velbar);
  gtk_box_pack_start (GTK_BOX (pianospan_velbar_box), pianospan_velbar,
    FALSE, FALSE, 0);

  /* vertical scrollbar controls keyrange widget view only */
  vscrollbar = gtk_vscrollbar_new (NULL);
  gtk_widget_show (vscrollbar);
  vadj = GTK_RANGE (vscrollbar)->adjustment;
  gtk_signal_connect (GTK_OBJECT (vadj), "changed",
    GTK_SIGNAL_FUNC (pianospan_cb_scrollbar_automatic), vscrollbar);
  gtk_box_pack_start (GTK_BOX (box_main), vscrollbar, FALSE, FALSE, 0);

  /* keyrange viewport */
  view = gtk_viewport_new (NULL, vadj);
  gtk_widget_set_usize (view, KEYSPAN_DEFAULT_SIZEX, 0);

  gtk_signal_connect (GTK_OBJECT (hadj), "value_changed",
    GTK_SIGNAL_FUNC (pianospan_cb_piano_vel_range_hadj),
    (gpointer) gtk_viewport_get_hadjustment (GTK_VIEWPORT (view)));

  gtk_container_border_width (GTK_CONTAINER (view), 0);
  gtk_viewport_set_shadow_type (GTK_VIEWPORT (view), GTK_SHADOW_IN);
  gtk_widget_show (GTK_WIDGET (view));

  pianospan_keyrange_box = box = gtk_vbox_new (FALSE, 0);
  gtk_widget_show (box);
  gtk_container_add (GTK_CONTAINER (view), box);

  gtk_box_pack_start (GTK_BOX (vbox), view, TRUE, TRUE, 0);
  gtk_box_pack_start (GTK_BOX (vbox), hscrollbar, FALSE, FALSE, 0);

  pianospan_spans = g_ptr_array_new ();

  return (box_main);
}