/*****************************************************************************

   envy24control.c - Env24 chipset (ICE1712) control utility

   Copyright (C) 2000 by Jaroslav Kysela <perex@perex.cz>

   (2003/03/22) Changed to hbox/vbox layout.

   Copyright (C) 2003 by Søren Wedel Nielsen

   (16.12.2005)  Re-worked user interface -digital mixer display permanently

   visible; pcms split to another page; controls re-arranged and all pages

   scrollable for min window size and greater flexibility; pop-up menu enabled.

   Changes to levelmeters.c to prevent invalid redraws.

   New options added: 'w' to set initial window pixel width and 't' for tall equal mixer height style.

   Copyright (C) 2005 by Alan Horstmann

   This program is free software; you can redistribute it and/or

   modify it under the terms of the GNU General Public License

   as published by the Free Software Foundation; either version 2

   of the License, or (at your option) any later version.

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with this program; if not, write to the Free Software

   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

******************************************************************************/

#include "envy24control.h"

#include "midi.h"

#include "config.h"

#define _GNU_SOURCE

#include <getopt.h>

int input_channels, output_channels, pcm_output_channels, spdif_channels, view_spdif_playback, card_number;

int card_is_dmx6fire = FALSE, tall_equal_mixer_ht = 0;

char *profiles_file_name, *default_profile;

ice1712_eeprom_t card_eeprom;

snd_ctl_t *ctl;

GtkWidget *window;

GtkWidget *mixer_mix_drawing;

GtkWidget *mixer_clear_peaks_button;

GtkWidget *mixer_drawing[20];

GtkObject *mixer_adj[20][2];

GtkWidget *mixer_vscale[20][2];

GtkWidget *mixer_mute_toggle[20][2];

GtkWidget *mixer_stereo_toggle[20];

GtkWidget *router_radio[10][12];

//GtkWidget *hw_master_clock_xtal_radio;

GtkWidget *hw_master_clock_xtal_22050;

GtkWidget *hw_master_clock_xtal_32000;

GtkWidget *hw_master_clock_xtal_44100;

GtkWidget *hw_master_clock_xtal_48000;

GtkWidget *hw_master_clock_xtal_88200;

GtkWidget *hw_master_clock_xtal_96000;

GtkWidget *hw_master_clock_spdif_radio;

GtkWidget *hw_master_clock_word_radio;

GtkWidget *hw_master_clock_status_label;

GtkWidget *hw_master_clock_actual_rate_label;

GtkWidget *hw_clock_state_label;

GtkWidget *hw_clock_state_locked;

GtkWidget *hw_clock_state_reset;

GtkWidget *hw_rate_locking_check;

GtkWidget *hw_rate_reset_check;

GtkObject *hw_volume_change_adj;

GtkWidget *hw_volume_change_spin;

GtkWidget *hw_spdif_profi_nonaudio_radio;

GtkWidget *hw_spdif_profi_audio_radio;

GtkWidget *hw_profi_stream_stereo_radio;

GtkWidget *hw_profi_stream_notid_radio;

GtkWidget *hw_profi_emphasis_none_radio;

GtkWidget *hw_profi_emphasis_5015_radio;

GtkWidget *hw_profi_emphasis_ccitt_radio;

GtkWidget *hw_profi_emphasis_notid_radio;

GtkWidget *hw_consumer_copyright_on_radio;

GtkWidget *hw_consumer_copyright_off_radio;

GtkWidget *hw_consumer_copy_1st_radio;

GtkWidget *hw_consumer_copy_original_radio;

GtkWidget *hw_consumer_emphasis_none_radio;

GtkWidget *hw_consumer_emphasis_5015_radio;

GtkWidget *hw_consumer_category_dat_radio;

GtkWidget *hw_consumer_category_pcm_radio;

GtkWidget *hw_consumer_category_cd_radio;

GtkWidget *hw_consumer_category_general_radio;

GtkWidget *hw_spdif_professional_radio;

GtkWidget *hw_spdif_consumer_radio;

GtkWidget *hw_spdif_output_notebook;

GtkWidget *hw_spdif_input_coaxial_radio;

GtkWidget *hw_spdif_input_optical_radio;

GtkWidget *hw_spdif_switch_off_radio;

GtkWidget *input_interface_internal;

GtkWidget *input_interface_front_input;

GtkWidget *input_interface_rear_input;

GtkWidget *input_interface_wavetable;

GtkWidget *hw_phono_input_on_radio;

GtkWidget *hw_phono_input_off_radio;

GtkObject *av_dac_volume_adj[10];

GtkObject *av_adc_volume_adj[10];

GtkObject *av_ipga_volume_adj[10];

GtkLabel *av_dac_volume_label[10];

GtkLabel *av_adc_volume_label[10];

GtkLabel *av_ipga_volume_label[10];

GtkWidget *av_dac_sense_radio[10][4];

GtkWidget *av_adc_sense_radio[10][4];

struct profile_button {

	GtkWidget *toggle_button;

	GtkWidget *entry;

} profiles_toggle_buttons[MAX_PROFILES];

GtkWidget *active_button = NULL;

GtkObject *card_number_adj;

static void create_mixer_frame(GtkWidget *box, int stream)

{

	GtkWidget *vbox;

	GtkWidget *vbox1;

	GtkWidget *hbox;

	GtkWidget *frame;

	GtkObject *adj;

	GtkWidget *vscale;

	GtkWidget *drawing;

	GtkWidget *label;

	GtkWidget *toggle;

	char str[64], drawname[32];

	if (stream <= MAX_PCM_OUTPUT_CHANNELS) {

		sprintf(str, "PCM Out %i", stream);

	} else if (stream <= (MAX_PCM_OUTPUT_CHANNELS + MAX_SPDIF_CHANNELS)) {

		sprintf(str, "SPDIF Out %s", stream & 1 ? "L": "R");

	} else if (card_is_dmx6fire) {

		switch (stream) {

		case 11: sprintf(str, "CD In L");break;

		case 12: sprintf(str, "CD In R");break;

		case 13: sprintf(str, "Line In L");break;

		case 14: sprintf(str, "Line In R");break;

		case 15: sprintf(str, "Phono/Mic L");break;

		case 16: sprintf(str, "Phono/Mic R");break;

		case 19: sprintf(str, "Digital In L");break;

		case 20: sprintf(str, "Digital In R");break;

		default : sprintf(str, "????");break;

		}

	} else if (stream <= (MAX_PCM_OUTPUT_CHANNELS + MAX_SPDIF_CHANNELS + MAX_INPUT_CHANNELS)) {

		sprintf(str, "H/W In %i", stream - (MAX_PCM_OUTPUT_CHANNELS + MAX_SPDIF_CHANNELS));

	} else if (stream <= (MAX_PCM_OUTPUT_CHANNELS + MAX_SPDIF_CHANNELS + MAX_INPUT_CHANNELS + MAX_SPDIF_CHANNELS)) {

		sprintf(str, "SPDIF In %s", stream & 1 ? "L": "R");

	} else {

		strcpy(str, "???");

	}

	frame = gtk_frame_new(str);

	gtk_widget_show(frame);

	gtk_box_pack_start(GTK_BOX(box), frame, FALSE, TRUE, 0);

	gtk_container_set_border_width(GTK_CONTAINER(frame), 2);

	vbox = gtk_vbox_new(FALSE, 6);

	gtk_widget_show(vbox);

	gtk_container_add(GTK_CONTAINER(frame), vbox);

	gtk_container_set_border_width(GTK_CONTAINER(vbox), 2);

	hbox = gtk_hbox_new(FALSE, 2);

	gtk_widget_show(hbox);

	gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);

	adj = gtk_adjustment_new(96, 0, 96, 1, 16, 0);

	mixer_adj[stream-1][0] = adj;

	vscale = gtk_vscale_new(GTK_ADJUSTMENT(adj));

	mixer_vscale[stream-1][0] = vscale;

        gtk_widget_show(vscale);

	gtk_box_pack_start(GTK_BOX(hbox), vscale, TRUE, FALSE, 0);

	gtk_scale_set_value_pos(GTK_SCALE(vscale), GTK_POS_BOTTOM);

	gtk_scale_set_digits(GTK_SCALE(vscale), 0);

	gtk_signal_connect(GTK_OBJECT(adj), "value_changed",

			   GTK_SIGNAL_FUNC(mixer_adjust),

			   (gpointer)(long)((stream << 16) + 0));

	vbox1 = gtk_vbox_new(FALSE, 0);

	gtk_widget_show(vbox1);

	gtk_box_pack_start(GTK_BOX(hbox), vbox1, FALSE, FALSE, 0);

	drawing = gtk_drawing_area_new();

	mixer_drawing[stream-1] = drawing;

	sprintf(drawname, "Mixer%i", stream);

	gtk_widget_set_name(drawing, drawname);

	gtk_widget_show(drawing);

	gtk_signal_connect(GTK_OBJECT(drawing), "expose_event",

			   GTK_SIGNAL_FUNC(level_meters_expose_event), NULL);

	gtk_signal_connect(GTK_OBJECT(drawing), "configure_event",

			   GTK_SIGNAL_FUNC(level_meters_configure_event), NULL);

	gtk_widget_set_events(drawing, GDK_EXPOSURE_MASK);

	gtk_widget_set_usize(drawing, 36, (60 * tall_equal_mixer_ht + 204));

	gtk_box_pack_start(GTK_BOX(vbox1), drawing, FALSE, FALSE, 1);

	label = gtk_label_new("");

	gtk_widget_show(label);

	gtk_box_pack_start(GTK_BOX(vbox1), label, TRUE, TRUE, 2);

	adj = gtk_adjustment_new(96, 0, 96, 1, 16, 0);

	mixer_adj[stream-1][1] = adj;

	vscale = gtk_vscale_new(GTK_ADJUSTMENT(adj));

	mixer_vscale[stream-1][1] = vscale;

        gtk_widget_show(vscale);

	gtk_box_pack_start(GTK_BOX(hbox), vscale, TRUE, FALSE, 0);

	gtk_scale_set_value_pos(GTK_SCALE(vscale), GTK_POS_BOTTOM);

	gtk_scale_set_digits(GTK_SCALE(vscale), 0);

	gtk_signal_connect(GTK_OBJECT(adj), "value_changed",

			   GTK_SIGNAL_FUNC(mixer_adjust),

			   (gpointer)(long)((stream << 16) + 1));

	hbox = gtk_hbox_new(TRUE, 0);

	gtk_widget_show(hbox);

	gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, FALSE, 0);

	label = gtk_label_new("Left");

	gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);

	gtk_widget_show(label);

	gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, TRUE, 0);

	label = gtk_label_new("Right");

	gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5);

	gtk_widget_show(label);

	gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, TRUE, 0);

	toggle = gtk_toggle_button_new_with_label("L/R Gang");

	mixer_stereo_toggle[stream-1] = toggle;

	gtk_widget_show(toggle);

	gtk_box_pack_end(GTK_BOX(vbox), toggle, FALSE, FALSE, 0);

	/* gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toggle), TRUE); */

	gtk_signal_connect(GTK_OBJECT(toggle), "toggled",

			   GTK_SIGNAL_FUNC(config_set_stereo), (gpointer)stream-1);

	hbox = gtk_hbox_new(TRUE, 6);

	gtk_widget_show(hbox);

	gtk_box_pack_end(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);

	toggle = gtk_toggle_button_new_with_label("Mute");

	mixer_mute_toggle[stream-1][0] = toggle;

	gtk_widget_show(toggle);

	gtk_box_pack_start(GTK_BOX(hbox), toggle, FALSE, TRUE, 0);

	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toggle), TRUE);

	gtk_signal_connect(GTK_OBJECT(toggle), "toggled",

			   GTK_SIGNAL_FUNC(mixer_toggled_mute),

			   (gpointer)(long)((stream << 16) + 0));

	toggle = gtk_toggle_button_new_with_label("Mute");

	mixer_mute_toggle[stream-1][1] = toggle;

	gtk_widget_show(toggle);

	gtk_box_pack_start(GTK_BOX(hbox), toggle, FALSE, TRUE, 0);

	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toggle), TRUE);

	gtk_signal_connect(GTK_OBJECT(toggle), "toggled",

			   GTK_SIGNAL_FUNC(mixer_toggled_mute),

			   (gpointer)(long)((stream << 16) + 1));

}

static void create_inputs_mixer(GtkWidget *main, GtkWidget *notebook, int page)

{

        GtkWidget *hbox;

        GtkWidget *vbox;

	GtkWidget *label;

	GtkWidget *scrolledwindow;

	GtkWidget *viewport;

	int stream;

	hbox = gtk_hbox_new(FALSE, 3);

	gtk_widget_show(hbox);

	gtk_container_add(GTK_CONTAINER(notebook), hbox);

        label = gtk_label_new("Monitor Inputs");

        gtk_widget_show(label);

	gtk_notebook_set_tab_label(GTK_NOTEBOOK(notebook), 

				   gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook),page), 

				   label);

	/* build scrolling area */

	scrolledwindow = gtk_scrolled_window_new(NULL, NULL);

	gtk_widget_show(scrolledwindow);

	gtk_box_pack_start(GTK_BOX(hbox), scrolledwindow, TRUE, TRUE, 0);

	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow),

					GTK_POLICY_AUTOMATIC, GTK_POLICY_NEVER);

	viewport = gtk_viewport_new(NULL, NULL);

	gtk_widget_show(viewport);

	gtk_container_add(GTK_CONTAINER(scrolledwindow), viewport);

	vbox = gtk_vbox_new(FALSE, 0);

	gtk_widget_show(vbox);

	gtk_container_add(GTK_CONTAINER(viewport), vbox);

	hbox = gtk_hbox_new(FALSE, 0);

	gtk_widget_show(hbox);

	gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);

	for(stream = (MAX_PCM_OUTPUT_CHANNELS + MAX_SPDIF_CHANNELS + 1); \

		stream <= input_channels + (MAX_PCM_OUTPUT_CHANNELS + MAX_SPDIF_CHANNELS); stream ++) {

		if (mixer_stream_is_active(stream))

			create_mixer_frame(hbox, stream);

	}

	for(stream = (MAX_PCM_OUTPUT_CHANNELS + MAX_SPDIF_CHANNELS + MAX_INPUT_CHANNELS + 1); \

		stream <= spdif_channels + (MAX_PCM_OUTPUT_CHANNELS + MAX_SPDIF_CHANNELS + MAX_INPUT_CHANNELS); stream ++) {

		if (mixer_stream_is_active(stream))

			create_mixer_frame(hbox, stream);

	}

}

static void create_pcms_mixer(GtkWidget *main, GtkWidget *notebook, int page)

{

        GtkWidget *hbox;

        GtkWidget *vbox;

	GtkWidget *label;

	GtkWidget *scrolledwindow;

	GtkWidget *viewport;

	int stream;

	hbox = gtk_hbox_new(FALSE, 3);

	gtk_widget_show(hbox);

	gtk_container_add(GTK_CONTAINER(notebook), hbox);

        label = gtk_label_new("Monitor PCMs");

        gtk_widget_show(label);

	gtk_notebook_set_tab_label(GTK_NOTEBOOK(notebook),

				   gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook),page),

				   label);

	/* build scrolling area */

	scrolledwindow = gtk_scrolled_window_new(NULL, NULL);

	gtk_widget_show(scrolledwindow);

	gtk_box_pack_start(GTK_BOX(hbox), scrolledwindow, TRUE, TRUE, 0);

	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow), 

					GTK_POLICY_AUTOMATIC, GTK_POLICY_NEVER);

	viewport = gtk_viewport_new(NULL, NULL);

	gtk_widget_show(viewport);

	gtk_container_add(GTK_CONTAINER(scrolledwindow), viewport);

	vbox = gtk_vbox_new(FALSE, 0);

	gtk_widget_show(vbox);

	gtk_container_add(GTK_CONTAINER(viewport), vbox);

	hbox = gtk_hbox_new(FALSE, 0);

	gtk_widget_show(hbox);

	gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);

	for(stream = 1; stream <= pcm_output_channels; stream ++) {

		if (mixer_stream_is_active(stream))

			create_mixer_frame(hbox, stream);

	}

	for(stream = (MAX_PCM_OUTPUT_CHANNELS + 1); \

		stream <= spdif_channels + MAX_PCM_OUTPUT_CHANNELS; stream ++) {

		if (mixer_stream_is_active(stream) && view_spdif_playback)

			create_mixer_frame(hbox, stream);

	}

}

static void create_router_frame(GtkWidget *box, int stream, int pos)

{

	GtkWidget *vbox;

	GtkWidget *frame;

	GtkWidget *radiobutton;

	GtkWidget *label;

	GtkWidget *hseparator;

	GSList *group = NULL;

	char str[64], str1[64];

	int idx;

	static char *table[10] = {

		"S/PDIF In L",

		"S/PDIF In R",

		"H/W In 1",

		"H/W In 2",

		"H/W In 3",

		"H/W In 4",

		"H/W In 5",

		"H/W In 6",

		"H/W In 7",

		"H/W In 8"

	};

	if (card_is_dmx6fire)

	{

                table[0] = "Digital In L";

                table[1] = "Digital In R";

                table[2] = "CD In L";

                table[3] = "CD In R";

                table[4] = "Line In L";

                table[5] = "Line In R";

                table[6] = "Phono/Mic L";

                table[7] = "Phono/Mic R";

	}

	if (stream <= MAX_OUTPUT_CHANNELS) {

		sprintf(str, "H/W Out %i (%s)", stream, stream & 1 ? "L" : "R");

	} else if (stream == (MAX_OUTPUT_CHANNELS + 1)) {

		if (card_is_dmx6fire) {

				strcpy(str, "Digital Out (L)");

			} else {

				strcpy(str, "S/PDIF Out (L)");

				}

	} else if (stream == (MAX_OUTPUT_CHANNELS + 2)) {

		if (card_is_dmx6fire) {

				strcpy(str, "Digital Out (R)");

			} else {

				strcpy(str, "S/PDIF Out (R)");

				}

	} else {

		strcpy(str, "???");

		}

	if ((stream == MAX_PCM_OUTPUT_CHANNELS + 1) || (stream == MAX_PCM_OUTPUT_CHANNELS + 2)) {

		sprintf(str1, "S/PDIF Out (%s)", stream & 1 ? "L" : "R");

	} else { 

		sprintf(str1, "PCM Out %i", stream);

	}

	frame = gtk_frame_new(str);

	gtk_widget_show(frame);

	gtk_box_pack_start (GTK_BOX(box), frame, FALSE, FALSE, 0);

	gtk_container_set_border_width(GTK_CONTAINER(frame), 6);

	vbox = gtk_vbox_new(TRUE, 0);

	gtk_widget_show(vbox);

	gtk_container_add(GTK_CONTAINER(frame), vbox);

	gtk_container_set_border_width(GTK_CONTAINER(vbox), 6);

	radiobutton = gtk_radio_button_new_with_label(group, str1);

	router_radio[stream-1][0] = radiobutton;

	group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));

	gtk_widget_show(radiobutton);

	gtk_box_pack_start(GTK_BOX(vbox), radiobutton, FALSE, FALSE, 0);

	gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",

			  (GtkSignalFunc)patchbay_toggled, 

			   (gpointer)(long)((stream << 16) + 0));

	hseparator = gtk_hseparator_new();

	gtk_widget_show(hseparator);

	gtk_box_pack_start(GTK_BOX(vbox), hseparator, FALSE, TRUE, 0);

	label = gtk_label_new("");

	gtk_widget_show(label);

	/* the digital mixer can only be routed to HW1/2 or SPDIF1/2 */

	if( (stream <= 2) /* hw1/2 */ ||

	    ((stream > MAX_OUTPUT_CHANNELS) && (stream <= MAX_OUTPUT_CHANNELS + 2)) /* spdif1/2 */

	    ) {

		radiobutton = gtk_radio_button_new_with_label(group, stream & 1 ? "Digital Mix L" : "Digital Mix R");

		router_radio[stream-1][1] = radiobutton;

		group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));

		gtk_widget_show(radiobutton);

		gtk_box_pack_start(GTK_BOX(vbox), 

				    radiobutton, FALSE, FALSE, 0);

		gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",

				  (GtkSignalFunc)patchbay_toggled, 

				   (gpointer)(long)((stream << 16) + 1));

	}

	else {

	  label = gtk_label_new("");

	  gtk_widget_show(label);

	  gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);

	}

	hseparator = gtk_hseparator_new();

	gtk_widget_show(hseparator);

	gtk_box_pack_start(GTK_BOX(vbox), hseparator, FALSE, TRUE, 0);

	for(idx = 2 - spdif_channels; idx < input_channels + 2; idx++) {

		radiobutton = gtk_radio_button_new_with_label(group, table[idx]);

		router_radio[stream-1][2+idx] = radiobutton;

		group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));

		gtk_widget_show(radiobutton);

		gtk_box_pack_start(GTK_BOX(vbox), 

				    radiobutton, FALSE, FALSE, 0);

		gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",

				  (GtkSignalFunc)patchbay_toggled, 

				   (gpointer)(long)((stream << 16) + 2 + idx));

	}

}

static void create_router(GtkWidget *main, GtkWidget *notebook, int page)

{

	GtkWidget *hbox;

	GtkWidget *label;

	GtkWidget *scrolledwindow;

	GtkWidget *viewport;

	int stream, pos;

	scrolledwindow = gtk_scrolled_window_new(NULL, NULL);

	gtk_widget_show(scrolledwindow);

	gtk_container_add(GTK_CONTAINER(notebook), scrolledwindow);

	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow), 

				       GTK_POLICY_AUTOMATIC, GTK_POLICY_NEVER);

        label = gtk_label_new("Patchbay / Router");

        gtk_widget_show(label);

	gtk_notebook_set_tab_label(GTK_NOTEBOOK(notebook), 

				   gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook), page), 

				   label);

	viewport = gtk_viewport_new(NULL, NULL);

	gtk_widget_show(viewport);

	gtk_container_add(GTK_CONTAINER(scrolledwindow), viewport);

	hbox = gtk_hbox_new(FALSE, 0);

	gtk_widget_show(hbox);

	gtk_container_add(GTK_CONTAINER(viewport), hbox);

	pos = 0;

	for (stream = 1; stream <= output_channels; stream++) {

		if (patchbay_stream_is_active(stream))

			create_router_frame(hbox, stream, pos++);

	}

	for (stream = MAX_OUTPUT_CHANNELS + 1; stream <= MAX_OUTPUT_CHANNELS + spdif_channels; stream++) {

		if (patchbay_stream_is_active(stream))

			create_router_frame(hbox, stream, pos++);

	}

}

static void create_master_clock(GtkWidget *box)

{

	GtkWidget *frame;

	GtkWidget *vbox;

	GtkWidget *radiobutton;

	GtkWidget *label;

	GSList *group = NULL;

	frame = gtk_frame_new("Master Clock");

	gtk_widget_show(frame);

	gtk_box_pack_start(GTK_BOX(box), frame, FALSE, FALSE, 4);

	vbox = gtk_vbox_new(FALSE, 0);

	gtk_widget_show(vbox);

	gtk_container_add(GTK_CONTAINER(frame), vbox);

	gtk_container_set_border_width(GTK_CONTAINER(vbox), 6);

	radiobutton = gtk_radio_button_new_with_label(group, "Int 22050");

	hw_master_clock_xtal_22050 = radiobutton;

	group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));

	gtk_widget_show(radiobutton);

	gtk_box_pack_start(GTK_BOX(vbox), radiobutton, FALSE, FALSE, 0);

	gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",

			  (GtkSignalFunc)internal_clock_toggled, 

			  (gpointer)"22050");

	radiobutton = gtk_radio_button_new_with_label(group, "Int 32000");

	hw_master_clock_xtal_32000 = radiobutton;

	group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));

	gtk_widget_show(radiobutton);

	gtk_box_pack_start(GTK_BOX(vbox), radiobutton, FALSE, FALSE, 0);

	gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",

			  (GtkSignalFunc)internal_clock_toggled, 

			  (gpointer)"32000");

	radiobutton = gtk_radio_button_new_with_label(group, "Int 44100");

	hw_master_clock_xtal_44100 = radiobutton;

	group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));

	gtk_widget_show(radiobutton);

	gtk_box_pack_start(GTK_BOX(vbox), radiobutton, FALSE, FALSE, 0);

	gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",

			  (GtkSignalFunc)internal_clock_toggled, 

			  (gpointer)"44100");

	radiobutton = gtk_radio_button_new_with_label(group, "Int 48000");

	hw_master_clock_xtal_48000 = radiobutton;

	group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));

	gtk_widget_show(radiobutton);

	gtk_box_pack_start(GTK_BOX(vbox), radiobutton, FALSE, FALSE, 0);

	gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",

			  (GtkSignalFunc)internal_clock_toggled, 

			  (gpointer)"48000");

	radiobutton = gtk_radio_button_new_with_label(group, "Int 88200");

	hw_master_clock_xtal_88200 = radiobutton;

	group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));

	gtk_widget_show(radiobutton);

	gtk_box_pack_start(GTK_BOX(vbox), radiobutton, FALSE, FALSE, 0);

	gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",

			  (GtkSignalFunc)internal_clock_toggled, 

			  (gpointer)"88200");

	radiobutton = gtk_radio_button_new_with_label(group, "Int 96000");

	hw_master_clock_xtal_96000 = radiobutton;

	group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));

	gtk_widget_show(radiobutton);

	gtk_box_pack_start(GTK_BOX(vbox), radiobutton, FALSE, FALSE, 0);

	gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",

			  (GtkSignalFunc)internal_clock_toggled, 

			  (gpointer)"96000");

	radiobutton = gtk_radio_button_new_with_label(group, "S/PDIF In");

	hw_master_clock_spdif_radio = radiobutton;

	group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));

	gtk_widget_show(radiobutton);

	gtk_box_pack_start(GTK_BOX(vbox), radiobutton, FALSE, FALSE, 0);

	gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",

			  (GtkSignalFunc)internal_clock_toggled, 

			  (gpointer)"SPDIF");

	if (card_eeprom.subvendor != ICE1712_SUBDEVICE_DELTA1010 &&

	    card_eeprom.subvendor != ICE1712_SUBDEVICE_DELTA1010LT)

		return;

	radiobutton = gtk_radio_button_new_with_label(group, "Word Clock");

	hw_master_clock_word_radio = radiobutton;

	group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));

	gtk_widget_show(radiobutton);

	gtk_box_pack_start(GTK_BOX(vbox), radiobutton, FALSE, FALSE, 0);

	gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",

			  (GtkSignalFunc)internal_clock_toggled, 

			  (gpointer)"WordClock");

        label = gtk_label_new("Locked");

        hw_master_clock_status_label = label;

        gtk_widget_show(label);

        gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, TRUE, 0);

}

static void create_rate_state(GtkWidget *box)

{

	GtkWidget *frame;

	GtkWidget *hbox;

	GtkWidget *check;

	frame = gtk_frame_new("Rate State");

	gtk_widget_show(frame);

	gtk_box_pack_start(GTK_BOX(box), frame, TRUE, TRUE, 0);

	hbox = gtk_hbox_new(TRUE, 0);

	gtk_widget_show(hbox);

	gtk_container_add(GTK_CONTAINER(frame), hbox);

	gtk_container_set_border_width(GTK_CONTAINER(hbox), 6);

	check = gtk_check_button_new_with_label("Locked");

	hw_rate_locking_check = check;

	gtk_widget_show(check);

	gtk_box_pack_start(GTK_BOX(hbox), check, FALSE, FALSE, 0);

	gtk_signal_connect(GTK_OBJECT(check), "toggled",

			  (GtkSignalFunc)rate_locking_toggled, 

			  (gpointer)"locked");

	check = gtk_check_button_new_with_label("Reset");

	hw_rate_reset_check = check;

	gtk_widget_show(check);

	gtk_box_pack_start(GTK_BOX(hbox), check, FALSE, FALSE, 0);

	gtk_signal_connect(GTK_OBJECT(check), "toggled",

			  (GtkSignalFunc)rate_reset_toggled, 

			  (gpointer)"reset");

}

static void create_actual_rate(GtkWidget *box)

{

	GtkWidget *frame;

	GtkWidget *label;

	frame = gtk_frame_new("Actual Rate");

	gtk_widget_show(frame);

	gtk_box_pack_start(GTK_BOX(box), frame, TRUE, TRUE, 0);

	label = gtk_label_new("");

	hw_master_clock_actual_rate_label = label;

	gtk_widget_show(label);

	gtk_container_add(GTK_CONTAINER(frame), label);

	gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT);

	gtk_misc_set_padding(GTK_MISC(label), 6, 6);

}

static void create_volume_change(GtkWidget *box)

{

	GtkWidget *frame;

	GtkWidget *hbox;

	GtkObject *spinbutton_adj;

	GtkWidget *spinbutton;

	GtkWidget *label;

	frame = gtk_frame_new("Volume Change");

	gtk_widget_show(frame);

	gtk_box_pack_start(GTK_BOX(box), frame, TRUE, TRUE, 0);

	hbox = gtk_hbox_new(FALSE, 0);

	gtk_widget_show(hbox);

	gtk_container_add(GTK_CONTAINER(frame), hbox);

	gtk_container_set_border_width(GTK_CONTAINER(hbox), 6);

	label = gtk_label_new("Rate");

	gtk_widget_show(label);

	gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, FALSE, 0);

	gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT);

	spinbutton_adj = gtk_adjustment_new(16, 0, 255, 1, 10, 10);

	hw_volume_change_adj = spinbutton_adj;

	spinbutton = gtk_spin_button_new(GTK_ADJUSTMENT(spinbutton_adj), 1, 0);

	gtk_widget_show(spinbutton);

	gtk_box_pack_start(GTK_BOX(hbox), spinbutton, TRUE, FALSE, 0);

	gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(spinbutton), TRUE);

	gtk_signal_connect(GTK_OBJECT(spinbutton_adj), "value_changed",

			   GTK_SIGNAL_FUNC(volume_change_rate_adj), NULL);

}

static void create_spdif_output_settings_profi_data(GtkWidget *box)

{

	GtkWidget *frame;

	GtkWidget *vbox;

	GtkWidget *radiobutton;

	GSList *group = NULL;

	frame = gtk_frame_new("Data Mode");

	gtk_widget_show(frame);

	gtk_box_pack_start(GTK_BOX(box), frame, FALSE, TRUE, 0);

	vbox = gtk_vbox_new(FALSE, 0);

	gtk_widget_show(vbox);

	gtk_container_add(GTK_CONTAINER(frame), vbox);

	gtk_container_set_border_width(GTK_CONTAINER(vbox), 6);

	radiobutton = gtk_radio_button_new_with_label(group, "Non-audio");

	hw_spdif_profi_nonaudio_radio = radiobutton;

	group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));

	gtk_widget_show(radiobutton);

	gtk_box_pack_start(GTK_BOX(vbox), radiobutton, FALSE, FALSE, 0);

	gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",

			  (GtkSignalFunc)profi_data_toggled, 

			  (gpointer)"Non-audio");

	radiobutton = gtk_radio_button_new_with_label(group, "Audio");

	hw_spdif_profi_audio_radio = radiobutton;

	group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));

	gtk_widget_show(radiobutton);

	gtk_box_pack_start(GTK_BOX(vbox), radiobutton, FALSE, FALSE, 0);

	gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",

			  (GtkSignalFunc)profi_data_toggled, 

			  (gpointer)"Audio");

}

static void create_spdif_output_settings_profi_stream(GtkWidget *box)

{

	GtkWidget *frame;

	GtkWidget *vbox;

	GtkWidget *radiobutton;

	GSList *group = NULL;

	frame = gtk_frame_new("Stream");

	gtk_widget_show(frame);

	gtk_box_pack_start(GTK_BOX(box), frame, FALSE, TRUE, 0);

	vbox = gtk_vbox_new(FALSE, 0);

	gtk_widget_show(vbox);

	gtk_container_add(GTK_CONTAINER(frame), vbox);

	gtk_container_set_border_width(GTK_CONTAINER(vbox), 6);

	radiobutton = gtk_radio_button_new_with_label(group, "Stereophonic");

	hw_profi_stream_stereo_radio = radiobutton;

	group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));

	gtk_widget_show(radiobutton);

	gtk_box_pack_start(GTK_BOX(vbox), radiobutton, FALSE, FALSE, 0);

	gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",

			  (GtkSignalFunc)profi_stream_toggled, 

			  (gpointer)"Stereo");

	radiobutton = gtk_radio_button_new_with_label(group, "Not indicated");

	hw_profi_stream_notid_radio = radiobutton;

	group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));

	gtk_widget_show(radiobutton);

	gtk_box_pack_start(GTK_BOX(vbox), radiobutton, FALSE, FALSE, 0);

	gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",

			  (GtkSignalFunc)profi_stream_toggled, 

			  (gpointer)"NOTID");

}

static void create_spdif_output_settings_profi_emphasis(GtkWidget *box)

{

	GtkWidget *frame;

	GtkWidget *vbox;

	GtkWidget *radiobutton;

	GSList *group = NULL;

	frame = gtk_frame_new("Emphasis");

	gtk_widget_show(frame);

	gtk_box_pack_start(GTK_BOX(box), frame, FALSE, TRUE, 0);

	vbox = gtk_vbox_new(FALSE, 0);

	gtk_widget_show(vbox);

	gtk_container_add(GTK_CONTAINER(frame), vbox);

	gtk_container_set_border_width(GTK_CONTAINER(vbox), 6);

	radiobutton = gtk_radio_button_new_with_label(group, "No emphasis");

	hw_profi_emphasis_none_radio = radiobutton;

	group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));

	gtk_widget_show(radiobutton);

	gtk_box_pack_start(GTK_BOX(vbox), radiobutton, FALSE, FALSE, 0);

	gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",

			  (GtkSignalFunc)profi_emphasis_toggled, 

			  (gpointer)"No");

	radiobutton = gtk_radio_button_new_with_label(group, "50/15us");

	hw_profi_emphasis_5015_radio = radiobutton;

	group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));

	gtk_widget_show(radiobutton);

	gtk_box_pack_start(GTK_BOX(vbox), radiobutton, FALSE, FALSE, 0);

	gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",

			  (GtkSignalFunc)profi_emphasis_toggled, 

			  (gpointer)"5015");

	radiobutton = gtk_radio_button_new_with_label(group, "CCITT J.17");

	hw_profi_emphasis_ccitt_radio = radiobutton;

	group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));

	gtk_widget_show(radiobutton);

	gtk_box_pack_start(GTK_BOX(vbox), radiobutton, FALSE, FALSE, 0);

	gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",

			  (GtkSignalFunc)profi_emphasis_toggled, 

			  (gpointer)"CCITT");

	radiobutton = gtk_radio_button_new_with_label(group, "Not indicated");

	hw_profi_emphasis_notid_radio = radiobutton;

	group = gtk_radio_button_group(GTK_RADIO_BUTTON(radiobutton));

	gtk_widget_show(radiobutton);

	gtk_box_pack_start(GTK_BOX(vbox), radiobutton, FALSE, FALSE, 0);

	gtk_signal_connect(GTK_OBJECT(radiobutton), "toggled",

			  (GtkSignalFunc)profi_emphasis_toggled, 

			  (gpointer)"NOTID");

}

static void create_spdif_output_settings_profi(GtkWidget *notebook, int page)

{

	GtkWidget *hbox;

	GtkWidget *vbox;

	GtkWidget *label;

	hbox = gtk_hbox_new(FALSE, 0);

	gtk_widget_show(hbox);

	gtk_container_add(GTK_CONTAINER(notebook), hbox);

        label = gtk_label_new("Professional");

        gtk_widget_show(label);

	gtk_notebook_set_tab_label(GTK_NOTEBOOK(notebook), 

				   gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook), page),