src/connector.cpp

   1 /* Calf Library
   2  * Jack Connector Window
   3  *
   4  * Copyright (C) 2014 Markus Schmidt / Krzysztof Foltman
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General
  17  * Public License along with this program; if not, write to the
  18  * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  19  * Boston, MA  02110-1301  USA
  20  */
  21
  22 #include <gtk/gtk.h>
  23 #include <gdk/gdk.h>
  24
  25 #include <calf/giface.h>
  26 #include <calf/connector.h>
  27 #include <calf/custom_ctl.h>
  28 #include <calf/jackhost.h>
  29
  30 #include <jack/jack.h>
  31 #include <jack/midiport.h>
  32
  33 using namespace std;
  34 using namespace calf_plugins;
  35
  36 calf_connector::calf_connector(plugin_strip *strip_)
  37 {
  38     strip = strip_;
  39     window = NULL;
  40     create_window();
  41 }
  42
  43 calf_connector::~calf_connector()
  44 {
  45
  46 }
  47
  48 // CALLBACKS FOR CALLBACKS
  49 void calf_connector::toggle_port(calf_connector *self, GtkListStore *list, gchar *path_, gchar **port, gboolean &enabled)
  50 {
  51     GtkTreeIter iter;
  52     gtk_tree_model_get_iter(GTK_TREE_MODEL(list), &iter, gtk_tree_path_new_from_string(path_));
  53     gtk_tree_model_get(GTK_TREE_MODEL(list), &iter, 0, port, 2, &enabled, -1);
  54     gtk_list_store_set(GTK_LIST_STORE (list), &iter, 2, !enabled, -1);
  55     enabled = !enabled;
  56 }
  57 void calf_connector::connect(jack_client_t *client, gchar *source, gchar *dest, gboolean enabled)
  58 {
  59     if (enabled) {
  60         jack_connect(client, source, dest);
  61     } else {
  62         jack_disconnect(client, source, dest);
  63     }
  64     set_toggles(this, 0);
  65     set_toggles(this, 1);
  66     set_toggles(this, 2);
  67 }
  68
  69 // PORT CLICKS
  70 void calf_connector::inport_clicked(GtkWidget *button, gpointer data)
  71 {
  72     connector_port *port = (connector_port *)data;
  73     if (port == port->connector->active_in)
  74         return;
  75     port->connector->active_in = port;
  76     port->connector->fill_inlist(port->connector);
  77 }
  78 void calf_connector::outport_clicked(GtkWidget *button, gpointer data)
  79 {
  80     connector_port *port = (connector_port *)data;
  81     if (port == port->connector->active_out)
  82         return;
  83     port->connector->active_out = port;
  84     port->connector->fill_outlist(port->connector);
  85 }
  86 void calf_connector::midiport_clicked(GtkWidget *button, gpointer data)
  87 {
  88     connector_port *port = (connector_port *)data;
  89     if (port == port->connector->active_midi)
  90         return;
  91     port->connector->active_midi = port;
  92     port->connector->fill_midilist(port->connector);
  93 }
  94
  95 // LIST CLICKS
  96 void calf_connector::inconnector_clicked(GtkCellRendererToggle *cell_renderer, gchar *path_, gpointer data)
  97 {
  98     calf_connector *self = (calf_connector *)data;
  99     gchar *port;
 100     gboolean enabled;
 101     self->toggle_port(self, self->inlist, path_, &port, enabled);
 102     string source = port;
 103     string dest   = (string)jack_get_client_name(self->jackclient)
 104                   + ":" + self->strip->plugin->inputs[self->active_in ? self->active_in->id : 0].nice_name;
 105     self->connect(self->jackclient, (gchar*)source.c_str(), (gchar*)dest.c_str(), enabled);
 106     self->set_toggles(self, 0);
 107 }
 108 void calf_connector::outconnector_clicked(GtkCellRendererToggle *cell_renderer, gchar *path_, gpointer data)
 109 {
 110     calf_connector *self = (calf_connector *)data;
 111     gchar *port = NULL;
 112     gboolean enabled;
 113     self->toggle_port(self, self->outlist, path_, &port, enabled);
 114     string source = (string)jack_get_client_name(self->jackclient)
 115                   + ":" + self->strip->plugin->outputs[self->active_out ? self->active_out->id : 0].nice_name;
 116     string dest   = port;
 117     self->connect(self->jackclient, (gchar*)source.c_str(), (gchar*)dest.c_str(), enabled);
 118     self->set_toggles(self, 1);
 119 }
 120 void calf_connector::midiconnector_clicked(GtkCellRendererToggle *cell_renderer, gchar *path_, gpointer data)
 121 {
 122     calf_connector *self = (calf_connector *)data;
 123     gchar *port = NULL;
 124     gboolean enabled;
 125     self->toggle_port(self, self->midilist, path_, &port, enabled);
 126     string source = port;
 127     string dest   = (string)jack_get_client_name(self->jackclient)
 128                   + ":" + self->strip->plugin->midi_port.nice_name;
 129     self->connect(self->jackclient, (gchar*)source.c_str(), (gchar*)dest.c_str(), enabled);
 130     self->set_toggles(self, 2);
 131 }
 132
 133 // DISCONNECT CLICKS
 134 void calf_connector::disconnect_inputs(GtkWidget *button, gpointer data)
 135 {
 136     ((calf_connector *)data)->_disconnect(0);
 137 }
 138 void calf_connector::disconnect_outputs(GtkWidget *buttconson, gpointer data)
 139 {
 140     ((calf_connector *)data)->_disconnect(1);
 141 }
 142 void calf_connector::disconnect_midi(GtkWidget *button, gpointer data)
 143 {
 144     ((calf_connector *)data)->_disconnect(2);
 145 }
 146 void calf_connector::disconnect_all(GtkWidget *button, gpointer data)
 147 {
 148     ((calf_connector *)data)->_disconnect(-1);
 149 }
 150
 151 // JACK CALLBACKS
 152 //void calf_connector::jack_port_connect_callback(jack_port_id_t a, jack_port_id_t b, int connect, gpointer data)
 153 //{
 154     //calf_connector *self = (calf_connector *)data;
 155     //self->fill_list(data);
 156 //}
 157 //void calf_connector::jack_port_rename_callback(jack_port_id_t port, const char *old_name, const char *new_name, gpointer data)
 158 //{
 159     //calf_connector *self = (calf_connector *)data;
 160     //self->fill_list(data);
 161 //}
 162 //void calf_connector::jack_port_registration_callback(jack_port_id_t port, int register, gpointer data)
 163 //{
 164     //calf_connector *self = (calf_connector *)data;
 165     //self->fill_list(data);
 166 //}
 167
 168
 169 void calf_connector::fill_inlist(gpointer data)
 170 {
 171     ((calf_connector *)data)->fill_list((calf_connector *)data, 0);
 172 }
 173 void calf_connector::fill_outlist(gpointer data)
 174 {
 175     ((calf_connector *)data)->fill_list((calf_connector *)data, 1);
 176 }
 177 void calf_connector::fill_midilist(gpointer data)
 178 {
 179     ((calf_connector *)data)->fill_list((calf_connector *)data, 2);
 180 }
 181
 182 void calf_connector::fill_list(calf_connector *self, int type)
 183 {
 184     GtkTreeIter iter;
 185     GtkListStore *list;
 186     const char **ports;
 187     switch (type) {
 188         case 0:
 189         default:
 190             list = self->inlist;
 191             gtk_list_store_clear(list);
 192             ports = jack_get_ports(self->jackclient, ".*:.*", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput);
 193             if (!ports) return;
 194             break;
 195         case 1:
 196             list = self->outlist;
 197             gtk_list_store_clear(list);
 198             ports = jack_get_ports(self->jackclient, ".*:.*", JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput);
 199             if (!ports) return;
 200             break;
 201         case 2:
 202             list = self->midilist;
 203             gtk_list_store_clear(list);
 204             ports = jack_get_ports(self->jackclient, ".*:.*", JACK_DEFAULT_MIDI_TYPE, JackPortIsOutput);
 205             if (!ports) return;
 206             break;
 207     }
 208
 209     int c = 0;
 210     do {
 211         gtk_list_store_append(list, &iter);
 212         if (gtk_list_store_iter_is_valid(list, &iter))
 213             gtk_list_store_set(list, &iter, 0, ports[c], 1, ports[c], 2,  FALSE, -1);
 214     } while (ports[++c]);
 215     jack_free(ports);
 216     self->set_toggles(self, type);
 217 }
 218
 219 void calf_connector::set_toggles(calf_connector *self, int type)
 220 {
 221     const char** cons;
 222     const char** ports;
 223     char path[16];
 224     GtkTreeIter iter;
 225     GtkListStore *list;
 226     jack_port_t *port = NULL;
 227     int p = 0, c = 0, f = 0, portflag = 0;
 228     const char * porttype;
 229     string s  = "", nn = "";
 230     switch (type) {
 231         case 0:
 232         default:
 233             if (!self->active_in)
 234                 return;
 235             portflag = JackPortIsOutput;
 236             porttype = JACK_DEFAULT_AUDIO_TYPE;
 237             nn       = (string)jack_get_client_name(self->jackclient)
 238                      + ":" + self->strip->plugin->inputs[self->active_in->id].nice_name;
 239             list     = self->inlist;
 240             break;
 241         case 1:
 242             if (!self->active_out)
 243                 return;
 244             portflag = JackPortIsInput;
 245             porttype = JACK_DEFAULT_AUDIO_TYPE;
 246             nn       = (string)jack_get_client_name(self->jackclient)
 247                      + ":" + self->strip->plugin->outputs[self->active_out->id].nice_name;
 248             list     = self->outlist;
 249             break;
 250         case 2:
 251             portflag = JackPortIsOutput;
 252             porttype = JACK_DEFAULT_MIDI_TYPE;
 253             nn       = (string)jack_get_client_name(self->jackclient)
 254                      + ":" + self->strip->plugin->midi_port.nice_name;
 255             list     = self->midilist;
 256             break;
 257     }
 258     port  = jack_port_by_name(self->jackclient, nn.c_str());
 259     cons  = jack_port_get_all_connections(self->jackclient, port);
 260     ports = jack_get_ports(self->jackclient,
 261                            NULL,
 262                            porttype,
 263                            portflag);
 264     if (!ports) {
 265         jack_free(cons);
 266         jack_free(ports);
 267         return;
 268     }
 269     p = 0;
 270     do {
 271         sprintf(path, "%d", p);
 272         gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(list), &iter, path);
 273         c = f = 0;
 274         do {
 275             if (cons and cons[c] == ports[p]) {
 276                 gtk_list_store_set (list, &iter, 2, TRUE, -1);
 277                 f = 1;
 278             }
 279         } while (cons[++c]);
 280         if (!f) {
 281             gtk_list_store_set (list, &iter, 2, FALSE, -1);
 282         }
 283     } while (ports[++p]);
 284     jack_free(cons);
 285     jack_free(ports);
 286 }
 287
 288 void calf_connector::_disconnect(int type)
 289 {
 290     string nn = "";
 291     const char** cons = NULL;
 292     jack_port_t *port = NULL;
 293     int c = 0;
 294     if (type == 0 or type == -1) {
 295         for (int i = 0; i < strip->plugin->in_count; i++) {
 296             nn   = (string)jack_get_client_name(jackclient)
 297                  + ":" + strip->plugin->inputs[i].nice_name;
 298             port = jack_port_by_name(jackclient, nn.c_str());
 299             cons = jack_port_get_all_connections(jackclient, port);
 300             if (cons) {
 301                 c = 0;
 302                 do {
 303                     jack_disconnect(jackclient, cons[c], jack_port_name(port));
 304                 } while (cons[++c]);
 305                 jack_free(cons);
 306             }
 307         }
 308     }
 309     if (type == 1 or type == -1) {
 310         for (int i = 0; i < strip->plugin->out_count; i++) {
 311             nn   = (string)jack_get_client_name(jackclient)
 312                  + ":" + strip->plugin->outputs[i].nice_name;
 313             port = jack_port_by_name(jackclient, nn.c_str());
 314             cons = jack_port_get_all_connections(jackclient, port);
 315             if (cons) {
 316                 c = 0;
 317                 do {
 318                     jack_disconnect(jackclient, jack_port_name(port), cons[c]);
 319                 } while (cons[++c]);
 320                 jack_free(cons);
 321             }
 322         }
 323     }
 324     if (type == 2 or type == -1) {
 325         nn   = (string)jack_get_client_name(jackclient)
 326              + ":" + strip->plugin->midi_port.nice_name;
 327         port = jack_port_by_name(jackclient, nn.c_str());
 328         cons = jack_port_get_all_connections(jackclient, port);
 329         if (cons) {
 330             c = 0;
 331             do {
 332                 jack_disconnect(jackclient, cons[c], jack_port_name(port));
 333             } while (cons[++c]);
 334             jack_free(cons);
 335         }
 336     }
 337     set_toggles(this, 0);
 338     set_toggles(this, 1);
 339     set_toggles(this, 2);
 340 }
 341
 342 void calf_connector::close()
 343 {
 344     if (window)
 345         gtk_widget_destroy(GTK_WIDGET(window));
 346 }
 347 void calf_connector::close_window(GtkWidget *button, gpointer data)
 348 {
 349     calf_connector *self = (calf_connector *)data;
 350     if (self->window)
 351         gtk_widget_destroy(GTK_WIDGET(self->window));
 352 }
 353 void calf_connector::on_destroy_window(GtkWidget *window, gpointer data)
 354 {
 355     calf_connector *self = (calf_connector *)data;
 356     if (self->strip->con)
 357         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(self->strip->con), FALSE);
 358     self->strip->connector = NULL;
 359     delete self;
 360 }
 361
 362
 363 void calf_connector::create_window()
 364 {
 365     char buf[256];
 366
 367     // WINDOW
 368
 369     string title = "Calf " + (string)strip->plugin->get_metadata_iface()->get_label() + " Connector";
 370     window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 371     gtk_window_set_title(GTK_WINDOW(window), title.c_str());
 372     gtk_window_set_destroy_with_parent(GTK_WINDOW(window), TRUE);
 373     //gtk_window_set_keep_above(GTK_WINDOW(window), TRUE);
 374     gtk_window_set_icon_name(GTK_WINDOW(window), "calf_plugin");
 375     gtk_window_set_role(GTK_WINDOW(window), "calf_connector");
 376     gtk_window_set_default_size(GTK_WINDOW(window), 900, 400);
 377     gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_MOUSE);
 378     gtk_widget_set_name(GTK_WIDGET(window), "Connector");
 379
 380     g_signal_connect(G_OBJECT(window), "destroy",
 381                      G_CALLBACK (on_destroy_window), (gpointer)this);
 382
 383
 384     // CONTAINER STUFF
 385
 386     GtkVBox *vbox = GTK_VBOX(gtk_vbox_new(false, 8));
 387     gtk_container_add(GTK_CONTAINER(window), GTK_WIDGET(vbox));
 388     //gtk_widget_set_name(GTK_WIDGET(vbox), "Calf-Container");
 389     gtk_container_set_border_width (GTK_CONTAINER(vbox), 8);
 390
 391     GtkTable *table = GTK_TABLE(gtk_table_new(2, 5, FALSE));
 392     gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(table), true, true, 0);
 393     gtk_table_set_row_spacings(table, 5);
 394     gtk_table_set_col_spacings(table, 5);
 395
 396
 397     // FRAMES AND CONTAINER
 398
 399     // Button frame
 400     GtkWidget *butframe = gtk_frame_new("Bulk Disconnect");
 401     gtk_table_attach(GTK_TABLE(table), GTK_WIDGET(butframe), 1, 4, 1, 2, (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL), 0, 0);
 402     // Button container
 403     GtkWidget *buttons = gtk_vbox_new(false, 2);
 404     gtk_container_add(GTK_CONTAINER(butframe), GTK_WIDGET(buttons));
 405
 406     // Input frame
 407     GtkWidget *inframe = gtk_frame_new("Plug-In Inputs");
 408     gtk_table_attach(GTK_TABLE(table), GTK_WIDGET(inframe), 1, 2, 0, 1, (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL|GTK_EXPAND), 0, 0);
 409     gtk_widget_set_name(GTK_WIDGET(inframe), "Ports");
 410     gtk_widget_set_size_request(GTK_WIDGET(inframe), 100, -1);
 411     //gtk_widget_set_size_request(GTK_WIDGET(inframe), -1, 200);
 412     // Input container
 413     GtkWidget *inputs = gtk_vbox_new(false, 2);
 414     gtk_container_add(GTK_CONTAINER(inframe), GTK_WIDGET(inputs));
 415     // Disconnect input button
 416     GtkWidget *inbut = gtk_button_new_with_label("Inputs");
 417     g_signal_connect(G_OBJECT(inbut), "clicked", G_CALLBACK(disconnect_inputs), this);
 418     gtk_box_pack_start(GTK_BOX(buttons), inbut, false, false, 0);
 419     gtk_widget_show(GTK_WIDGET(inbut));
 420
 421     // Output frame
 422     GtkWidget *outframe = gtk_frame_new("Plug-In Outputs");
 423     gtk_table_attach(GTK_TABLE(table), GTK_WIDGET(outframe), 3, 4, 0, 1, (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL|GTK_EXPAND), 0, 0);
 424     gtk_widget_set_name(GTK_WIDGET(outframe), "Ports");
 425     gtk_widget_set_size_request(GTK_WIDGET(outframe), 100, -1);
 426     //gtk_widget_set_size_request(GTK_WIDGET(outframe), -1, 200);
 427     // Output container
 428     GtkWidget *outputs = gtk_vbox_new(false, 2);
 429     gtk_container_add(GTK_CONTAINER(outframe), GTK_WIDGET(outputs));
 430     // Disconnect output button
 431     GtkWidget *outbut = gtk_button_new_with_label("Outputs");
 432     g_signal_connect(G_OBJECT(outbut), "clicked", G_CALLBACK(disconnect_outputs), this);
 433     gtk_box_pack_start(GTK_BOX(buttons), outbut, false, false, 0);
 434     gtk_widget_show(GTK_WIDGET(outbut));
 435
 436     // MIDI frame
 437     GtkWidget *midiframe = gtk_frame_new("Plug-In MIDI");
 438     //gtk_table_attach(GTK_TABLE(table), GTK_WIDGET(midiframe), 1, 2, 1, 2, (GtkAttachOptions)GTK_FILL, (GtkAttachOptions)(GTK_FILL), 0, 0);
 439     // MIDI container
 440     GtkWidget *midi = gtk_vbox_new(false, 2);
 441     gtk_container_add(GTK_CONTAINER(midiframe), GTK_WIDGET(midi));
 442     // Disconnect midi button
 443     GtkWidget *midibut = gtk_button_new_with_label("MIDI");
 444     g_signal_connect(G_OBJECT(midibut), "clicked", G_CALLBACK(disconnect_midi), this);
 445     gtk_box_pack_start(GTK_BOX(buttons), midibut, false, false, 0);
 446     gtk_widget_show(GTK_WIDGET(midibut));
 447
 448     // LABEL
 449     GtkWidget *label = gtk_label_new(strip->plugin->get_metadata_iface()->get_label());
 450     gtk_table_attach(GTK_TABLE(table), GTK_WIDGET(label), 2, 3, 0, 1, (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL), 10, 0);
 451     gtk_widget_set_name(GTK_WIDGET(label), "Title");
 452     gtk_label_set_angle(GTK_LABEL(label), 90);
 453
 454     gtk_widget_show_all(window);
 455
 456     // Disconnect all button
 457     GtkWidget *allbut = gtk_button_new_with_label("*All*");
 458     g_signal_connect(G_OBJECT(allbut), "clicked", G_CALLBACK(disconnect_all), this);
 459     gtk_box_pack_start(GTK_BOX(buttons), allbut, false, true, 0);
 460     gtk_widget_show(GTK_WIDGET(allbut));
 461
 462     // Close button
 463     //GtkWidget *_close = gtk_alignment_new(1, 1, 0.5, 0.33);
 464     //gtk_table_attach(GTK_TABLE(table), GTK_WIDGET(_close), 3, 4, 1, 2, (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL), 0, 0);
 465     GtkWidget *close = gtk_button_new_with_label("Close");
 466     g_signal_connect(G_OBJECT(close), "clicked", G_CALLBACK(close_window), this);
 467     //gtk_container_add(GTK_CONTAINER(_close), close);
 468     gtk_widget_show(GTK_WIDGET(close));
 469     //gtk_widget_show(GTK_WIDGET(_close));
 470     gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(close), false, true, 0);
 471
 472
 473     // LIST STUFF
 474
 475     GtkTreeViewColumn *col;
 476     GtkCellRenderer *renderer;
 477     GtkWidget *inscroller, *outscroller, *midiscroller;
 478     GtkWidget *inview, *outview, *midiview;
 479
 480     // INPUT LIST
 481
 482     // scroller
 483     inscroller = gtk_scrolled_window_new(NULL, NULL);
 484     gtk_table_attach_defaults(GTK_TABLE(table), GTK_WIDGET(inscroller), 0, 1, 0, 1);
 485     gtk_widget_set_size_request(GTK_WIDGET(inscroller), 300, -1);
 486     gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(inscroller), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 487     gtk_widget_show(GTK_WIDGET(inscroller));
 488
 489     // list store / tree view
 490     inlist = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN);
 491     inview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(inlist));
 492     gtk_container_add(GTK_CONTAINER(inscroller), inview);
 493     gtk_widget_show(GTK_WIDGET(inview));
 494
 495     // text column
 496     col = gtk_tree_view_column_new();
 497     gtk_tree_view_column_set_expand(col, TRUE);
 498     gtk_tree_view_column_set_title(col, "Available JACK Audio Outputs");
 499     renderer = gtk_cell_renderer_text_new();
 500     gtk_tree_view_column_pack_start(col, renderer, TRUE);
 501     gtk_tree_view_column_add_attribute(col, renderer, "text", 1);
 502     gtk_tree_view_append_column(GTK_TREE_VIEW(inview), col);
 503
 504     // toggle column
 505     col = gtk_tree_view_column_new();
 506     gtk_tree_view_column_set_expand(col, FALSE);
 507     gtk_tree_view_column_set_title(col, "⬌");
 508     renderer = gtk_cell_renderer_toggle_new();
 509     gtk_tree_view_column_pack_start(col, renderer, FALSE);
 510     gtk_tree_view_column_add_attribute(col, renderer, "active", 2);
 511     gtk_tree_view_append_column(GTK_TREE_VIEW(inview), col);
 512     g_signal_connect(GTK_OBJECT(renderer), "toggled", G_CALLBACK(inconnector_clicked), (gpointer*)this);
 513
 514
 515     gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(inview)),
 516                                 GTK_SELECTION_NONE);
 517
 518     g_object_unref(inlist);
 519
 520     // OUTPUT LIST
 521
 522     // scroller
 523     outscroller = gtk_scrolled_window_new(NULL, NULL);
 524     gtk_table_attach_defaults(GTK_TABLE(table), GTK_WIDGET(outscroller), 4, 5, 0, 2);
 525     gtk_widget_set_size_request(GTK_WIDGET(outscroller), 280, -1);
 526     gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(outscroller), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 527     gtk_widget_show(GTK_WIDGET(outscroller));
 528
 529     // list store / tree view
 530     outlist = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN);
 531     outview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(outlist));
 532     gtk_container_add(GTK_CONTAINER(outscroller), outview);
 533     gtk_widget_show(GTK_WIDGET(outview));
 534
 535     // toggle column
 536     col = gtk_tree_view_column_new();
 537     gtk_tree_view_column_set_title(col, "⬌");
 538     renderer = gtk_cell_renderer_toggle_new();
 539     gtk_tree_view_column_pack_start(col, renderer, FALSE);
 540     gtk_tree_view_column_add_attribute(col, renderer, "active", 2);
 541     gtk_tree_view_append_column(GTK_TREE_VIEW(outview), col);
 542     g_signal_connect(GTK_OBJECT(renderer), "toggled", G_CALLBACK(outconnector_clicked), (gpointer*)this);
 543
 544     // text column
 545     col = gtk_tree_view_column_new();
 546     gtk_tree_view_column_set_title(col, "Available JACK Audio Inputs");
 547     renderer = gtk_cell_renderer_text_new();
 548     gtk_tree_view_column_pack_start(col, renderer, TRUE);
 549     gtk_tree_view_column_add_attribute(col, renderer, "text", 1);
 550     gtk_tree_view_append_column(GTK_TREE_VIEW(outview), col);
 551
 552     gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(outview)),
 553                                 GTK_SELECTION_NONE);
 554
 555     g_object_unref(outlist);
 556
 557     // MIDI LIST
 558
 559     // scroller
 560     midiscroller = gtk_scrolled_window_new(NULL, NULL);
 561     gtk_table_attach(GTK_TABLE(table), GTK_WIDGET(midiscroller), 0, 1, 1, 2, (GtkAttachOptions)(GTK_FILL|GTK_EXPAND), (GtkAttachOptions)(GTK_FILL), 0, 0);
 562     gtk_widget_set_size_request(GTK_WIDGET(midiscroller), 280, -1);
 563     gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(midiscroller), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 564     gtk_widget_show(GTK_WIDGET(midiscroller));
 565
 566     // list store / tree view
 567     midilist = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN);
 568     midiview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(midilist));
 569     gtk_container_add(GTK_CONTAINER(midiscroller), midiview);
 570     gtk_widget_show(GTK_WIDGET(midiview));
 571
 572     // text column
 573     col = gtk_tree_view_column_new();
 574     gtk_tree_view_column_set_expand(col, TRUE);
 575     gtk_tree_view_column_set_title(col, "Available JACK MIDI Outputs");
 576     renderer = gtk_cell_renderer_text_new();
 577     gtk_tree_view_column_pack_start(col, renderer, TRUE);
 578     gtk_tree_view_column_add_attribute(col, renderer, "text", 1);
 579     gtk_tree_view_append_column(GTK_TREE_VIEW(midiview), col);
 580
 581     // toggle column
 582     col = gtk_tree_view_column_new();
 583     gtk_tree_view_column_set_expand(col, FALSE);
 584     gtk_tree_view_column_set_title(col, "⬌");
 585     renderer = gtk_cell_renderer_toggle_new();
 586     gtk_tree_view_column_pack_start(col, renderer, FALSE);
 587     gtk_tree_view_column_add_attribute(col, renderer, "active", 2);
 588     gtk_tree_view_append_column(GTK_TREE_VIEW(midiview), col);
 589     g_signal_connect(GTK_OBJECT(renderer), "toggled", G_CALLBACK(midiconnector_clicked), (gpointer*)this);
 590
 591     gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(midiview)),
 592                                 GTK_SELECTION_NONE);
 593
 594     g_object_unref(midilist);
 595
 596     // ALL THOSE PORT BUTTONS
 597
 598     active_in = active_out = active_midi = NULL;
 599     GtkRadioButton *last  = NULL;
 600     GtkRadioButton *first = NULL;
 601     int c = 0;
 602     // Inputs
 603     for (int i = 0; i < strip->plugin->in_count; i++) {
 604         sprintf(buf, "Input #%d", (i + 1));
 605         GtkWidget *in = gtk_radio_button_new_with_label(NULL, buf);
 606         gtk_box_pack_start(GTK_BOX(inputs), in, false, true, 0);
 607         gtk_widget_show(GTK_WIDGET(in));
 608         if (!i)
 609             last = GTK_RADIO_BUTTON(in);
 610         else
 611             gtk_radio_button_set_group(GTK_RADIO_BUTTON(in), gtk_radio_button_get_group(last));
 612         inports[c].type = 0;
 613         inports[c].id = c;
 614         inports[c].connector = this;
 615         g_signal_connect(GTK_OBJECT(in), "clicked", G_CALLBACK(inport_clicked), (gpointer*)&inports[c]);
 616         if (!first) {
 617             first = GTK_RADIO_BUTTON(in);
 618             active_in = &inports[c];
 619             gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(first), TRUE);
 620         }
 621         c++;
 622     }
 623     if (!c) {
 624         gtk_widget_set_sensitive(GTK_WIDGET(inframe), FALSE);
 625         gtk_widget_set_sensitive(GTK_WIDGET(inview), FALSE);
 626         gtk_widget_set_sensitive(GTK_WIDGET(inbut), FALSE);
 627         gtk_widget_hide(GTK_WIDGET(inbut));
 628     }
 629     first = NULL;
 630     last  = NULL;
 631     c = 0;
 632     // Outputs
 633     for (int i = 0; i < strip->plugin->out_count; i++) {
 634         sprintf(buf, "Output #%d", (i + 1));
 635         GtkWidget *out = gtk_radio_button_new_with_label(NULL, buf);
 636         gtk_box_pack_start(GTK_BOX(outputs), out, false, true, 0);
 637         gtk_widget_show(GTK_WIDGET(out));
 638         if (!i and !last)
 639             last = GTK_RADIO_BUTTON(out);
 640         else
 641             gtk_radio_button_set_group(GTK_RADIO_BUTTON(out), gtk_radio_button_get_group(last));
 642         outports[c].type = 1;
 643         outports[c].id = c;
 644         outports[c].connector = this;
 645         g_signal_connect(GTK_OBJECT(out), "clicked", G_CALLBACK(outport_clicked), (gpointer*)&outports[c]);
 646         if (!first) {
 647             first = GTK_RADIO_BUTTON(out);
 648             active_out = &outports[c];
 649             gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(first), TRUE);
 650         }
 651         c++;
 652     }
 653     if (!c) {
 654         gtk_widget_set_sensitive(GTK_WIDGET(outframe), FALSE);
 655         gtk_widget_set_sensitive(GTK_WIDGET(outview), FALSE);
 656         gtk_widget_set_sensitive(GTK_WIDGET(outbut), FALSE);
 657         gtk_widget_hide(GTK_WIDGET(outbut));
 658     }
 659     first = NULL;
 660     last  = NULL;
 661     c = 0;
 662     // MIDI
 663     if (strip->plugin->get_metadata_iface()->get_midi()) {
 664         GtkWidget *mid = gtk_radio_button_new_with_label(NULL, "MIDI");
 665         gtk_box_pack_start(GTK_BOX(midi), mid, false, true, 0);
 666         midiports[c].type = 2;
 667         midiports[c].id = c;
 668         midiports[c].connector = this;
 669         g_signal_connect(GTK_OBJECT(mid), "clicked", G_CALLBACK(midiport_clicked), (gpointer*)&midiports[c]);
 670         gtk_widget_show(GTK_WIDGET(mid));
 671         if (!first) {
 672             first = GTK_RADIO_BUTTON(mid);
 673             active_midi = &midiports[c];
 674             gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(first), TRUE);
 675         }
 676         c++;
 677     }
 678     if (!c) {
 679         //gtk_widget_set_sensitive(GTK_WIDGET(midiframe), FALSE);
 680         //gtk_widget_set_sensitive(GTK_WIDGET(midiview), FALSE);
 681         //gtk_widget_set_sensitive(GTK_WIDGET(midibut), FALSE);
 682         gtk_widget_hide(GTK_WIDGET(midiview));
 683         gtk_widget_hide(GTK_WIDGET(midibut));
 684         gtk_container_child_set(GTK_CONTAINER(table), GTK_WIDGET(inscroller), "bottom-attach", 2, NULL);
 685     }
 686
 687     // JACK STUFF
 688
 689     jackclient = strip->plugin->client->client;
 690
 691     //jack_set_port_connect_callback(jackclient, jack_port_connect_callback, this);
 692     //jack_set_port_rename_callback(jackclient, jack_port_rename_callback, this);
 693     //jack_set_port_registration_callback(jackclient, jack_port_registration_callback , this);
 694
 695     fill_inlist(this);
 696     fill_outlist(this);
 697     fill_midilist(this);
 698 }