plugin.c

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

        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);
                        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);
                        
                } while (i++, gtk_tree_model_iter_next(GTK_TREE_MODEL(running_store), &iter));

                gtk_list_store_clear(running_store);           
        }                                                            

        set_active_state();
}

void
create_fxbuilder(void) {

	GtkWidget * hbox;
	GtkWidget * vbox;
	GtkWidget * frame_avail;
	GtkWidget * viewport_avail;
	GtkWidget * scrolled_win_avail;

	GtkWidget * frame_running;
	GtkWidget * viewport_running;

	GtkWidget * hbox_buttons;

        GtkWidget * rp__enable_all;
        GtkWidget * rp__disable_all;
        GtkWidget * rp__toggle_all;
        GtkWidget * rp__separator1;
        GtkWidget * rp__separator2;
        GtkWidget * rp__clear_list;

        GtkCellRenderer * renderer;
        GtkTreeViewColumn * column;

        /* window creating stuff */
        fxbuilder_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
        gtk_window_set_title(GTK_WINDOW(fxbuilder_window), _("LADSPA patch builder"));
	gtk_window_set_position(GTK_WINDOW(fxbuilder_window), GTK_WIN_POS_CENTER);
        g_signal_connect(G_OBJECT(fxbuilder_window), "delete_event", G_CALLBACK(fxbuilder_close), NULL);
        g_signal_connect(G_OBJECT(fxbuilder_window), "key_press_event", G_CALLBACK(fxbuilder_key_pressed), NULL);
        gtk_container_set_border_width(GTK_CONTAINER(fxbuilder_window), 2);

	hbox = gtk_hbox_new(FALSE, 0);
        gtk_container_add(GTK_CONTAINER(fxbuilder_window), hbox);

        frame_avail = gtk_frame_new(_("Available plugins"));
        gtk_box_pack_start(GTK_BOX(hbox), frame_avail, TRUE, TRUE, 5);

	vbox = gtk_vbox_new(FALSE, 0);
        gtk_container_set_border_width(GTK_CONTAINER(vbox), 3);
        gtk_container_add(GTK_CONTAINER(frame_avail), vbox);

	viewport_avail = gtk_viewport_new(NULL, NULL);
        gtk_box_pack_start(GTK_BOX(vbox), viewport_avail, TRUE, TRUE, 3);
	
        add_button = gtk_button_new_from_stock (GTK_STOCK_ADD); 
        g_signal_connect(add_button, "clicked", G_CALLBACK(add_clicked), NULL);
        gtk_box_pack_start(GTK_BOX(vbox), add_button, FALSE, TRUE, 3);

	scrolled_win_avail = gtk_scrolled_window_new(NULL, NULL);
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_win_avail),
				       GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
	gtk_container_add(GTK_CONTAINER(viewport_avail), scrolled_win_avail);

	/* create store of available plugins */
	if (!avail_store) {
		avail_store = gtk_list_store_new(7,
						 G_TYPE_STRING,  /* 0: ID */
						 G_TYPE_STRING,  /* 1: Name */
						 G_TYPE_STRING,  /* 2: category */
						 G_TYPE_STRING,  /* 3: n_ins */
						 G_TYPE_STRING,  /* 4: n_outs */
						 G_TYPE_STRING,  /* 5: filename */
						 G_TYPE_STRING); /* 6: index */

		gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(avail_store), 1, GTK_SORT_ASCENDING);

		gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(avail_store), 0, compare_func,
						(gpointer) 0, NULL);
		gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(avail_store), 1, compare_func,
						(gpointer) 1, NULL);
		gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(avail_store), 2, compare_func,
						(gpointer) 2, NULL);
		gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(avail_store), 3, compare_func,
						(gpointer) 3, NULL);
		gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(avail_store), 4, compare_func,
						(gpointer) 4, NULL);

		/* fill avail_store with data */
		parse_lrdf_data();
		find_all_plugins();
	}


	avail_list = gtk_tree_view_new_with_model(GTK_TREE_MODEL(avail_store));
	gtk_tree_view_set_enable_search(GTK_TREE_VIEW(avail_list), FALSE);
        gtk_widget_set_size_request(avail_list, 400, 300);
	gtk_container_add(GTK_CONTAINER(scrolled_win_avail), avail_list);

        gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(avail_list), TRUE);

	g_signal_connect(G_OBJECT(avail_list), "key_press_event", G_CALLBACK(avail_key_pressed), NULL);
	g_signal_connect(G_OBJECT(avail_list), "button_press_event", G_CALLBACK(avail_dblclicked), NULL);


        avail_select = gtk_tree_view_get_selection(GTK_TREE_VIEW(avail_list));
        gtk_tree_selection_set_mode(avail_select, GTK_SELECTION_MULTIPLE);

	renderer = gtk_cell_renderer_text_new();

	column = gtk_tree_view_column_new_with_attributes(_("ID"), renderer, "text", 0, NULL);
	gtk_tree_view_column_set_resizable(GTK_TREE_VIEW_COLUMN(column), TRUE);
        gtk_tree_view_append_column(GTK_TREE_VIEW(avail_list), column);
	gtk_tree_view_column_set_sort_column_id(GTK_TREE_VIEW_COLUMN(column), 0);

        if (options.simple_view_in_fx)
                gtk_tree_view_column_set_visible(GTK_TREE_VIEW_COLUMN (column), FALSE);

	column = gtk_tree_view_column_new_with_attributes(_("Name"), renderer, "text", 1, NULL);
	gtk_tree_view_column_set_resizable(GTK_TREE_VIEW_COLUMN(column), TRUE);
        gtk_tree_view_append_column(GTK_TREE_VIEW(avail_list), column);
	gtk_tree_view_column_set_sort_column_id(GTK_TREE_VIEW_COLUMN(column), 1);

	column = gtk_tree_view_column_new_with_attributes(_("Category"), renderer, "text", 2, NULL);
	gtk_tree_view_column_set_resizable(GTK_TREE_VIEW_COLUMN(column), TRUE);
        gtk_tree_view_append_column(GTK_TREE_VIEW(avail_list), column);
	gtk_tree_view_column_set_sort_column_id(GTK_TREE_VIEW_COLUMN(column), 2);

        if (options.simple_view_in_fx)
                gtk_tree_view_column_set_visible(GTK_TREE_VIEW_COLUMN (column), FALSE);

	column = gtk_tree_view_column_new_with_attributes(_("Inputs"), renderer, "text", 3, NULL);
	gtk_tree_view_column_set_resizable(GTK_TREE_VIEW_COLUMN(column), TRUE);
        gtk_tree_view_append_column(GTK_TREE_VIEW(avail_list), column);
	gtk_tree_view_column_set_sort_column_id(GTK_TREE_VIEW_COLUMN(column), 3);
        
        if (options.simple_view_in_fx)
                gtk_tree_view_column_set_visible(GTK_TREE_VIEW_COLUMN (column), FALSE);

	column = gtk_tree_view_column_new_with_attributes(_("Outputs"), renderer, "text", 4, NULL);
	gtk_tree_view_column_set_resizable(GTK_TREE_VIEW_COLUMN(column), TRUE);
        gtk_tree_view_append_column(GTK_TREE_VIEW(avail_list), column);
	gtk_tree_view_column_set_sort_column_id(GTK_TREE_VIEW_COLUMN(column), 4);
        
        if (options.simple_view_in_fx)
                gtk_tree_view_column_set_visible(GTK_TREE_VIEW_COLUMN (column), FALSE);

        frame_running = gtk_frame_new(_("Running plugins"));
        gtk_box_pack_start(GTK_BOX(hbox), frame_running, TRUE, TRUE, 5);

	vbox = gtk_vbox_new(FALSE, 0);
        gtk_container_set_border_width(GTK_CONTAINER(vbox), 3);
        gtk_container_add(GTK_CONTAINER(frame_running), vbox);

	viewport_running = gtk_viewport_new(NULL, NULL);
        gtk_box_pack_start(GTK_BOX(vbox), viewport_running, TRUE, TRUE, 3);

	hbox_buttons = gtk_hbox_new(TRUE, 0);
	gtk_box_pack_start(GTK_BOX(vbox), hbox_buttons, FALSE, TRUE, 3);

        remove_button = gtk_button_new_from_stock (GTK_STOCK_REMOVE); 
        g_signal_connect(remove_button, "clicked", G_CALLBACK(remove_clicked), NULL);
	gtk_box_pack_start(GTK_BOX(hbox_buttons), remove_button, TRUE, TRUE, 0);

	conf_button = gui_stock_label_button(_("_Configure"), GTK_STOCK_PREFERENCES);
        g_signal_connect(conf_button, "clicked", G_CALLBACK(conf_clicked), NULL);
	gtk_box_pack_start(GTK_BOX(hbox_buttons), conf_button, TRUE, TRUE, 0);

	scrolled_win_running = gtk_scrolled_window_new(NULL, NULL);
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_win_running),
				       GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
	gtk_container_add(GTK_CONTAINER(viewport_running), scrolled_win_running);

	/* create store of running plugins */
	if (!running_store) {
		running_store = gtk_list_store_new(2,
						   G_TYPE_STRING,   /* Name */
						   G_TYPE_POINTER); /* instance */

		g_signal_connect(G_OBJECT(running_store), "row_inserted",
				 G_CALLBACK(running_list_row_inserted), NULL);
	}

	running_list = gtk_tree_view_new_with_model(GTK_TREE_MODEL(running_store));
        gtk_widget_set_size_request(running_list, 200, 300);
	gtk_container_add(GTK_CONTAINER(scrolled_win_running), running_list);

        gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(running_list), TRUE);
	gtk_tree_view_set_reorderable(GTK_TREE_VIEW(running_list), TRUE);

        g_signal_connect(G_OBJECT(running_list), "key_press_event",
			 G_CALLBACK(running_list_key_pressed), NULL);
        g_signal_connect(G_OBJECT(running_list), "button_press_event",
			 G_CALLBACK(running_list_button_pressed), NULL);
	

        running_select = gtk_tree_view_get_selection(GTK_TREE_VIEW(running_list));
        gtk_tree_selection_set_mode(running_select, GTK_SELECTION_SINGLE);

	renderer = gtk_cell_renderer_text_new();

	column = gtk_tree_view_column_new_with_attributes(_("Name"), renderer, "text", 0, NULL);
	gtk_tree_view_column_set_resizable(GTK_TREE_VIEW_COLUMN(column), TRUE);
        gtk_tree_view_append_column(GTK_TREE_VIEW(running_list), column);

        /* running plugins menu */

        rp_menu = gtk_menu_new();
                
	rp__enable_all = gtk_menu_item_new_with_label(_("Enable all plugins"));
	rp__disable_all = gtk_menu_item_new_with_label(_("Disable all plugins"));
	rp__separator1 = gtk_separator_menu_item_new();
	rp__toggle_all = gtk_menu_item_new_with_label(_("Invert current state"));
	rp__separator2 = gtk_separator_menu_item_new();
	rp__clear_list = gtk_menu_item_new_with_label(_("Clear list"));

	gtk_menu_shell_append(GTK_MENU_SHELL(rp_menu), rp__enable_all);
	gtk_menu_shell_append(GTK_MENU_SHELL(rp_menu), rp__disable_all);
	gtk_menu_shell_append(GTK_MENU_SHELL(rp_menu), rp__separator1);
	gtk_menu_shell_append(GTK_MENU_SHELL(rp_menu), rp__toggle_all);
	gtk_menu_shell_append(GTK_MENU_SHELL(rp_menu), rp__separator2);
	gtk_menu_shell_append(GTK_MENU_SHELL(rp_menu), rp__clear_list);

        g_signal_connect_swapped(G_OBJECT(rp__enable_all), "activate", G_CALLBACK(rp__enable_all_cb), NULL);
        g_signal_connect_swapped(G_OBJECT(rp__disable_all), "activate", G_CALLBACK(rp__disable_all_cb), NULL);
        g_signal_connect_swapped(G_OBJECT(rp__toggle_all), "activate", G_CALLBACK(rp__toggle_all_cb), NULL);
        g_signal_connect_swapped(G_OBJECT(rp__clear_list), "activate", G_CALLBACK(rp__clear_list_cb), NULL);

	gtk_widget_show(rp__enable_all);
	gtk_widget_show(rp__disable_all);
	gtk_widget_show(rp__separator1);
	gtk_widget_show(rp__toggle_all);
	gtk_widget_show(rp__separator2);
	gtk_widget_show(rp__clear_list);

}


void
save_plugin_data(void) {

        int i = 0;
	int k;
        GtkTreeIter iter;
        gpointer gp_instance;
	plugin_instance * instance;
        xmlDocPtr doc;
        xmlNodePtr root;
        xmlNodePtr plugin_node;
        xmlNodePtr port_node;
        char c, d;
        FILE * fin;
        FILE * fout;
        char tmpname[MAXLEN];
        char plugin_file[MAXLEN];
        char str[32];


        sprintf(plugin_file, "%s/plugin.xml", options.confdir);

        doc = xmlNewDoc((const xmlChar*) "1.0");
        root = xmlNewNode(NULL, (const xmlChar*) "aqualung_plugin");
        xmlDocSetRootElement(doc, root);

        while (gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(running_store), &iter, NULL, i)) {

                gtk_tree_model_get(GTK_TREE_MODEL(running_store), &iter, 1, &gp_instance, -1);
                instance = (plugin_instance *) gp_instance;

		plugin_node = xmlNewTextChild(root, NULL, (const xmlChar*) "plugin", NULL);

		xmlNewTextChild(plugin_node, NULL, (const xmlChar*) "filename", (xmlChar*) instance->filename);

		snprintf(str, 31, "%d", instance->index);
		xmlNewTextChild(plugin_node, NULL, (const xmlChar*) "index", (xmlChar*) str);

		snprintf(str, 31, "%d", instance->is_bypassed);
		xmlNewTextChild(plugin_node, NULL, (const xmlChar*) "is_bypassed", (xmlChar*) str);

                for (k = 0; k < MAX_KNOBS && k < instance->descriptor->PortCount; ++k) {

                        if (!LADSPA_IS_PORT_CONTROL(instance->descriptor->PortDescriptors[k]))
                                continue;
                        if (LADSPA_IS_PORT_OUTPUT(instance->descriptor->PortDescriptors[k]))
                                continue;

			port_node = xmlNewTextChild(plugin_node, NULL, (const xmlChar*) "port", NULL);

			snprintf(str, 31, "%d", k);
			xmlNewTextChild(port_node, NULL, (const xmlChar*) "index", (xmlChar*) str);

			snprintf(str, 31, "%f", instance->knobs[k]);
			xmlNewTextChild(port_node, NULL, (const xmlChar*) "value", (xmlChar*) str);
		}
                ++i;
        }

        sprintf(tmpname, "%s/plugin.xml.temp", options.confdir);
        xmlSaveFormatFile(tmpname, doc, 1);

        if ((fin = fopen(plugin_file, "rt")) == NULL) {
                fprintf(stderr, "Error opening file: %s\n", plugin_file);
                return;
        }
        if ((fout = fopen(tmpname, "rt")) == NULL) {
                fprintf(stderr, "Error opening file: %s\n", tmpname);
                return;
        }

        c = 0; d = 0;
        while (((c = fgetc(fin)) != EOF) && ((d = fgetc(fout)) != EOF)) {
                if (c != d) {
                        fclose(fin);
                        fclose(fout);
                        unlink(plugin_file);
                        rename(tmpname, plugin_file);
                        return;
                }
        }

        fclose(fin);
        fclose(fout);
        unlink(tmpname);
}


void
parse_plugin(xmlDocPtr doc, xmlNodePtr cur) {

        xmlChar * key;
	int k;
        char filename[MAXLEN];
        int index = -1;
        int is_bypassed;
	GtkTreeIter running_iter;
	plugin_instance * instance = NULL;
        char bypassed_name[MAXLEN];
        LADSPA_Data knobs[MAX_KNOBS];

        filename[0] = '\0';

        cur = cur->xmlChildrenNode;
        while (cur != NULL) {
                if ((!xmlStrcmp(cur->name, (const xmlChar *)"filename"))) {
                        key = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1);
                        if (key != NULL)
                                strncpy(filename, (char *) key, MAXLEN-1);
                        xmlFree(key);
                        if (filename[0] == '\0') {
                                fprintf(stderr, "Error in XML aqualung_plugin: "
                                       "plugin <filename> is required, but NULL\n");
                        }
                } else if ((!xmlStrcmp(cur->name, (const xmlChar *)"index"))) {
                        key = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1);
                        if (key != NULL)
                                sscanf((char *) key, "%d", &index);
                        xmlFree(key);
                } else if ((!xmlStrcmp(cur->name, (const xmlChar *)"is_bypassed"))) {
                        key = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1);
                        if (key != NULL)
                                sscanf((char *) key, "%d", &is_bypassed);
                        xmlFree(key);
                } else if ((!xmlStrcmp(cur->name, (const xmlChar *)"port"))) {
			int port_index = -1;
			float port_value = 0.0f;
			xmlNodePtr port_node = cur->xmlChildrenNode;

			while (port_node != NULL) {
				if ((!xmlStrcmp(port_node->name, (const xmlChar *)"index"))) {
					key = xmlNodeListGetString(doc, port_node->xmlChildrenNode, 1);
					if (key != NULL)
						sscanf((char *) key, "%d", &port_index);
					xmlFree(key);
				} else if ((!xmlStrcmp(port_node->name, (const xmlChar *)"value"))) {
					key = xmlNodeListGetString(doc, port_node->xmlChildrenNode, 1);
					if (key != NULL)
						sscanf((char *) key, "%f", &port_value);
					xmlFree(key);
				}
				port_node = port_node->next;
			}

			if ((port_index >= 0) && (port_index < MAX_KNOBS)) {
				knobs[port_index] = port_value;
			}
                }
                cur = cur->next;
        }

	
	if ((filename[0] != '\0') && (index >= 0)) { /* create plugin, restore settings */
		
		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);
			for (k = 0; k < MAX_KNOBS && k < instance->descriptor->PortCount; ++k) {
				if (!LADSPA_IS_PORT_CONTROL(instance->descriptor->PortDescriptors[k]))