plugin.c

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

	if (n_outlat) {
		for (k = 0; k < MAX_KNOBS && k < plugin->PortCount; ++k) {
			int max_height = 0;

			if (!LADSPA_IS_PORT_CONTROL(plugin->PortDescriptors[k]))
				continue;
			if (LADSPA_IS_PORT_INPUT(plugin->PortDescriptors[k]))
				continue;
			if (LADSPA_IS_HINT_TOGGLED(hints[k].HintDescriptor))
				continue;
			
			widget = gtk_label_new(plugin->PortNames[k]);
                        hbox = gtk_hbox_new(FALSE, 0);
                        gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, FALSE, 0);
			gtk_table_attach(GTK_TABLE(table), hbox, 0, 1, i, i+1,
					 GTK_FILL, GTK_FILL | GTK_EXPAND, 2, 2);
			gtk_widget_size_request(widget, &req);
			req.height += 2;
			if (req.width > max_width)
				max_width = req.width;
			if (req.height > max_height)
				max_height = req.height;

			if (LADSPA_IS_HINT_SAMPLE_RATE(hints[k].HintDescriptor)) {
				fact = out_SR;
			} else {
				fact = 1.0f;
			}
			
			if (LADSPA_IS_HINT_BOUNDED_BELOW(hints[k].HintDescriptor)) {
				min = hints[k].LowerBound * fact;
			} else {
				min = -10000.0f;
			}
			
			if (LADSPA_IS_HINT_BOUNDED_ABOVE(hints[k].HintDescriptor)) {
				max = hints[k].UpperBound * fact;
			} else {
				max = 10000.0f;
			}
			
			/* infinity */
			if (10000.0f <= max - min) {
				dp = 1;
				step = 5.0f;
				
			/* 100.0 ... lots */
			} else if (100.0f < max - min) {
				dp = 0;
				step = 1.0f;
				
			/* 10.0 ... 100.0 */
			} else if (10.0f < max - min) {
				dp = 1;
				step = 0.1f;
				
			/* 1.0 ... 10.0 */
			} else if (1.0f < max - min) {
				dp = 2;
				step = 0.01f;
				
			/* 0.0 ... 1.0 */
			} else {
				dp = 3;
				step = 0.001f;
			}
			
			if (LADSPA_IS_HINT_INTEGER(hints[k].HintDescriptor)) {
				dp = 0;
				if (step < 1.0f) step = 1.0f;
			}
			
			if (LADSPA_IS_HINT_DEFAULT_MINIMUM(hints[k].HintDescriptor)) {
				start = min;
			} else if (LADSPA_IS_HINT_DEFAULT_LOW(hints[k].HintDescriptor)) {
				start = min * 0.75f + max * 0.25f;
			} else if (LADSPA_IS_HINT_DEFAULT_MIDDLE(hints[k].HintDescriptor)) {
				start = min * 0.5f + max * 0.5f;
			} else if (LADSPA_IS_HINT_DEFAULT_HIGH(hints[k].HintDescriptor)) {
				start = min * 0.25f + max * 0.75f;
			} else if (LADSPA_IS_HINT_DEFAULT_MAXIMUM(hints[k].HintDescriptor)) {
				start = max;
			} else if (LADSPA_IS_HINT_DEFAULT_0(hints[k].HintDescriptor)) {
				start = 0.0f;
			} else if (LADSPA_IS_HINT_DEFAULT_1(hints[k].HintDescriptor)) {
				start = 1.0f;
			} else if (LADSPA_IS_HINT_DEFAULT_100(hints[k].HintDescriptor)) {
				start = 100.0f;
			} else if (LADSPA_IS_HINT_DEFAULT_440(hints[k].HintDescriptor)) {
				start = 440.0f;
			} else if (LADSPA_IS_HINT_INTEGER(hints[k].HintDescriptor)) {
				start = min;
			} else if (max >= 0.0f && min <= 0.0f) {
				start = 0.0f;
			} else {
				start = min * 0.5f + max * 0.5f;
			}
			
			instance->knobs[k] = start;
			
			adjustment = gtk_adjustment_new(start, min, max, step, step * 50.0, 0.0);
			instance->adjustments[k] = GTK_ADJUSTMENT(adjustment);
			
			if (!LADSPA_IS_HINT_INTEGER(hints[k].HintDescriptor)) {
				widget = gtk_hscale_new(GTK_ADJUSTMENT(adjustment));
				gtk_widget_set_name(widget, "plugin_scale");
				gtk_widget_set_size_request(widget, 200, -1);
				gtk_scale_set_digits(GTK_SCALE(widget), dp);
				gtk_table_attach(GTK_TABLE(table), widget, 1, 2, i, i+1,
						 GTK_FILL | GTK_EXPAND, GTK_FILL, 2, 2);
				gtk_scale_set_draw_value(GTK_SCALE(widget), FALSE);
				gtk_widget_set_sensitive(widget, FALSE);
				gtk_widget_size_request(widget, &req);
				req.height += 2;
				if (req.height > max_height)
					max_height = req.height;
			}

			widget = gtk_spin_button_new(GTK_ADJUSTMENT(adjustment), step, dp);
			gtk_widget_set_size_request(widget, 70, -1);
			gtk_widget_set_sensitive(widget, FALSE);
			gtk_table_attach(GTK_TABLE(table), widget, 2, 3, i, i+1,
					 GTK_FILL, GTK_FILL, 2, 2);
			gtk_widget_size_request(widget, &req);
			req.height += 2;
			if (req.height > max_height)
				max_height = req.height;
			height += max_height;
			++i;
		}
	}


	if ((!n_toggled) && (!n_untoggled) && (!n_outctl) && (!n_outlat)) {
		widget = gtk_label_new("This LADSPA plugin has no user controls");
		gtk_box_pack_start(GTK_BOX(inner_vbox), widget, TRUE, TRUE, 2);
		gtk_widget_size_request(widget, &req);
		gtk_widget_set_size_request(scrwin, req.width + 20, req.height + 20);
	} else {
		gtk_widget_set_size_request(scrwin, (max_width + 280) * 1.1,
					    (height > 500) ? 500 : height * 1.1 + 10);
	}

	if ((n_outctl) || (n_outlat)) {
		instance->timeout = g_timeout_add(100, update_plugin_outputs, instance);
	} else {
		instance->timeout = 0;
	}

        set_active_state();

        g_signal_connect(G_OBJECT(instance->window), "delete_event", G_CALLBACK(close_plugin_window), NULL);
}


void
foreach_plugin_to_add(GtkTreeModel * model, GtkTreePath * path, GtkTreeIter * iter, gpointer data) {

	GtkTreeIter running_iter;
	int n_ins;
	int n_outs;
	char filename[MAXLEN];
	int index;
	char * str_n_ins;
	char * str_n_outs;
	char * str_filename;
	char * str_index;
	plugin_instance * instance;
	char bypassed_name[MAXLEN];
	

	gtk_tree_model_get(GTK_TREE_MODEL(avail_store), iter, 3, &str_n_ins,
			   4, &str_n_outs, 5, &str_filename, 6, &str_index, -1);
	
	sscanf(str_n_ins, "%d", &n_ins);
	sscanf(str_n_outs, "%d", &n_outs);
	strncpy(filename, str_filename, MAXLEN-1);
	sscanf(str_index, "%d", &index);
	
	if (((n_ins == 1) && (n_outs == 1)) ||
	    ((n_ins == 2) && (n_outs == 2))) {
		
		if (n_plugins >= MAX_PLUGINS) {
			fprintf(stderr,
				"Maximum number of running plugin instances (%d) reached; "
				"cannot add more.\n", MAX_PLUGINS);
			return;
		}
		instance = instantiate(filename, index);
		if (instance) {
			connect_port(instance);
			activate(instance);
			build_plugin_window(instance);
			
			get_bypassed_name(instance, bypassed_name);
			added_plugin = 1; /* so resort handler will not do any harm */
			gtk_list_store_append(running_store, &running_iter);
			gtk_list_store_set(running_store, &running_iter,
					   0, bypassed_name, 1, (gpointer)instance, -1);

			refresh_plugin_vect(1);
		}
	} else {
		fprintf(stderr,
			"cannot add %s:%d -- it has %d ins and %d outs.\n",
			filename, index, n_ins, n_outs);
	}
}


gint
add_clicked(GtkWidget * widget, GdkEvent * event, gpointer data) {

	gtk_tree_selection_selected_foreach(avail_select, foreach_plugin_to_add, NULL);

        set_active_state();
	return TRUE;
}


gint
remove_clicked(GtkWidget * widget, GdkEvent * event, gpointer data) {

	GtkTreeIter iter;
	gpointer gp_instance;
	plugin_instance * instance;

	if (gtk_tree_selection_get_selected(running_select, NULL, &iter)) {

                gtk_tree_model_get(GTK_TREE_MODEL(running_store), &iter, 1, &gp_instance, -1);
		gtk_list_store_remove(running_store, &iter);
		refresh_plugin_vect(-1);

		instance = (plugin_instance *) gp_instance;
		if (instance->handle) {
			if (instance->descriptor->deactivate) {
				instance->descriptor->deactivate(instance->handle);
			}
			instance->descriptor->cleanup(instance->handle);
			instance->handle = NULL;
		}
		if (instance->handle2) {
			if (instance->descriptor->deactivate) {
				instance->descriptor->deactivate(instance->handle2);
			}
			instance->descriptor->cleanup(instance->handle2);
			instance->handle2 = NULL;
		}
		if (instance->timeout)
			g_source_remove(instance->timeout);
		if (instance->window)
			gtk_widget_destroy(instance->window);

		trashlist_free(instance->trashlist);
		free(instance);
	}

        set_active_state();
        return TRUE;
}


gint
conf_clicked(GtkWidget * widget, GdkEvent * event, gpointer data) {

        GtkTreeIter iter;
        gpointer gp_instance;
        plugin_instance * instance;

        if (gtk_tree_selection_get_selected(running_select, NULL, &iter)) {

                gtk_tree_model_get(GTK_TREE_MODEL(running_store), &iter, 1, &gp_instance, -1);
                instance = (plugin_instance *) gp_instance;
		if (instance->window)
			gtk_widget_show_all(instance->window);
	}

	return TRUE;
}



gint
running_list_key_pressed(GtkWidget * widget, GdkEventKey * event) {

	switch (event->keyval) {
	case GDK_Delete:
	case GDK_KP_Delete:
		remove_clicked(NULL, NULL, NULL);
		return TRUE;
		break;
	}

	return FALSE;
}


gint
running_list_button_pressed(GtkWidget * widget, GdkEventButton * event) {

	GtkTreeIter iter;
        GtkTreePath * path;
        GtkTreeViewColumn * column;
	gpointer gp_instance;
	plugin_instance * instance;

	if (event->type == GDK_BUTTON_PRESS && event->button == 2) {

                if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(running_list), event->x, event->y,
                                                  &path, &column, NULL, NULL)) {

			gtk_tree_view_set_cursor(GTK_TREE_VIEW(running_list), path, NULL, FALSE);
			gtk_tree_selection_get_selected(running_select, NULL, &iter);

			gtk_tree_model_get(GTK_TREE_MODEL(running_store), &iter, 1, &gp_instance, -1);
			instance = (plugin_instance *) gp_instance;
			if (instance->bypass_button) {
				gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(instance->bypass_button),
				       !gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(
				               instance->bypass_button)));
			}
		}
	}

	if (event->type == GDK_2BUTTON_PRESS && event->button == 1) {
		conf_clicked(NULL, NULL, NULL);
	}

	if (event->type == GDK_BUTTON_PRESS && event->button == 3 &&
	    gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(running_store), &iter, NULL, 0)) {

		gtk_menu_popup(GTK_MENU(rp_menu), NULL, NULL, NULL, NULL,
			       event->button, event->time);
		return TRUE;
        }

	return FALSE;
}


gint
refresh_on_list_changed_cb(gpointer data) {

	refresh_plugin_vect(0);

	return FALSE;
}


void
running_list_row_inserted(GtkTreeModel * model, GtkTreePath * path, GtkTreeIter * iter) {

	if (added_plugin) {
		added_plugin = 0;
		return;
	}
	g_timeout_add(100, refresh_on_list_changed_cb, NULL);
}


gint
avail_key_pressed(GtkWidget * widget, GdkEventKey * event) {

	switch (event->keyval) {
	case GDK_a:
	case GDK_A:
		add_clicked(NULL, NULL, NULL);
		return TRUE;
		break;
	}

	return FALSE;
}


gint
avail_dblclicked(GtkWidget * widget, GdkEventButton * event) {

	if (event->type == GDK_2BUTTON_PRESS && event->button == 1) {
		add_clicked(NULL, NULL, NULL);
		return TRUE;
	}

	return FALSE;
}

void
set_all_plugins_status(gint status) {

        GtkTreeIter iter;
        gpointer gp_instance;
	plugin_instance * instance;
        int i = 0;

        if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(running_store), &iter)) {
		do {
			gtk_tree_model_get(GTK_TREE_MODEL(running_store), &iter, 1, &gp_instance, -1);
			instance = (plugin_instance *) gp_instance;
			if (instance->bypass_button) {
		
                                if (status != -1)
                                        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(instance->bypass_button), status);
                                else
                                        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(instance->bypass_button), 
                                                                     !gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(instance->bypass_button)));
                        }

                } while (i++, gtk_tree_model_iter_next(GTK_TREE_MODEL(running_store), &iter));
        }
}

void
rp__enable_all_cb(gpointer data) {

        set_all_plugins_status(FALSE);
}

void
rp__disable_all_cb(gpointer data) {

        set_all_plugins_status(TRUE);
}

void
rp__toggle_all_cb(gpointer data) {

        set_all_plugins_status(-1);
}

void
rp__clear_list_cb(gpointer data) {

        GtkTreeIter iter;
	gpointer gp_instance;
	plugin_instance * instance;
        int i = 0;