ports.c

Aqualung is an advanced music player primarily targeted for the GNU/Linux operating system, but als

/*                                                     -*- linux-c -*-
    Copyright (C) 2004 Tom Szilagyi

    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., 675 Mass Ave, Cambridge, MA 02139, USA.

    $Id: ports.c,v 1.5 2006/08/11 08:04:08 tszilagyi Exp $
*/


#include <config.h>

#ifdef HAVE_JACK

#include <errno.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <gtk/gtk.h>
#include <jack/jack.h>

#include "common.h"
#include "i18n.h"
#include "ports.h"


#define LIST_WIDTH 200
#define LIST_HEIGHT 100


extern GtkWidget* gui_stock_label_button(gchar *blabel, const gchar *bstock);

extern GtkWidget * main_window;

/* JACK data */
extern jack_port_t * out_L_port;
extern jack_port_t * out_R_port;
extern jack_client_t * jack_client;

GtkWidget * ports_window = NULL;
GtkWidget * nb_outs;
GtkWidget * nb_out_labels[MAX_JACK_CLIENTS];

GtkWidget * vbox_dl; /* down-left */
GtkWidget * vbox_dr; /* down-right */

GtkWidget * tree_out_L;
GtkWidget * tree_out_R;
GtkListStore * store_out_L;
GtkListStore * store_out_R;
GtkTreeViewColumn * column_out_L;
GtkTreeViewColumn * column_out_R;

int n_clients;
GtkListStore * store_out_nb[MAX_JACK_CLIENTS];

gint timeout_tag;

int out_selector = 0;


void scan_connections(jack_port_t * port, GtkListStore * store);
void setup_notebook_out(void);



gint
ports_timeout_callback(gpointer data) {

	switch((int)data) {
	case 1:
		gtk_list_store_clear(store_out_L);
		scan_connections(out_L_port, store_out_L);
		break;
	case 2:
		gtk_list_store_clear(store_out_R);
		scan_connections(out_R_port, store_out_R);
		break;
	}
	return 0;
}


int
port_window_close(GtkWidget *widget, gpointer * data) {

	ports_window = NULL;
	return 0;
}


void
clicked_rescan(GtkWidget * widget, gpointer * data) {

	gtk_list_store_clear(store_out_L);
	scan_connections(out_L_port, store_out_L);
	gtk_list_store_clear(store_out_R);
	scan_connections(out_R_port, store_out_R);

	/* re-build notebook */
	gtk_widget_destroy(nb_outs);
	n_clients = 0;

	nb_outs = gtk_notebook_new();
        gtk_box_pack_start(GTK_BOX(vbox_dr), nb_outs, TRUE, TRUE, 2);
	setup_notebook_out();
        gtk_widget_show(nb_outs);
}


void
ports_clicked_close(GtkWidget * widget, gpointer * data) {

	gtk_widget_destroy(ports_window);
	ports_window = NULL;
}


void
set_active(GtkWidget * widget, int sel) {

	GdkColor color_normal;
	GdkColor color_active;
	GdkColor color_prelight;

	if (sel == 0) {
		color_normal.red = 40000;
		color_normal.green = 40000;
		color_normal.blue = 40000;

		color_active.red = 30000;
		color_active.green = 30000;
		color_active.blue = 30000;

		color_prelight.red = 50000;
		color_prelight.green = 50000;
		color_prelight.blue = 50000;

	} else {
		color_normal.red = 40000;
		color_normal.green = 40000;
		color_normal.blue = 65535;

		color_active.red = 30000;
		color_active.green = 30000;
		color_active.blue = 45000;

		color_prelight.red = 50000;
		color_prelight.green = 50000;
		color_prelight.blue = 65535;
	}
	gtk_widget_modify_bg(widget, GTK_STATE_NORMAL, &color_normal);
	gtk_widget_modify_bg(widget, GTK_STATE_ACTIVE, &color_active);
	gtk_widget_modify_bg(widget, GTK_STATE_PRELIGHT, &color_prelight);
}


void
clicked_out_L_header(GtkWidget * widget, gpointer * data) {

	out_selector = 0;
	set_active(GTK_WIDGET(column_out_L->button), 1);
	set_active(GTK_WIDGET(column_out_R->button), 0);
}


void
clicked_out_R_header(GtkWidget * widget, gpointer * data) {

	out_selector = 1;
	set_active(GTK_WIDGET(column_out_L->button), 0);
	set_active(GTK_WIDGET(column_out_R->button), 1);
}


void
tree_out_nb_selection_changed(GtkObject * tree, gpointer * data) {

	GtkTreeIter iter;
        GtkTreeModel * model;
	GtkTreeSelection * selection;
        gchar * str;
	const gchar * label;
	char fullname[MAXLEN];

	selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
        if (gtk_tree_selection_get_selected(selection, &model, &iter)) {

                gtk_tree_model_get(model, &iter, 0, &str, -1);
		label = gtk_label_get_text(GTK_LABEL(nb_out_labels[(int)data]));
		sprintf(fullname, "%s:%s", label, str);
		g_free(str);

		if (out_selector == 0) {
			if (jack_connect(jack_client, jack_port_name(out_L_port), fullname)) {
				fprintf(stderr, "Cannot connect %s to out_L. "
					"These ports are probably already connected.\n", fullname);
			} else {
				gtk_list_store_clear(store_out_L);
				scan_connections(out_L_port, store_out_L);
				out_selector = 1;
				set_active(GTK_WIDGET(column_out_L->button), 0);
				set_active(GTK_WIDGET(column_out_R->button), 1);
			}
		} else {
			if (jack_connect(jack_client, jack_port_name(out_R_port), fullname)) {
				fprintf(stderr, "Cannot connect %s to out_R. "
					"These ports are probably already connected.\n", fullname);
			} else {
				gtk_list_store_clear(store_out_R);
				scan_connections(out_R_port, store_out_R);
				out_selector = 0;
				set_active(GTK_WIDGET(column_out_L->button), 1);
				set_active(GTK_WIDGET(column_out_R->button), 0);
			}
		}
        }
}


void
tree_out_L_selection_changed(GtkTreeSelection * selection, gpointer * data) {

	GtkTreeIter iter;
        GtkTreeModel * model;
        gchar * str;
	int res;

        if (gtk_tree_selection_get_selected(selection, &model, &iter)) {

                gtk_tree_model_get(model, &iter, 0, &str, -1);
		if ((res = jack_disconnect(jack_client, jack_port_name(out_L_port), str)) != 0) {
			fprintf(stderr, "ERROR: jack_disconnect() returned %d\n", res);
		}
		g_free(str);
		timeout_tag = g_timeout_add(100, ports_timeout_callback, (gpointer)1);
        }
}


void
tree_out_R_selection_changed(GtkTreeSelection *selection, gpointer * data) {

	GtkTreeIter iter;
        GtkTreeModel * model;
        gchar * str;
	int res;

        if (gtk_tree_selection_get_selected(selection, &model, &iter)) {

                gtk_tree_model_get(model, &iter, 0, &str, -1);
		if ((res = jack_disconnect(jack_client, jack_port_name(out_R_port), str)) != 0) {
			fprintf(stderr, "ERROR: jack_disconnect() returned %d\n", res);
		}
		g_free(str);
		timeout_tag = g_timeout_add(100, ports_timeout_callback, (gpointer)2);
        }
}


void
clear_outs(GtkWidget * widget, gpointer * data) {

	const char ** ports;
	int i = 0;
	int res;

	ports = jack_port_get_connections(out_L_port);
	if (ports) {
		while (ports[i] != NULL) {
			if ((res = jack_disconnect(jack_client, jack_port_name(out_L_port), ports[i])) != 0) {
				fprintf(stderr, "ERROR: jack_disconnect() returned %d\n", res);
			}
			i++;
		}
		free(ports);
	}
	i = 0;
	ports = jack_port_get_connections(out_R_port);