Guitar tuner

Before you start coding, you'll need to set up a new project in Anjuta. This will create all of the files you need to build and run the code later on. It's also useful for keeping everything together.

The code loads an (empty) window from the user interface description file and displays it. More details are given below; you may choose to skip this list if you understand the basics:

This code is ready to be used, so you can compile it by clicking Build ▸ Build Project (or press Shift+F7). When you do this, a dialog will appear. Change the Configuration to Default and then click Execute to configure the build directory. You only need to do this once, for the first build.

A description of the user interface (UI) is contained in the GtkBuilder file src/guitar_tuner.ui defined at the top of the class. To edit the user interface, open src/guitar_tuner.ui by double-clicking on it in the Project or Files section. This will switch to the interface designer. The design window is in the center; Widgets and the widget properties are on the right, and the Palette of available widgets is on the left.

The layout of every UI in GTK+ is organized using boxes and tables. Let's use a vertical GtkButtonBox here to assign six GtkButtons, one for each of the six guitar strings.

This section will show you how to create the code to produce sounds. GStreamer is GNOME's multimedia framework — you can use it for playing, recording, and processing video, audio, webcam streams and the like. Here, we'll be using it to produce single-frequency tones.

Conceptually, GStreamer works as follows: You create a pipeline containing several processing elements going from the source to the sink (output). The source can be an image file, a video, or a music file, for example, and the output could be a widget or the soundcard.

Between source and sink, you can apply various filters and converters to handle effects, format conversions and so on. Each element of the pipeline has properties which can be used to change its behaviour.

In this example we will use a tone generator source called audiotestsrc and send the output to the default system sound device, autoaudiosink. We only need to configure the frequency of the tone generator; this is accessible through the freq property of audiotestsrc.

We need to add a line to initialize GStreamer; put the following code on the line above the Gtk.init call in the main function:

Gst.init (ref args);

Then, copy the following function into guitar_tuner.vala inside our Main class:

Gst.Element sink;
Gst.Element source;
Gst.Pipeline pipeline;

private void play_sound(double frequency)
{
	pipeline = new Gst.Pipeline ("note");
	source   = Gst.ElementFactory.make ("audiotestsrc",
	                                    "source");
	sink     = Gst.ElementFactory.make ("autoaudiosink",
	                                    "output");

	/* set frequency */
	source.set ("freq", frequency);

	pipeline.add (source);
	pipeline.add (sink);
	source.link (sink);

	pipeline.set_state (Gst.State.PLAYING);

	/* stop it after 200ms */
	var time = new TimeoutSource(200);

	time.set_callback(() => {
		pipeline.set_state (Gst.State.NULL);
		return false;
	});
	time.attach(null);
}

In the UI designer, you made it so that all of the buttons will call the same function, on_button_clicked, when they are clicked. Actually we type main_on_button_clicked which tells the UI designer that this method is part of our Main. We need to add that function in the source file.

To do this, in the user interface file (guitar_tuner.ui) select one of the buttons by clicking on it, then open guitar_tuner.vala (by clicking on the tab in the center). Switch to the Signals tab on the right, which you used to set the signal name. Now take the row where you set the clicked signal and drag and drop it into to the source file at the beginning of the class. The following code will be added to your source file:

public void on_button_clicked (Gtk.Button sender) {

}

This signal handler has only one argument: the Gtk.Widget that called the function (in our case, always a Gtk.Button).

We want to play the correct sound when the user clicks a button. For this, we flesh out the signal handler which we defined above, on_button_clicked. We could have connected every button to a different signal handler, but that would lead to a lot of code duplication. Instead, we can use the label of the button to figure out which button was clicked:

public void on_button_clicked (Gtk.Button sender) {
	var label = sender.get_child () as Gtk.Label;
	switch (label.get_label()) {
		case "E":
			play_sound (329.63);
			break;
		case "A":
			play_sound (440);
			break;
		case "D":
			play_sound (587.33);
			break;
		case "G":
			play_sound (783.99);
			break;
		case "B":
			play_sound (987.77);
			break;
		case "e":
			play_sound (1318);
			break;
		default:
			break;
	}
}

The Gtk.Button that was clicked is passed as an argument (sender) to on_button_clicked. We can get the label of that button by using get_child, and then get the text from that label using get_label.

The switch statement compares the label text to the notes that we can play, and play_sound is called with the frequency appropriate for that note. This plays the tone; we have a working guitar tuner!

All of the code should now be ready to go. Click Build ▸ Build Project to build everything again, and then Run ▸ Execute to start the application.

If you haven't already done so, choose the Debug/src/guitar-tuner application in the dialog that appears. Finally, hit Run and enjoy!

If you run into problems with the tutorial, compare your code with this reference code.

To find out more about the Vala programming language you might want to check out the Vala Tutorial and the Vala API Documentation

Here are some ideas for how you can extend this simple demonstration: