Ticket #33: basic_plugin_browser.diff

File basic_plugin_browser.diff, 36.9 kB (added by kickback, 6 years ago)

patch (against revison 409 which is currently trunk) to demo the basic plugin browser (called from main and displayed in it's own window in lieu of a permanent framework to host it.))

  • src/plugin_browser.c

    old new  
     1/* 
     2 *  This program is free software; you can redistribute it and/or modify 
     3 *  it under the terms of the GNU General Public License as published by 
     4 *  the Free Software Foundation; either version 2 of the License, or 
     5 *  (at your option) any later version. 
     6 * 
     7 *  This program is distributed in the hope that it will be useful, 
     8 *  but WITHOUT ANY WARRANTY; without even the implied warranty of 
     9 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
     10 *  GNU General Public License for more details. 
     11 * 
     12 *  You should have received a copy of the GNU General Public License 
     13 *  along with this program; if not, write to the Free Software 
     14 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 
     15 */ 
     16  
     17/* copy plugin data from extern plugins now 
     18 * use liststore instead of plugins glist later? 
     19 */ 
     20  
     21#ifdef HAVE_CONFIG_H 
     22#  include <config.h> 
     23#endif 
     24 
     25#include <sys/types.h> 
     26#include <sys/stat.h> 
     27#include <unistd.h> 
     28#include <stdlib.h> 
     29#include <string.h> 
     30#include <stdio.h> 
     31#include <regex.h> 
     32 
     33#include <gdk/gdkkeysyms.h> 
     34#include <gtk/gtk.h> 
     35 
     36#include <sweep/sweep_i18n.h> 
     37#include <sweep/sweep_types.h> 
     38 
     39#include "plugin_browser.h" 
     40#include "plugin.h" 
     41#include "interface.h" 
     42  
     43enum 
     44{ 
     45        NAME_COLUMN, 
     46        N_IN_PORTS_COLUMN, 
     47        N_OUT_PORTS_COLUMN, 
     48        DESCRIPTION_COLUMN, 
     49        AUTHOR_COLUMN, 
     50        PROCESS_COLUMN, 
     51        BOOKMARKS_COLUMN, 
     52        BLACKLIST_COLUMN, 
     53        N_COLUMNS 
     54}; 
     55 
     56enum 
     57{ 
     58        QS_NAME_COLUMN, 
     59        QS_STRING_COLUMN, 
     60        QS_BLACK_COLUMN, 
     61        QS_BOOK_COLUMN, 
     62        QS_UNMARK_COLUMN, 
     63        QS_LADSPA_COLUMN, 
     64        QS_SWEEP_COLUMN, 
     65        QS_STEREO_COLUMN, 
     66        QS_MONO_COLUMN, 
     67        QS_N_COLUMNS 
     68}; 
     69 
     70enum 
     71{ 
     72        FILTER_TOGGLE_BOOKMARKED, 
     73        FILTER_TOGGLE_UNMARKED, 
     74    FILTER_TOGGLE_BLACKLISTED, 
     75    FILTER_TOGGLE_LADSPA, 
     76    FILTER_TOGGLE_SWEEP, 
     77    FILTER_TOGGLE_STEREO, 
     78    FILTER_TOGGLE_MONO 
     79}; 
     80 
     81struct _plugin_browser_filter { 
     82        GtkTreeModel * filter; 
     83        GtkListStore * plugins_list_store; 
     84        GtkListStore * qsearch_list_store; 
     85        GtkWidget * entry; 
     86        gchar * search_text; 
     87        regex_t * reg_buffer; 
     88    gboolean reg_dirty_flag; 
     89        gboolean hide_blacklisted; 
     90        gboolean hide_bookmarked; 
     91        gboolean hide_unmarked; 
     92        gboolean hide_ladspa; 
     93        gboolean hide_sweep; 
     94        gboolean hide_stereo; 
     95        gboolean hide_mono; 
     96 }; 
     97  
     98 gchar * quick_search_defaults []  = { 
     99         "Reverb¬verb¬0¬0¬0¬0¬0¬0¬0" 
     100         "Echo¬echo¬0¬0¬0¬0¬0¬0¬0" 
     101         "Amplifier¬amp¬0¬0¬0¬0¬0¬0¬0" 
     102         "Normalise¬normalise¬0¬0¬0¬0¬0¬0¬0" 
     103         "Delay¬delay¬0¬0¬0¬0¬0¬0¬0" 
     104         "Gate¬gate¬0¬0¬0¬0¬0¬0¬0" 
     105         "Dynamics¬ompres|dynam|sc[0-9]|maximiser¬0¬0¬0¬0¬0¬0¬0" 
     106         "Distortion¬distort|overd¬0¬0¬0¬0¬0¬0¬0" 
     107         "Oscillator¬osc¬0¬0¬0¬0¬0¬0¬0" 
     108         "Limiter¬limiter¬0¬0¬0¬0¬0¬0¬0" 
     109         "Phaser¬phaser¬0¬0¬0¬0¬0¬0¬0" 
     110         "Chorus¬chorus¬0¬0¬0¬0¬0¬0¬0" 
     111         "Flanger¬flanger¬0¬0¬0¬0¬0¬0¬0" 
     112         "Filter¬filter¬0¬0¬0¬0¬0¬0¬0" 
     113         "EQ¬eq¬0¬0¬0¬0¬0¬0¬0" 
     114         "Pitch¬pitch¬0¬0¬0¬0¬0¬0¬0"}; 
     115  
     116  
     117  
     118typedef struct _plugin_browser_filter plugin_browser_filter; 
     119         
     120static GtkWidget * setup_plugins_tree_view (plugin_browser_filter * pbf); 
     121static GtkWidget * setup_qsearch_tree_view(plugin_browser_filter * pbf); 
     122 
     123static gboolean filter_visible (GtkTreeModel *model, GtkTreeIter *iter, gpointer data); 
     124static void search_entry_cb (GtkWidget * entry, gpointer userdata); 
     125static void search_entry_clear_cb (GtkWidget * button, gpointer userdata); 
     126static void check_toggled (GtkCellRendererToggle *cell_renderer, 
     127                                gchar                 *path, 
     128                                gpointer               user_data, 
     129                                                                int column);  
     130static void check_bookmarks_toggled_cb (GtkCellRendererToggle *cell_renderer, 
     131                                gchar                 *path, 
     132                                gpointer               user_data); 
     133static void check_blacklist_toggled_cb (GtkCellRendererToggle *cell_renderer, 
     134                                gchar                 *path, 
     135                                gpointer               user_data); 
     136static void filter_button_toggled_cb(GtkWidget * toggle_button, gpointer user_data); 
     137static void entry_first_click_cb (GtkWidget * entry, GdkEventFocus *event, gpointer user_data); 
     138static void save_search_cb (GtkButton * button, gpointer user_data); 
     139static void qsearch_tree_selection_changed_cb (GtkTreeSelection *selection, gpointer data);               
     140static void delete_search_cb (GtkButton * button, gpointer user_data); 
     141 
     142extern GList * plugins; 
     143 
     144 
     145GtkWidget* 
     146create_plugin_browser_window (void) 
     147{ 
     148  GtkWidget *plugin_browser_window; 
     149  GtkWidget *hbox1; 
     150  GtkWidget *scrolledplugin_browser_window; 
     151  GtkWidget *treeview1; 
     152  GtkWidget *notebook1; 
     153  GtkWidget *hbox2; 
     154  GtkWidget *vbox2; 
     155  GtkWidget *frame1; 
     156  GtkWidget *label2; 
     157  GtkWidget *hbox4; 
     158  GtkWidget *frame2; 
     159  GtkWidget *alignment1; 
     160  GtkWidget *vbox4; 
     161  GtkWidget *scrolledwindow3; 
     162  GtkWidget *treeview4; 
     163  GtkWidget *hbox5; 
     164  GtkWidget *button15; 
     165  GtkWidget *button16; 
     166  GtkWidget *label3; 
     167  GtkWidget *frame3; 
     168  GtkWidget *vbox5; 
     169  GtkWidget *togglebutton1; 
     170  GtkWidget *togglebutton2; 
     171  GtkWidget *togglebutton3; 
     172  GtkWidget *togglebutton4; 
     173  GtkWidget *togglebutton5; 
     174  GtkWidget *togglebutton6; 
     175  GtkWidget *togglebutton7; 
     176  GtkWidget *label4; 
     177  GtkWidget *vbox1; 
     178  GtkWidget *scrolledwindow2; 
     179  GtkWidget *treeview3; 
     180  GtkWidget *hbox3; 
     181  GtkWidget *button1; 
     182  GtkWidget *image1; 
     183  GtkWidget *label1; 
     184  plugin_browser_filter *pbf; 
     185   
     186  re_set_syntax(RE_SYNTAX_POSIX_EXTENDED); 
     187 
     188 
     189  pbf = g_new0(plugin_browser_filter, 1); 
     190  pbf->search_text = ""; 
     191  pbf->reg_buffer = NULL; 
     192  pbf->hide_blacklisted = FALSE; 
     193  pbf->hide_bookmarked = FALSE; 
     194  pbf->hide_unmarked = FALSE; 
     195  pbf->hide_ladspa = FALSE; 
     196  pbf->hide_sweep = FALSE; 
     197  pbf->hide_stereo = FALSE; 
     198  pbf->hide_mono = FALSE; 
     199   
     200  plugin_browser_window = gtk_window_new (GTK_WINDOW_TOPLEVEL); 
     201  gtk_window_set_title (GTK_WINDOW (plugin_browser_window), _("Plugin Browser")); 
     202  sweep_set_window_icon(GTK_WINDOW(plugin_browser_window)); 
     203  //g_object_set_data(G_OBJECT(plugin_browser_window), "plugin_browser_filter", pbf); 
     204  treeview3 = setup_plugins_tree_view(pbf); 
     205 
     206  gtk_widget_set_size_request (plugin_browser_window, 830, 275); 
     207  gtk_window_set_title (GTK_WINDOW (plugin_browser_window), _("plugin_browser_window")); 
     208 
     209  hbox1 = gtk_hbox_new (FALSE, 0); 
     210  gtk_widget_show (hbox1); 
     211  //gtk_container_add (GTK_CONTAINER (plugin_browser_window), hbox1); 
     212 
     213  /*scrolledplugin_browser_window = gtk_scrolled_window_new (NULL, NULL); 
     214  gtk_widget_show (scrolledplugin_browser_window); 
     215  gtk_box_pack_start (GTK_BOX (hbox1), scrolledplugin_browser_window, FALSE, TRUE, 0); 
     216  gtk_widget_set_size_request (scrolledplugin_browser_window, 86, -1); 
     217  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledplugin_browser_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); 
     218 
     219  treeview1 = gtk_tree_view_new (); 
     220  gtk_widget_show (treeview1); 
     221  gtk_container_add (GTK_CONTAINER (scrolledplugin_browser_window), treeview1); 
     222  gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview1), FALSE); 
     223*/ 
     224  notebook1 = gtk_notebook_new (); 
     225  gtk_widget_show (notebook1); 
     226  gtk_container_set_border_width(notebook1, 5); 
     227  gtk_box_pack_start (GTK_BOX (hbox1), notebook1, TRUE, TRUE, 0); 
     228  GTK_WIDGET_UNSET_FLAGS (notebook1, GTK_CAN_FOCUS); 
     229  gtk_notebook_set_show_tabs (GTK_NOTEBOOK (notebook1), FALSE); 
     230  gtk_notebook_set_scrollable (GTK_NOTEBOOK (notebook1), TRUE); 
     231  gtk_notebook_set_show_border(GTK_NOTEBOOK(notebook1), TRUE); 
     232  hbox2 = gtk_hbox_new (FALSE, 0); 
     233  gtk_widget_show (hbox2); 
     234  gtk_container_add (GTK_CONTAINER (notebook1), hbox2); 
     235 
     236  vbox2 = gtk_vbox_new (FALSE, 0); 
     237  gtk_widget_show (vbox2); 
     238  gtk_box_pack_start (GTK_BOX (hbox2), vbox2, FALSE, TRUE, 3); 
     239  gtk_widget_set_size_request (vbox2, 253, -1); 
     240 
     241  frame1 = gtk_frame_new (NULL); 
     242  gtk_widget_show (frame1); 
     243  gtk_box_pack_start (GTK_BOX (vbox2), frame1, FALSE, FALSE, 0); 
     244  gtk_frame_set_shadow_type (GTK_FRAME (frame1), GTK_SHADOW_OUT); 
     245 
     246  label2 = gtk_label_new (_("<b>Display Filter Options</b>")); 
     247  gtk_widget_show (label2); 
     248  gtk_container_add (GTK_CONTAINER (frame1), label2); 
     249  gtk_label_set_use_markup (GTK_LABEL (label2), TRUE); 
     250  gtk_misc_set_padding (GTK_MISC (label2), 0, 3); 
     251 
     252  hbox4 = gtk_hbox_new (FALSE, 0); 
     253  gtk_widget_show (hbox4); 
     254  gtk_box_pack_start (GTK_BOX (vbox2), hbox4, TRUE, TRUE, 0); 
     255  gtk_widget_set_size_request (hbox4, 132, -1); 
     256 
     257  frame2 = gtk_frame_new (NULL); 
     258  gtk_widget_show (frame2); 
     259  gtk_box_pack_start (GTK_BOX (hbox4), frame2, TRUE, TRUE, 3); 
     260 
     261  alignment1 = gtk_alignment_new (0.5, 0.5, 1, 1); 
     262  gtk_widget_show (alignment1); 
     263  gtk_container_add (GTK_CONTAINER (frame2), alignment1); 
     264  gtk_alignment_set_padding (GTK_ALIGNMENT (alignment1), 4, 4, 6, 6); 
     265 
     266  vbox4 = gtk_vbox_new (FALSE, 0); 
     267  gtk_widget_show (vbox4); 
     268  gtk_container_add (GTK_CONTAINER (alignment1), vbox4); 
     269 
     270  scrolledwindow3 = gtk_scrolled_window_new (NULL, NULL); 
     271  gtk_widget_show (scrolledwindow3); 
     272  gtk_box_pack_start (GTK_BOX (vbox4), scrolledwindow3, TRUE, TRUE, 0); 
     273  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow3), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); 
     274  gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow3), GTK_SHADOW_IN); 
     275 
     276  treeview4 = setup_qsearch_tree_view(pbf); 
     277  gtk_widget_show (treeview4); 
     278  gtk_container_add (GTK_CONTAINER (scrolledwindow3), treeview4); 
     279 
     280  hbox5 = gtk_hbox_new (FALSE, 0); 
     281  gtk_widget_show (hbox5); 
     282  gtk_box_pack_start (GTK_BOX (vbox4), hbox5, FALSE, FALSE, 2); 
     283  gtk_container_set_border_width (GTK_CONTAINER (hbox5), 1); 
     284 
     285  button15 = gtk_button_new_with_mnemonic (_("Save")); 
     286  g_signal_connect(G_OBJECT(button15), "clicked", G_CALLBACK(save_search_cb), pbf); 
     287  gtk_widget_show (button15); 
     288  gtk_box_pack_start (GTK_BOX (hbox5), button15, FALSE, FALSE, 0); 
     289 
     290  button16 = gtk_button_new_with_mnemonic (_("Delete")); 
     291  g_signal_connect(G_OBJECT(button16), "clicked", G_CALLBACK(delete_search_cb), treeview4); 
     292  gtk_widget_show (button16); 
     293  gtk_box_pack_start (GTK_BOX (hbox5), button16, FALSE, FALSE, 0); 
     294 
     295  label3 = gtk_label_new (_("Quick Search")); 
     296  gtk_widget_show (label3); 
     297  gtk_frame_set_label_widget (GTK_FRAME (frame2), label3); 
     298  gtk_label_set_use_markup (GTK_LABEL (label3), TRUE); 
     299 
     300  frame3 = gtk_frame_new (NULL); 
     301  gtk_widget_show (frame3); 
     302  gtk_box_pack_start (GTK_BOX (hbox4), frame3, FALSE, FALSE, 1); 
     303 
     304  vbox5 = gtk_vbox_new (FALSE, 0); 
     305  gtk_widget_show (vbox5); 
     306  gtk_container_add (GTK_CONTAINER (frame3), vbox5); 
     307  gtk_container_set_border_width (GTK_CONTAINER (vbox5), 3); 
     308 
     309  togglebutton1 = gtk_toggle_button_new_with_mnemonic (_("Unmarked")); 
     310    g_object_set_data(G_OBJECT(togglebutton1), "which_toggle", 
     311          GINT_TO_POINTER(FILTER_TOGGLE_UNMARKED)); 
     312  gtk_widget_show (togglebutton1); 
     313  gtk_box_pack_start (GTK_BOX (vbox5), togglebutton1, FALSE, FALSE, 0); 
     314//sort this 
     315GtkWidget *tmp = gtk_image_new_from_stock ("gtk-yes", GTK_ICON_SIZE_MENU); 
     316  togglebutton2 = gtk_toggle_button_new_with_mnemonic (_("Bookmarked")); 
     317    g_object_set_data(G_OBJECT(togglebutton2), "which_toggle", 
     318          GINT_TO_POINTER(FILTER_TOGGLE_BOOKMARKED)); 
     319  GtkWidget *bookmark = gtk_image_new_from_stock ("gtk-about", GTK_ICON_SIZE_MENU); 
     320  gtk_button_set_image(GTK_BUTTON(togglebutton2), bookmark); 
     321  gtk_widget_show (togglebutton2); 
     322  gtk_box_pack_start (GTK_BOX (vbox5), togglebutton2, FALSE, FALSE, 0); 
     323 
     324  togglebutton3 = gtk_toggle_button_new_with_mnemonic (_("Blacklisted")); 
     325    g_object_set_data(G_OBJECT(togglebutton3), "which_toggle", 
     326          GINT_TO_POINTER(FILTER_TOGGLE_BLACKLISTED)); 
     327  GtkWidget *blacklist = gtk_image_new_from_stock ("gtk-stop", GTK_ICON_SIZE_MENU); 
     328  gtk_button_set_image(GTK_BUTTON(togglebutton3), blacklist); 
     329  gtk_widget_show (togglebutton3); 
     330  gtk_box_pack_start (GTK_BOX (vbox5), togglebutton3, FALSE, FALSE, 0); 
     331 
     332  togglebutton4 = gtk_toggle_button_new_with_mnemonic (_("LADSPA")); 
     333  g_object_set_data(G_OBJECT(togglebutton4), "which_toggle", 
     334          GINT_TO_POINTER(FILTER_TOGGLE_LADSPA)); 
     335tmp = gtk_image_new_from_stock ("gtk-yes", GTK_ICON_SIZE_MENU); 
     336 
     337  gtk_button_set_image(GTK_BUTTON(togglebutton4), tmp); 
     338  gtk_widget_show (togglebutton4); 
     339  gtk_box_pack_start (GTK_BOX (vbox5), togglebutton4, FALSE, FALSE, 0); 
     340 
     341  togglebutton5 = gtk_toggle_button_new_with_mnemonic (_("Sweep")); 
     342   g_object_set_data(G_OBJECT(togglebutton5), "which_toggle", 
     343          GINT_TO_POINTER(FILTER_TOGGLE_SWEEP)); 
     344          gtk_button_set_image(GTK_BUTTON(togglebutton5), tmp); 
     345  gtk_widget_show (togglebutton5); 
     346  gtk_box_pack_start (GTK_BOX (vbox5), togglebutton5, FALSE, FALSE, 0); 
     347 
     348  togglebutton6 = gtk_toggle_button_new_with_mnemonic (_("Mono")); 
     349   g_object_set_data(G_OBJECT(togglebutton6), "which_toggle", 
     350          GINT_TO_POINTER(FILTER_TOGGLE_MONO)); 
     351  gtk_widget_show (togglebutton6); 
     352  gtk_box_pack_start (GTK_BOX (vbox5), togglebutton6, FALSE, FALSE, 0); 
     353 
     354  togglebutton7 = gtk_toggle_button_new_with_mnemonic (_("Stereo")); 
     355    g_object_set_data(G_OBJECT(togglebutton7), "which_toggle", 
     356          GINT_TO_POINTER(FILTER_TOGGLE_STEREO)); 
     357  gtk_widget_show (togglebutton7); 
     358  gtk_box_pack_start (GTK_BOX (vbox5), togglebutton7, FALSE, FALSE, 0); 
     359 
     360  label4 = gtk_label_new (_("Hide Groups")); 
     361  gtk_widget_show (label4); 
     362  gtk_frame_set_label_widget (GTK_FRAME (frame3), label4); 
     363 
     364  vbox1 = gtk_vbox_new (FALSE, 0); 
     365  gtk_widget_show (vbox1); 
     366  gtk_box_pack_start (GTK_BOX (hbox2), vbox1, TRUE, TRUE, 0); 
     367 
     368  scrolledwindow2 = gtk_scrolled_window_new (NULL, NULL); 
     369  gtk_widget_show (scrolledwindow2); 
     370  gtk_box_pack_start (GTK_BOX (vbox1), scrolledwindow2, TRUE, TRUE, 0); 
     371  gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow2), GTK_SHADOW_IN); 
     372 
     373 
     374  gtk_widget_show (treeview3); 
     375  gtk_container_add (GTK_CONTAINER (scrolledwindow2), treeview3); 
     376  gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (treeview3), TRUE); 
     377 
     378  hbox3 = gtk_hbox_new (FALSE, 0); 
     379  gtk_widget_show (hbox3); 
     380  gtk_box_pack_start (GTK_BOX (vbox1), hbox3, FALSE, TRUE, 0); 
     381   
     382  pbf->entry = gtk_entry_new(); 
     383  button1 = gtk_button_new_with_mnemonic (_("Clear")); 
     384  g_signal_connect(G_OBJECT(button1), "clicked", G_CALLBACK(search_entry_clear_cb), pbf->entry); 
     385  gtk_widget_show (button1); 
     386  gtk_box_pack_end (GTK_BOX (hbox3), button1, FALSE, FALSE, 0); 
     387 
     388  image1 = gtk_image_new_from_icon_name ("gtk-find", GTK_ICON_SIZE_BUTTON); 
     389  gtk_widget_show (image1); 
     390  gtk_box_pack_start (GTK_BOX (hbox3), image1, FALSE, TRUE, 0); 
     391  gtk_misc_set_padding (GTK_MISC (image1), 4, 0); 
     392 
     393  
     394  gtk_widget_show (pbf->entry); 
     395  g_signal_connect(G_OBJECT(pbf->entry), "focus-in-event", G_CALLBACK(entry_first_click_cb), pbf); 
     396  gtk_box_pack_start (GTK_BOX (hbox3), pbf->entry, TRUE, TRUE, 0); 
     397  gtk_entry_set_text (GTK_ENTRY (pbf->entry), _("search")); 
     398 
     399  label1 = gtk_label_new (_("label1")); 
     400  gtk_widget_show (label1); 
     401  gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook1), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook1), 0), label1); 
     402 
     403  g_signal_connect(G_OBJECT(togglebutton1), "toggled", G_CALLBACK(filter_button_toggled_cb), pbf); 
     404  g_signal_connect(G_OBJECT(togglebutton2), "toggled", G_CALLBACK(filter_button_toggled_cb), pbf); 
     405  g_signal_connect(G_OBJECT(togglebutton3), "toggled", G_CALLBACK(filter_button_toggled_cb), pbf); 
     406  g_signal_connect(G_OBJECT(togglebutton4), "toggled", G_CALLBACK(filter_button_toggled_cb), pbf); 
     407  g_signal_connect(G_OBJECT(togglebutton5), "toggled", G_CALLBACK(filter_button_toggled_cb), pbf); 
     408  g_signal_connect(G_OBJECT(togglebutton6), "toggled", G_CALLBACK(filter_button_toggled_cb), pbf); 
     409  g_signal_connect(G_OBJECT(togglebutton7), "toggled", G_CALLBACK(filter_button_toggled_cb), pbf); 
     410  
     411  gtk_button_set_alignment (GTK_BUTTON(togglebutton1), 0.0, 0.5); 
     412  gtk_button_set_alignment (GTK_BUTTON(togglebutton2), 0.0, 0.5); 
     413  gtk_button_set_alignment (GTK_BUTTON(togglebutton3), 0.0, 0.5); 
     414  gtk_button_set_alignment (GTK_BUTTON(togglebutton4), 0.0, 0.5); 
     415  gtk_button_set_alignment (GTK_BUTTON(togglebutton5), 0.0, 0.5); 
     416  gtk_button_set_alignment (GTK_BUTTON(togglebutton6), 0.0, 0.5); 
     417  gtk_button_set_alignment (GTK_BUTTON(togglebutton7), 0.0, 0.5); 
     418 
     419  return hbox1; 
     420} 
     421 
     422/*      show "search" in the entry widget but don't connect entry to filter 
     423 *      until after widget has been focused and the text removed else "search" 
     424 *  will be used as a filter and no plugins will be shown at start up 
     425 */ 
     426static void entry_first_click_cb (GtkWidget * entry, GdkEventFocus *event, gpointer user_data) 
     427{ 
     428        plugin_browser_filter * pbf; 
     429         
     430        pbf = (plugin_browser_filter *)user_data; 
     431        g_signal_handlers_disconnect_by_func(entry, entry_first_click_cb, user_data); 
     432        gtk_entry_set_text(GTK_ENTRY(entry), ""); 
     433        pbf->search_text = (char *)gtk_entry_get_text(GTK_ENTRY(entry)); 
     434    g_signal_connect(G_OBJECT(entry), "changed", G_CALLBACK(search_entry_cb), pbf); 
     435} 
     436 
     437static GtkWidget * setup_qsearch_tree_view(plugin_browser_filter * pbf) 
     438{ 
     439        GtkWidget * tree; 
     440        GtkCellRenderer * renderer; 
     441        GtkTreeViewColumn * column; 
     442        GtkTreeSelection * select; 
     443         
     444        pbf->qsearch_list_store = gtk_list_store_new (QS_N_COLUMNS,      
     445                                                                                                        G_TYPE_STRING, /* name */ 
     446                                                                                                        G_TYPE_STRING, /* search string */ 
     447                                                                                                        G_TYPE_BOOLEAN, /* toggle blacklist */  
     448                                                                                                        G_TYPE_BOOLEAN, /* toggle bookmarks */ 
     449                                                                                                        G_TYPE_BOOLEAN, /* toggle unmarked */ 
     450                                                                                                        G_TYPE_BOOLEAN, /* toggle LADSPA */ 
     451                                                                                                        G_TYPE_BOOLEAN, /* toggle Sweep */ 
     452                                                                                                        G_TYPE_BOOLEAN, /* toggle stereo */ 
     453                                                                                                        G_TYPE_BOOLEAN); /* toggle mono */ 
     454 
     455        tree = gtk_tree_view_new_with_model (GTK_TREE_MODEL(pbf->qsearch_list_store)); 
     456        gtk_tree_view_set_headers_visible (GTK_TREE_VIEW(tree), FALSE); 
     457        g_object_unref (G_OBJECT (pbf->qsearch_list_store)); 
     458 
     459        renderer = gtk_cell_renderer_text_new (); 
     460    column = gtk_tree_view_column_new_with_attributes ("", renderer, 
     461                                                      "text", QS_NAME_COLUMN, 
     462                                                      NULL); 
     463        gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column); 
     464         
     465        select = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree)); 
     466        gtk_tree_selection_set_mode (select, GTK_SELECTION_SINGLE); 
     467        g_signal_connect (G_OBJECT (select), "changed", 
     468                  G_CALLBACK (qsearch_tree_selection_changed_cb), 
     469                  pbf);   
     470        gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE(pbf->qsearch_list_store), 
     471                                             QS_NAME_COLUMN, 
     472                                             GTK_SORT_ASCENDING);                  
     473        return tree; 
     474} 
     475 
     476static GtkWidget * setup_plugins_tree_view (plugin_browser_filter * pbf) 
     477{ 
     478        GList * gl; 
     479        sw_procedure * proc; 
     480        GtkTreeIter iter; 
     481    GtkWidget *tree; 
     482    GtkTreeViewColumn *column; 
     483    GtkCellRenderer *renderer; 
     484 
     485        GtkWidget *bookmark_icon, *blacklist_icon; 
     486     
     487        pbf->plugins_list_store = gtk_list_store_new (N_COLUMNS,        G_TYPE_STRING, /* name */ 
     488                                                                                                G_TYPE_INT, /* description */ 
     489                                                                                                G_TYPE_INT, /* author */ 
     490                                                                                                G_TYPE_STRING, /* number of input ports */ 
     491                                                                                                G_TYPE_STRING, /* number of output ports */ 
     492                                                                                                G_TYPE_INT,   /* process pointer */ 
     493                                                                                                G_TYPE_BOOLEAN,  /* bookmarked? */ 
     494                                                                                                G_TYPE_BOOLEAN); /* blacklisted? */ 
     495 
     496        for (gl = plugins; gl; gl = gl->next)  
     497        { 
     498        proc = (sw_procedure *)gl->data; 
     499 
     500                gtk_list_store_append (pbf->plugins_list_store, &iter); 
     501                gtk_list_store_set (pbf->plugins_list_store, &iter, 
     502                          NAME_COLUMN, proc->name, 
     503                          DESCRIPTION_COLUMN, proc->type, 
     504                          AUTHOR_COLUMN,  proc->author, 
     505                                                  N_IN_PORTS_COLUMN, proc->channels, 
     506                                                  N_OUT_PORTS_COLUMN,  5, 
     507                                                  PROCESS_COLUMN, proc, 
     508                                                  BOOKMARKS_COLUMN, FALSE, 
     509                                                  BLACKLIST_COLUMN, FALSE, 
     510                          -1); 
     511 
     512        } 
     513 
     514         
     515        pbf->filter = gtk_tree_model_filter_new (GTK_TREE_MODEL(pbf->plugins_list_store), NULL); 
     516        gtk_tree_model_filter_set_visible_func 
     517                                            (GTK_TREE_MODEL_FILTER(pbf->filter), 
     518                                             filter_visible, 
     519                                             pbf, 
     520                                             NULL); 
     521 
     522        tree = gtk_tree_view_new_with_model (GTK_TREE_MODEL (pbf->filter)); 
     523         
     524        g_object_unref (G_OBJECT (pbf->filter)); 
     525 
     526        bookmark_icon = gtk_image_new_from_stock ("gtk-about", GTK_ICON_SIZE_MENU); 
     527        gtk_widget_show(bookmark_icon); 
     528 
     529        blacklist_icon = gtk_image_new_from_stock ("gtk-stop", GTK_ICON_SIZE_MENU); 
     530                gtk_widget_show(blacklist_icon); 
     531 
     532        renderer = gtk_cell_renderer_text_new (); 
     533    column = gtk_tree_view_column_new_with_attributes ("Name", renderer, 
     534                                                      "text", NAME_COLUMN, 
     535                                                      NULL); 
     536        gtk_tree_view_column_set_resizable (column, TRUE); 
     537        gtk_tree_view_column_set_sort_column_id (column, NAME_COLUMN); 
     538        gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column); 
     539 
     540         
     541        renderer = gtk_cell_renderer_toggle_new (); 
     542        column = gtk_tree_view_column_new_with_attributes ("null", renderer, 
     543                                                      "active", BOOKMARKS_COLUMN, 
     544                                                      NULL); 
     545        gtk_tree_view_column_set_widget (column, bookmark_icon);                                                                                   
     546        gtk_tree_view_column_set_resizable (column, TRUE); 
     547        gtk_tree_view_column_set_clickable (column, TRUE); 
     548        gtk_tree_view_column_set_sort_column_id (column, BOOKMARKS_COLUMN);                                                        
     549        gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);      
     550        g_signal_connect(G_OBJECT(renderer), "toggled", G_CALLBACK(check_bookmarks_toggled_cb), pbf);    
     551         
     552        renderer = gtk_cell_renderer_toggle_new (); 
     553        column = gtk_tree_view_column_new_with_attributes ("B", renderer, 
     554                                                      "active", BLACKLIST_COLUMN, 
     555                                                      NULL); 
     556    gtk_tree_view_column_set_widget (column, blacklist_icon);                                                                      
     557        gtk_tree_view_column_set_resizable (column, TRUE); 
     558        gtk_tree_view_column_set_sort_column_id (column, BLACKLIST_COLUMN);                                                        
     559        gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);      
     560        g_signal_connect(G_OBJECT(renderer), "toggled", G_CALLBACK(check_blacklist_toggled_cb), pbf);    
     561         
     562        renderer = gtk_cell_renderer_text_new (); 
     563        column = gtk_tree_view_column_new_with_attributes ("Ports", renderer, 
     564                                                      "text", N_IN_PORTS_COLUMN, 
     565                                                      NULL);     
     566        gtk_tree_view_column_set_resizable (column, TRUE); 
     567        gtk_tree_view_column_set_sort_column_id (column, N_IN_PORTS_COLUMN);                                                       
     568        gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);                      
     569 
     570/* 
     571    currently, plugins are only loaded if they have an equal number of input 
     572        and output ports. so this next column is useless                 
     573        renderer = gtk_cell_renderer_text_new (); 
     574        column = gtk_tree_view_column_new_with_attributes ("Output ports", renderer, 
     575                                                      "text", N_OUT_PORTS_COLUMN, 
     576                                                      NULL);                                                                                     
     577        gtk_tree_view_column_set_resizable (column, TRUE); 
     578        gtk_tree_view_column_set_sort_column_id (column, N_OUT_PORTS_COLUMN); 
     579        gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);             */ 
     580 
     581        renderer = gtk_cell_renderer_text_new (); 
     582        column = gtk_tree_view_column_new_with_attributes ("Description", renderer, 
     583                                                      "text", DESCRIPTION_COLUMN, 
     584                                                      NULL); 
     585 
     586        gtk_tree_view_column_set_resizable (column, TRUE); 
     587        gtk_tree_view_column_set_sort_column_id (column, DESCRIPTION_COLUMN); 
     588        gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column); 
     589         
     590        renderer = gtk_cell_renderer_text_new (); 
     591        column = gtk_tree_view_column_new_with_attributes ("Author", renderer, 
     592                                                      "text", AUTHOR_COLUMN, 
     593                                                      NULL); 
     594                                                                                                           
     595        gtk_tree_view_column_set_resizable (column, TRUE); 
     596        gtk_tree_view_column_set_sort_column_id (column, AUTHOR_COLUMN); 
     597        gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column); 
     598                                                                                                           
     599        return tree; 
     600} 
     601 
     602static gboolean filter_visible (GtkTreeModel *model, GtkTreeIter *iter, gpointer data) 
     603{ 
     604        plugin_browser_filter * pbf = (plugin_browser_filter *)data; 
     605        gchar *name; 
     606        gboolean retval = FALSE; 
     607 
     608        gtk_tree_model_get (model, iter, NAME_COLUMN, &name, -1); 
     609         
     610        if (!pbf->reg_dirty_flag ) 
     611        { 
     612                retval = TRUE; 
     613        } 
     614 
     615        if (pbf->reg_dirty_flag && (regexec(pbf->reg_buffer, name, 0, NULL, 0) == 0)) 
     616        { 
     617                retval = TRUE; 
     618        } 
     619                 
     620        return retval;  
     621         
     622} 
     623 
     624static void search_entry_cb (GtkWidget * entry, gpointer userdata) 
     625{        
     626        plugin_browser_filter * pbf = (plugin_browser_filter *)userdata; 
     627         
     628         
     629        if (pbf->reg_buffer == NULL) 
     630        { 
     631                pbf->reg_buffer = g_new(regex_t, 1); 
     632        } 
     633         
     634        if (!g_strcasecmp(pbf->search_text, gtk_entry_get_text(GTK_ENTRY(entry))) && pbf->reg_dirty_flag) 
     635        { 
     636                regfree(pbf->reg_buffer); /* reset buffer only. does not free the struct itself  */ 
     637                pbf->reg_dirty_flag = FALSE; 
     638        } 
     639 
     640        pbf->search_text = gtk_entry_get_text(GTK_ENTRY(entry)); /* oops, cptn lazy badwise!  */ 
     641        pbf->reg_dirty_flag = 1; 
     642         
     643        if (pbf->reg_dirty_flag == TRUE &&  regcomp(pbf->reg_buffer, pbf->search_text, REG_EXTENDED|REG_ICASE|REG_NOSUB) == 0) 
     644        { 
     645                gtk_tree_model_filter_refilter(GTK_TREE_MODEL_FILTER(pbf->filter));      
     646        } 
     647         
     648 
     649} 
     650 
     651static void filter_button_toggled_cb(GtkWidget * toggle_button, gpointer user_data) 
     652{ 
     653        int which_toggle; 
     654        gboolean state = TRUE; 
     655        plugin_browser_filter *pbf = (plugin_browser_filter *) user_data; 
     656         
     657        if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(toggle_button))) 
     658                state = FALSE; 
     659         
     660        which_toggle = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(toggle_button), "which_toggle")); 
     661         
     662        switch (which_toggle) { 
     663        case FILTER_TOGGLE_BOOKMARKED: 
     664        pbf->hide_bookmarked = state; 
     665        break; 
     666        case FILTER_TOGGLE_UNMARKED: 
     667        pbf->hide_unmarked = state; 
     668        break; 
     669        case FILTER_TOGGLE_BLACKLISTED: 
     670        pbf->hide_blacklisted = state; 
     671        break; 
     672    case FILTER_TOGGLE_LADSPA: 
     673        pbf->hide_ladspa = state; 
     674        break; 
     675        case FILTER_TOGGLE_SWEEP: 
     676        pbf->hide_sweep = state; 
     677        break; 
     678        case FILTER_TOGGLE_STEREO: 
     679        pbf->hide_stereo = state; 
     680        break; 
     681        case FILTER_TOGGLE_MONO: 
     682        pbf->hide_mono = state; 
     683        break; 
     684  } 
     685  gtk_tree_model_filter_refilter(GTK_TREE_MODEL_FILTER(pbf->filter)); 
     686 
     687         
     688} 
     689 
     690static void search_entry_clear_cb (GtkWidget * button, gpointer userdata) 
     691{ 
     692        gtk_entry_set_text(GTK_ENTRY(userdata), "");     
     693} 
     694 
     695 
     696static void check_bookmarks_toggled_cb (GtkCellRendererToggle *cell_renderer, 
     697                                gchar                 *path, 
     698                                gpointer               user_data)  
     699{ 
     700        check_toggled (cell_renderer, path, user_data, BOOKMARKS_COLUMN); 
     701} 
     702 
     703static void check_blacklist_toggled_cb (GtkCellRendererToggle *cell_renderer, 
     704                                gchar                 *path, 
     705                                gpointer               user_data)  
     706{ 
     707        check_toggled (cell_renderer, path, user_data, BLACKLIST_COLUMN); 
     708} 
     709 
     710static void check_toggled (GtkCellRendererToggle *cell_renderer, 
     711                                gchar                 *path, 
     712                                gpointer               user_data, 
     713                                                                int column) 
     714 
     715{ 
     716        GtkTreeIter iter, child_iter; 
     717        plugin_browser_filter * pbf; 
     718         
     719        pbf = (plugin_browser_filter *) user_data; 
     720        if ( gtk_tree_model_get_iter_from_string (pbf->filter, 
     721                                             &iter, 
     722                                             path)) 
     723        { 
     724                gtk_tree_model_filter_convert_iter_to_child_iter 
     725                                            (GTK_TREE_MODEL_FILTER(pbf->filter), 
     726                                             &child_iter, 
     727                                             &iter); 
     728                 
     729                if (gtk_cell_renderer_toggle_get_active (cell_renderer)) 
     730                { 
     731                        gtk_list_store_set (pbf->plugins_list_store, &child_iter, column, FALSE, -1); 
     732                } 
     733                else 
     734                { 
     735                        gtk_list_store_set (pbf->plugins_list_store, &child_iter, column, TRUE, -1); 
     736                } 
     737         
     738        } 
     739} 
     740 
     741static void save_search_cb (GtkButton * button, gpointer user_data) 
     742{ 
     743        plugin_browser_filter * pbf; 
     744        GtkTreeIter iter; 
     745         
     746        pbf = (plugin_browser_filter *) user_data; 
     747 
     748        gtk_list_store_append (GTK_LIST_STORE(pbf->qsearch_list_store), &iter); 
     749        gtk_list_store_set(GTK_LIST_STORE(pbf->qsearch_list_store), &iter, 
     750                                                        QS_NAME_COLUMN, pbf->search_text, 
     751                                                        QS_STRING_COLUMN, pbf->search_text, 
     752                                                        QS_BLACK_COLUMN, pbf->hide_blacklisted, 
     753                                                        QS_BOOK_COLUMN, pbf->hide_bookmarked, 
     754                                                        QS_UNMARK_COLUMN, pbf->hide_unmarked, 
     755                                                        QS_LADSPA_COLUMN, pbf->hide_ladspa, 
     756                                                        QS_SWEEP_COLUMN, pbf->hide_sweep, 
     757                                                        QS_STEREO_COLUMN, pbf->hide_stereo, 
     758                                                        QS_MONO_COLUMN, pbf->hide_mono, 
     759                                                        -1); 
     760                           
     761} 
     762 
     763static void delete_search_cb (GtkButton * button, gpointer user_data) 
     764{ 
     765        GtkTreeIter iter; 
     766        GtkTreeModel * model; 
     767        GtkTreeSelection * select; 
     768         
     769        GtkTreeView * tree = GTK_TREE_VIEW(user_data);  
     770        plugin_browser_filter * pbf = (plugin_browser_filter *) user_data; 
     771         
     772 
     773        if ((select = gtk_tree_view_get_selection(tree))) 
     774        { 
     775                if (gtk_tree_selection_get_selected (select, &model, &iter)) 
     776                { 
     777                        gtk_list_store_remove (GTK_LIST_STORE(model), &iter); 
     778                               
     779                } 
     780        }                  
     781} 
     782 
     783static void qsearch_tree_selection_changed_cb (GtkTreeSelection *selection, gpointer user_data) 
     784{ 
     785        GtkTreeIter iter; 
     786    GtkTreeModel * model; 
     787    gchar * search_text; 
     788 
     789        plugin_browser_filter * pbf = (plugin_browser_filter *)user_data; 
     790    if (gtk_tree_selection_get_selected (selection, &model, &iter)) 
     791    { 
     792        gtk_tree_model_get (model, &iter,  
     793                                                        QS_STRING_COLUMN, &search_text, 
     794                                                        QS_BLACK_COLUMN, &pbf->hide_blacklisted, 
     795                                                        QS_BOOK_COLUMN, &pbf->hide_bookmarked, 
     796                                                        QS_UNMARK_COLUMN, &pbf->hide_unmarked, 
     797                                                        QS_LADSPA_COLUMN, &pbf->hide_ladspa, 
     798                                                        QS_SWEEP_COLUMN, &pbf->hide_sweep, 
     799                                                        QS_STEREO_COLUMN, &pbf->hide_stereo, 
     800                                                        QS_MONO_COLUMN, &pbf->hide_mono,  
     801                                                        -1); 
     802                gtk_entry_set_text(GTK_ENTRY(pbf->entry), search_text); 
     803                g_free(search_text); 
     804        } 
     805         
     806} 
     807 
     808/*qs_set_liststore_from_string(plugin_browser_filter *pbf) 
     809{ 
     810        gchar * current; 
     811         
     812         
     813 
     814         
     815         
     816        gtk_list_store_append (GTK_LIST_STORE(pbf->qsearch_list_store), &iter); 
     817        gtk_list_store_set(GTK_LIST_STORE(pbf->qsearch_list_store), &iter, 
     818                                                        QS_NAME_COLUMN, pbf->search_text, 
     819                                                        QS_STRING_COLUMN, pbf->search_text, 
     820                                                        QS_BLACK_COLUMN, pbf->hide_blacklisted, 
     821                                                        QS_BOOK_COLUMN, pbf->hide_bookmarked, 
     822                                                        QS_UNMARK_COLUMN, pbf->hide_unmarked, 
     823                                                        QS_LADSPA_COLUMN, pbf->hide_ladspa, 
     824                                                        QS_SWEEP_COLUMN, pbf->hide_sweep, 
     825                                                        QS_STEREO_COLUMN, pbf->hide_stereo, 
     826                                                        QS_MONO_COLUMN, pbf->hide_mono, 
     827                                                        -1); 
     828         
     829}*/ 

  • src/plugin_browser.h

    old new  
     1 
     2#ifndef __PLUGIN_BROWSER_H__ 
     3#define __PLUGIN_BROWSER_H__ 
     4 
     5GtkWidget* create_plugin_browser_window (void); 
     6 
     7#endif /* __PLUGIN_BROWSER_H__ */ 

  • src/main.c

    old new  
    4343#include "callbacks.h" 
    4444#include "question_dialogs.h" 
    4545#include "play.h" 
    46  
     46#include "plugin_browser.h" 
    4747extern void sweep_timeouts_init (void); 
    4848 
    4949/* 
    …… 
    235235  } 
    236236#endif 
    237237 
     238  GtkWidget * pb_window = gtk_window_new(GTK_WINDOW_TOPLEVEL); 
     239  gtk_container_add (GTK_CONTAINER(pb_window), create_plugin_browser_window()); 
     240 
     241  gtk_widget_show(pb_window);    
    238242  gtk_main (); 
    239243 
    240244  /* close preferences database */ 

  • src/Makefile.am

    old new  
    4949        pixmaps.h \ 
    5050        play.c play.h \ 
    5151        plugin.c plugin.h \ 
     52        plugin_browser.c plugin_browser.h \ 
    5253        preferences.c preferences.h \ 
    5354        print.c print.h \ 
    5455        question_dialogs.c question_dialogs.h \ 

  • plugins/fade/fade.c

    old new  
    159159  "Conrad Parker", 
    160160  "Copyright (C) 2002", 
    161161  "http://sweep.sourceforge.net/plugins/fade", 
     162  "SWEEP", 
     163  "libfade.so", 
     164  1, 
    162165  "Filters/Fade_In", /* identifier */ 
    163166  0, /* accel_key */ 
    164167  0, /* accel_mods */ 
    …… 
    175178  "Conrad Parker", 
    176179  "Copyright (C) 2002", 
    177180  "http://sweep.sourceforge.net/plugins/fade", 
     181  "SWEEP", 
     182  "libfade.so", 
     183  1, 
    178184  "Filters/Fade_In", /* identifier */ 
    179185  0, /* accel_key */ 
    180186  0, /* accel_mods */ 

  • plugins/byenergy/byenergy.c

    old new  
    234234  "C. Parker, S. Pfeiffer", 
    235235  "Copyright (C) 2000 CSIRO Australia", 
    236236  "http://sweep.sourceforge.net/plugins/byenergy", 
     237  "SWEEP", 
     238  "libbyenergy.lo", 
     239  1, 
    237240  "Filters/Select by energy", /* identifier */ 
    238241  0, /* accel_key */ 
    239242  0, /* accel_mods */ 

  • plugins/ladspa/ladspameta.c

    old new  
    7272 *   2. the number of audio inputs must equal the number of audio outputs. 
    7373 */ 
    7474static gboolean 
    75 is_usable(const LADSPA_Descriptor * d) 
     75is_usable(const LADSPA_Descriptor * d, gint *channels) 
    7676{ 
    7777  LADSPA_PortDescriptor pd; 
    7878  gint i; 
    …… 
    8989  } 
    9090 
    9191  if (nr_ao == 0) return FALSE; 
     92           
     93  if (nr_ai > nr_ao) 
     94          *channels = nr_ai; 
     95  else 
     96          *channels = nr_ao; 
    9297 
    9398  /* Sanity checks */ 
    9499  if (! d->run) return FALSE; /* plugin does nothing! */ 
    …… 
    661666  LADSPA_Descriptor_Function desc_func; 
    662667  const LADSPA_Descriptor * d; 
    663668  LADSPA_PortDescriptor pd; 
    664   gint i, j, k, nr_params; 
     669  gint i, j, k, nr_params, channels; 
    665670  int valid_mask; 
    666671  sw_procedure * proc; 
    667672 
    …… 
    675680  if ((desc_func = dlsym (module, "ladspa_descriptor"))) { 
    676681    for (i=0; (d = desc_func (i)) != NULL; i++) { 
    677682 
    678       if (!is_usable(d)) 
     683      if (!is_usable(d, &channels)) 
    679684        continue; 
    680685 
    681686      proc = g_malloc0 (sizeof (*proc)); 
     687          proc->type = "LADSPA"; 
    682688      proc->name = (gchar *)d->Name; 
    683689      proc->author = (gchar *)d->Maker; 
    684690      proc->copyright = (gchar *)d->Copyright; 
     691          proc->filename = g_strdup(name); 
     692          proc->channels = channels; 
    685693 
    686694      nr_params=0; 
    687695      for (j=0; j < d->PortCount; j++) { 

  • plugins/normalise/normalise.c

    old new  
    135135  "Conrad Parker", 
    136136  "Copyright (C) 2000", 
    137137  "http://sweep.sourceforge.net/plugins/normalise", 
     138  "SWEEP", 
     139  "libnormalise.so", 
     140  1, 
    138141  "Filters/Normalise", /* identifier */ 
    139142  GDK_n, /* accel_key */ 
    140143  GDK_SHIFT_MASK, /* accel_mods */ 

  • plugins/example/example.c

    old new  
    131131  "Conrad Parker", 
    132132  "Copyright (C) 2000", 
    133133  "http://sweep.sourceforge.net/plugins/example", 
     134  "SWEEP", 
     135  "libexample.so", 
     136  1, 
    134137  "Example", /* identifier */ 
    135138  0, /* accel_key */ 
    136139  0, /* accel_mods */ 

  • plugins/reverse/reverse.c

    old new  
    142142  "Conrad Parker", 
    143143  "Copyright (C) 2000", 
    144144  "http://sweep.sourceforge.net/plugins/reverse", 
     145  "SWEEP", 
     146  "libreverse", 
     147  1, 
    145148  "Filters/Reverse", /* identifier */ 
    146149  GDK_f, /* accel_key */ 
    147150  GDK_SHIFT_MASK, /* accel_mods */ 

  • plugins/echo/echo.c

    old new  
    115115  "Conrad Parker", 
    116116  "Copyright (C) 2000", 
    117117  "http://sweep.sourceforge.net/plugins/echo", 
     118  "SWEEP", 
     119  "libecho.so", 
     120  1, 
    118121  "Filters/Echo", /* identifier */ 
    119122  GDK_e, /* accel_key */ 
    120123  GDK_SHIFT_MASK, /* accel_mods */ 

  • include/sweep/sweep_types.h

    old new  
    420420  gchar * copyright; 
    421421  gchar * url; 
    422422 
     423/* "type" is currently one of "LADSPA" or "SWEEP" */  
     424  gchar * type; 
     425  gchar * filename;  
     426 
     427/* whilst only plugins with equal numbers of input and output 
     428 * ports are loaded, "ports" holds the effective number of channels 
     429 * that a plugin handles. convenient information for the plugin browser. 
     430 */ 
     431  gint channels;  
     432 
    423433  gchar * identifier; 
    424434 
    425435  /* Key bindings */ 
    …… 
    466476 
    467477 
    468478#endif  /* __SWEEP_TYPES_H__ */ 
    469  
    470  
    471  
    472  
    473  
    474