diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/jalv.c | 469 | ||||
| -rw-r--r-- | src/jalv_console.c | 50 | ||||
| -rw-r--r-- | src/jalv_gtk2.c | 76 | ||||
| -rw-r--r-- | src/jalv_internal.h | 64 | ||||
| -rw-r--r-- | src/jalv_qt4.cpp | 59 |
5 files changed, 718 insertions, 0 deletions
diff --git a/src/jalv.c b/src/jalv.c new file mode 100644 index 0000000..f2c3a1f --- /dev/null +++ b/src/jalv.c @@ -0,0 +1,469 @@ +/* + Copyright 2007-2011 David Robillard <http://drobilla.net> + + Permission to use, copy, modify, and/or distribute this software for any + purpose with or without fee is hereby granted, provided that the above + copyright notice and this permission notice appear in all copies. + + THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#define _XOPEN_SOURCE 500 + +#include <math.h> +#include <signal.h> +#include <stdbool.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include <jack/jack.h> +#include <jack/midiport.h> +#include <jack/session.h> + +#include "lv2/lv2plug.in/ns/ext/event/event-helpers.h" +#include "lv2/lv2plug.in/ns/ext/event/event.h" +#include "lv2/lv2plug.in/ns/ext/uri-map/uri-map.h" + +#include "lilv/lilv.h" + +#include "suil/suil.h" + +#include "jalv_internal.h" +#include "jalv-config.h" + +sem_t exit_sem; /**< Exit semaphore */ + +#define MIDI_BUFFER_SIZE 1024 + +enum PortType { + CONTROL, + AUDIO, + EVENT +}; + +struct Port { + const LilvPort* lilv_port; + enum PortType type; + jack_port_t* jack_port; /**< For audio/MIDI ports, otherwise NULL */ + float control; /**< For control ports, otherwise 0.0f */ + LV2_Event_Buffer* ev_buffer; /**< For MIDI ports, otherwise NULL */ + bool is_input; +}; + +/** URI map feature, for event types (we use only MIDI) */ +#define MIDI_EVENT_ID 1 +uint32_t +uri_to_id(LV2_URI_Map_Callback_Data callback_data, + const char* map, + const char* uri) +{ + /* Note a non-trivial host needs to use an actual dictionary here */ + if (!strcmp(map, LV2_EVENT_URI) && !strcmp(uri, LILV_URI_MIDI_EVENT)) + return MIDI_EVENT_ID; + else + return 0; /* Refuse to map ID */ +} + +#define NS_EXT "http://lv2plug.in/ns/ext/" + +static LV2_URI_Map_Feature uri_map = { NULL, &uri_to_id }; +static const LV2_Feature uri_map_feature = { NS_EXT "uri-map", &uri_map }; + +const LV2_Feature* features[2] = { &uri_map_feature, NULL }; + +/** Abort and exit on error */ +static void +die(const char* msg) +{ + fprintf(stderr, "%s\n", msg); + exit(EXIT_FAILURE); +} + +/** Creates a port and connects the plugin instance to its data location. + * + * For audio ports, creates a jack port and connects plugin port to buffer. + * + * For control ports, sets controls array to default value and connects plugin + * port to that element. + */ +void +create_port(Jalv* host, + uint32_t port_index, + float default_value) +{ + struct Port* const port = &host->ports[port_index]; + + port->lilv_port = lilv_plugin_get_port_by_index(host->plugin, port_index); + port->jack_port = NULL; + port->control = 0.0f; + port->ev_buffer = NULL; + + lilv_instance_connect_port(host->instance, port_index, NULL); + + /* Get the port symbol for console printing */ + const LilvNode* symbol = lilv_port_get_symbol(host->plugin, port->lilv_port); + const char* symbol_str = lilv_node_as_string(symbol); + + enum JackPortFlags jack_flags = 0; + if (lilv_port_is_a(host->plugin, port->lilv_port, host->input_class)) { + jack_flags = JackPortIsInput; + port->is_input = true; + } else if (lilv_port_is_a(host->plugin, port->lilv_port, host->output_class)) { + jack_flags = JackPortIsOutput; + port->is_input = false; + } else if (lilv_port_has_property(host->plugin, port->lilv_port, host->optional)) { + lilv_instance_connect_port(host->instance, port_index, NULL); + } else { + die("Mandatory port has unknown type (neither input or output)"); + } + + /* Set control values */ + if (lilv_port_is_a(host->plugin, port->lilv_port, host->control_class)) { + port->type = CONTROL; + port->control = isnan(default_value) ? 0.0 : default_value; + printf("%s = %f\n", symbol_str, host->ports[port_index].control); + } else if (lilv_port_is_a(host->plugin, port->lilv_port, host->audio_class)) { + port->type = AUDIO; + } else if (lilv_port_is_a(host->plugin, port->lilv_port, host->event_class)) { + port->type = EVENT; + } + + /* Connect the port based on its type */ + switch (port->type) { + case CONTROL: + lilv_instance_connect_port(host->instance, port_index, &port->control); + break; + case AUDIO: + port->jack_port = jack_port_register( + host->jack_client, symbol_str, JACK_DEFAULT_AUDIO_TYPE, jack_flags, 0); + break; + case EVENT: + port->jack_port = jack_port_register( + host->jack_client, symbol_str, JACK_DEFAULT_MIDI_TYPE, jack_flags, 0); + port->ev_buffer = lv2_event_buffer_new(MIDI_BUFFER_SIZE, LV2_EVENT_AUDIO_STAMP); + lilv_instance_connect_port(host->instance, port_index, port->ev_buffer); + break; + default: + /* FIXME: check if port connection is optional and die if not */ + lilv_instance_connect_port(host->instance, port_index, NULL); + fprintf(stderr, "WARNING: Unknown port type, port not connected.\n"); + } +} + +/** Jack process callback. */ +int +jack_process_cb(jack_nframes_t nframes, void* data) +{ + Jalv* const host = (Jalv*)data; + + /* Prepare port buffers */ + for (uint32_t p = 0; p < host->num_ports; ++p) { + if (!host->ports[p].jack_port) + continue; + + if (host->ports[p].type == AUDIO) { + /* Connect plugin port directly to Jack port buffer. */ + lilv_instance_connect_port( + host->instance, p, + jack_port_get_buffer(host->ports[p].jack_port, nframes)); + + } else if (host->ports[p].type == EVENT) { + /* Clear Jack event port buffer. */ + lv2_event_buffer_reset(host->ports[p].ev_buffer, + LV2_EVENT_AUDIO_STAMP, + (uint8_t*)(host->ports[p].ev_buffer + 1)); + + if (host->ports[p].is_input) { + void* buf = jack_port_get_buffer(host->ports[p].jack_port, + nframes); + + LV2_Event_Iterator iter; + lv2_event_begin(&iter, host->ports[p].ev_buffer); + + for (uint32_t i = 0; i < jack_midi_get_event_count(buf); ++i) { + jack_midi_event_t ev; + jack_midi_event_get(&ev, buf, i); + lv2_event_write(&iter, + ev.time, 0, + MIDI_EVENT_ID, ev.size, ev.buffer); + } + } + } + } + + /* Run plugin for this cycle */ + lilv_instance_run(host->instance, nframes); + + /* Deliver MIDI output */ + for (uint32_t p = 0; p < host->num_ports; ++p) { + if (host->ports[p].jack_port + && !host->ports[p].is_input + && host->ports[p].type == EVENT) { + + void* buf = jack_port_get_buffer(host->ports[p].jack_port, + nframes); + + jack_midi_clear_buffer(buf); + + LV2_Event_Iterator iter; + lv2_event_begin(&iter, host->ports[p].ev_buffer); + + for (uint32_t i = 0; i < iter.buf->event_count; ++i) { + uint8_t* data; + LV2_Event* ev = lv2_event_get(&iter, &data); + jack_midi_event_write(buf, ev->frames, data, ev->size); + lv2_event_increment(&iter); + } + } + } + + return 0; +} + +#ifdef JALV_JACK_SESSION +void +jack_session_cb(jack_session_event_t* event, void* arg) +{ + Jalv* host = (Jalv*)arg; + + char cmd[256]; + snprintf(cmd, sizeof(cmd), "jalv %s %s", + lilv_node_as_uri(lilv_plugin_get_uri(host->plugin)), + event->client_uuid); + + event->command_line = strdup(cmd); + jack_session_reply(host->jack_client, event); + + switch (event->type) { + case JackSessionSave: + break; + case JackSessionSaveAndQuit: + sem_post(&exit_sem); + break; + case JackSessionSaveTemplate: + break; + } + + jack_session_event_free(event); +} +#endif /* JALV_JACK_SESSION */ + +static void +lv2_ui_write(SuilController controller, + uint32_t port_index, + uint32_t buffer_size, + uint32_t format, + const void* buffer) +{ + fprintf(stderr, "UI WRITE\n"); +} + +static void +signal_handler(int ignored) +{ + sem_post(&exit_sem); +} + +int +main(int argc, char** argv) +{ + jalv_init(&argc, &argv); + + Jalv host; + host.jack_client = NULL; + host.num_ports = 0; + host.ports = NULL; + + sem_init(&exit_sem, 0, 0); + host.done = &exit_sem; + + signal(SIGINT, signal_handler); + signal(SIGTERM, signal_handler); + + /* Find all installed plugins */ + LilvWorld* world = lilv_world_new(); + lilv_world_load_all(world); + host.world = world; + const LilvPlugins* plugins = lilv_world_get_all_plugins(world); + + /* Set up the port classes this app supports */ + host.input_class = lilv_new_uri(world, LILV_URI_INPUT_PORT); + host.output_class = lilv_new_uri(world, LILV_URI_OUTPUT_PORT); + host.control_class = lilv_new_uri(world, LILV_URI_CONTROL_PORT); + host.audio_class = lilv_new_uri(world, LILV_URI_AUDIO_PORT); + host.event_class = lilv_new_uri(world, LILV_URI_EVENT_PORT); + host.midi_class = lilv_new_uri(world, LILV_URI_MIDI_EVENT); + host.optional = lilv_new_uri(world, LILV_NS_LV2 + "connectionOptional"); + +#ifdef JALV_JACK_SESSION + if (argc != 2 && argc != 3) { + fprintf(stderr, "Usage: %s PLUGIN_URI [JACK_UUID]\n", argv[0]); +#else + if (argc != 2) { + fprintf(stderr, "Usage: %s PLUGIN_URI\n", argv[0]); +#endif + lilv_world_free(world); + return EXIT_FAILURE; + } + + const char* const plugin_uri_str = argv[1]; + + printf("Plugin: %s\n", plugin_uri_str); + + /* Get the plugin */ + LilvNode* plugin_uri = lilv_new_uri(world, plugin_uri_str); + host.plugin = lilv_plugins_get_by_uri(plugins, plugin_uri); + lilv_node_free(plugin_uri); + if (!host.plugin) { + fprintf(stderr, "Failed to find plugin %s.\n", plugin_uri_str); + lilv_world_free(world); + return EXIT_FAILURE; + } + + /* Get a plugin UI */ + LilvNode* native_ui_type = jalv_native_ui_type(&host); + const LilvUI* ui = NULL; + const LilvNode* ui_type = NULL; + if (native_ui_type) { + LilvUIs* uis = lilv_plugin_get_uis(host.plugin); // FIXME: leak + LILV_FOREACH(uis, u, uis) { + const LilvUI* this_ui = lilv_uis_get(uis, u); + if (lilv_ui_is_supported(this_ui, + suil_ui_supported, + native_ui_type, + &ui_type)) { + // TODO: Multiple UI support + ui = this_ui; + break; + } + } + } + + if (ui) { + fprintf(stderr, "UI: %s\n", + lilv_node_as_uri(lilv_ui_get_uri(ui))); + } else { + fprintf(stderr, "No appropriate UI found\n"); + } + + /* Get the plugin's name */ + LilvNode* name = lilv_plugin_get_name(host.plugin); + const char* name_str = lilv_node_as_string(name); + + /* Truncate plugin name to suit JACK (if necessary) */ + char* jack_name = NULL; + if (strlen(name_str) >= (unsigned)jack_client_name_size() - 1) { + jack_name = calloc(jack_client_name_size(), sizeof(char)); + strncpy(jack_name, name_str, jack_client_name_size() - 1); + } else { + jack_name = strdup(name_str); + } + + /* Connect to JACK */ + printf("JACK Name: %s\n\n", jack_name); +#ifdef JALV_JACK_SESSION + const char* const jack_uuid_str = (argc > 2) ? argv[2] : NULL; + if (jack_uuid_str) { + host.jack_client = jack_client_open(jack_name, JackSessionID, NULL, + jack_uuid_str); + } +#endif + + if (!host.jack_client) { + host.jack_client = jack_client_open(jack_name, JackNullOption, NULL); + } + + free(jack_name); + lilv_node_free(name); + + if (!host.jack_client) + die("Failed to connect to JACK.\n"); + + /* Instantiate the plugin */ + host.instance = lilv_plugin_instantiate( + host.plugin, jack_get_sample_rate(host.jack_client), features); + if (!host.instance) + die("Failed to instantiate plugin.\n"); + + /* Set Jack callbacks */ + jack_set_process_callback(host.jack_client, &jack_process_cb, (void*)(&host)); +#ifdef JALV_JACK_SESSION + jack_set_session_callback(host.jack_client, &jack_session_cb, (void*)(&host)); +#endif + + /* Create ports */ + host.num_ports = lilv_plugin_get_num_ports(host.plugin); + host.ports = calloc((size_t)host.num_ports, sizeof(struct Port)); + float* default_values = calloc(lilv_plugin_get_num_ports(host.plugin), + sizeof(float)); + lilv_plugin_get_port_ranges_float(host.plugin, NULL, NULL, default_values); + + for (uint32_t i = 0; i < host.num_ports; ++i) + create_port(&host, i, default_values[i]); + + free(default_values); + + /* Activate plugin and JACK */ + lilv_instance_activate(host.instance); + jack_activate(host.jack_client); + + SuilHost* ui_host = suil_host_new(lv2_ui_write, NULL, NULL, NULL); + + /* Instantiate the UI */ + SuilInstance* instance = suil_instance_new( + ui_host, + &host, + lilv_node_as_uri(native_ui_type), + lilv_node_as_uri(lilv_plugin_get_uri(host.plugin)), + lilv_node_as_uri(lilv_ui_get_uri(ui)), + lilv_node_as_uri(ui_type), + lilv_uri_to_path(lilv_node_as_uri(lilv_ui_get_bundle_uri(ui))), + lilv_uri_to_path(lilv_node_as_uri(lilv_ui_get_binary_uri(ui))), + NULL); + + /* Run UI */ + jalv_open_ui(&host, instance); + + /* Wait for finish signal from UI or signal handler */ + sem_wait(&exit_sem); + + fprintf(stderr, "Exiting...\n"); + + /* Deactivate JACK */ + jack_deactivate(host.jack_client); + for (uint32_t i = 0; i < host.num_ports; ++i) { + if (host.ports[i].ev_buffer) { + free(host.ports[i].ev_buffer); + } + } + jack_client_close(host.jack_client); + + /* Deactivate plugin */ + lilv_instance_deactivate(host.instance); + lilv_instance_free(host.instance); + + /* Clean up */ + free(host.ports); + lilv_node_free(native_ui_type); + lilv_node_free(host.input_class); + lilv_node_free(host.output_class); + lilv_node_free(host.control_class); + lilv_node_free(host.audio_class); + lilv_node_free(host.event_class); + lilv_node_free(host.midi_class); + lilv_node_free(host.optional); + suil_host_free(ui_host); + lilv_world_free(world); + + sem_destroy(&exit_sem); + + return 0; +} diff --git a/src/jalv_console.c b/src/jalv_console.c new file mode 100644 index 0000000..48c3ed3 --- /dev/null +++ b/src/jalv_console.c @@ -0,0 +1,50 @@ +/* + Copyright 2007-2011 David Robillard <http://drobilla.net> + + Permission to use, copy, modify, and/or distribute this software for any + purpose with or without fee is hereby granted, provided that the above + copyright notice and this permission notice appear in all copies. + + THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#include <stdio.h> + +#include "jalv-config.h" +#include "jalv_internal.h" + +void +jalv_init(int* argc, char*** argv) +{ +} + +LilvNode* +jalv_native_ui_type(Jalv* jalv) +{ + return NULL; +} + +int +jalv_open_ui(Jalv* jalv, + SuilInstance* instance) +{ +#ifdef JALV_JACK_SESSION + printf("\nPress Ctrl-C to quit: "); + fflush(stdout); + //g_cond_wait(exit_cond, exit_mutex); +#else + printf("\nPress enter to quit: "); + fflush(stdout); + getc(stdin); + sem_post(jalv->done); +#endif + printf("\n"); + + return 0; +} diff --git a/src/jalv_gtk2.c b/src/jalv_gtk2.c new file mode 100644 index 0000000..72c8a1a --- /dev/null +++ b/src/jalv_gtk2.c @@ -0,0 +1,76 @@ +/* + Copyright 2007-2011 David Robillard <http://drobilla.net> + + Permission to use, copy, modify, and/or distribute this software for any + purpose with or without fee is hereby granted, provided that the above + copyright notice and this permission notice appear in all copies. + + THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#include <gtk/gtk.h> + +#include "jalv_internal.h" + +static void destroy(GtkWidget* widget, + gpointer data) +{ + gtk_main_quit(); +} + +void +jalv_init(int* argc, char*** argv) +{ + GError* error = NULL; + gtk_init_with_args( + argc, argv, + "PLUGIN_URI [JACK_UUID] - Run an LV2 plugin as a Jack application", + NULL, NULL, &error); +} + +LilvNode* +jalv_native_ui_type(Jalv* jalv) +{ + return lilv_new_uri(jalv->world, + "http://lv2plug.in/ns/extensions/ui#GtkUI"); +} + +int +jalv_open_ui(Jalv* jalv, + SuilInstance* instance) +{ + GtkWidget* window = gtk_window_new(GTK_WINDOW_TOPLEVEL); + + g_signal_connect(window, "destroy", + G_CALLBACK(destroy), NULL); + + gtk_container_set_border_width(GTK_CONTAINER(window), 8); + + if (instance) { + GtkWidget* widget = (GtkWidget*)suil_instance_get_widget(instance); + gtk_container_add(GTK_CONTAINER(window), widget); + } else { + GtkWidget* button = gtk_button_new_with_label("Close"); + + g_signal_connect_swapped(button, "clicked", + G_CALLBACK(gtk_widget_destroy), + window); + + gtk_container_add(GTK_CONTAINER(window), button); + } + + // TODO: Check UI properties for resizable + gtk_window_set_resizable(GTK_WINDOW(window), false); + + gtk_widget_show_all(window); + + gtk_main(); + sem_post(jalv->done); + return 0; +} diff --git a/src/jalv_internal.h b/src/jalv_internal.h new file mode 100644 index 0000000..f4dc6d4 --- /dev/null +++ b/src/jalv_internal.h @@ -0,0 +1,64 @@ +/* + Copyright 2007-2011 David Robillard <http://drobilla.net> + + Permission to use, copy, modify, and/or distribute this software for any + purpose with or without fee is hereby granted, provided that the above + copyright notice and this permission notice appear in all copies. + + THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#ifndef JALV_INTERNAL_H +#define JALV_INTERNAL_H + +#include <semaphore.h> + +#include <jack/jack.h> + +#include "lilv/lilv.h" + +#include "suil/suil.h" + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct { + LilvWorld* world; /**< Lilv World */ + jack_client_t* jack_client; /**< Jack client */ + sem_t* done; /**< Exit semaphore */ + const LilvPlugin* plugin; /**< Plugin class (RDF data) */ + LilvInstance* instance; /**< Plugin instance (shared library) */ + uint32_t num_ports; /**< Size of the two following arrays: */ + struct Port* ports; /**< Port array of size num_ports */ + LilvNode* input_class; /**< Input port class (URI) */ + LilvNode* output_class; /**< Output port class (URI) */ + LilvNode* control_class; /**< Control port class (URI) */ + LilvNode* audio_class; /**< Audio port class (URI) */ + LilvNode* event_class; /**< Event port class (URI) */ + LilvNode* midi_class; /**< MIDI event class (URI) */ + LilvNode* optional; /**< lv2:connectionOptional port property */ +} Jalv; + +void +jalv_init(int* argc, char*** argv); + +LilvNode* +jalv_native_ui_type(Jalv* jalv); + +int +jalv_open_ui(Jalv* jalv, + SuilInstance* instance); + + +#ifdef __cplusplus +} // extern "C" +#endif + +#endif // JALV_INTERNAL_H diff --git a/src/jalv_qt4.cpp b/src/jalv_qt4.cpp new file mode 100644 index 0000000..79cf985 --- /dev/null +++ b/src/jalv_qt4.cpp @@ -0,0 +1,59 @@ +/* + Copyright 2007-2011 David Robillard <http://drobilla.net> + + Permission to use, copy, modify, and/or distribute this software for any + purpose with or without fee is hereby granted, provided that the above + copyright notice and this permission notice appear in all copies. + + THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#include "jalv_internal.h" + +#include <QApplication> +#include <QPushButton> +#include <QMainWindow> + +static QApplication* app = NULL; + +extern "C" { + +void +jalv_init(int* argc, char*** argv) +{ + app = new QApplication(*argc, *argv, true); +} + +LilvNode* +jalv_native_ui_type(Jalv* jalv) +{ + return lilv_new_uri(jalv->world, + "http://lv2plug.in/ns/extensions/ui#Qt4UI"); +} + +int +jalv_open_ui(Jalv* jalv, + SuilInstance* instance) +{ + if (instance) { + QWidget* widget = (QWidget*)suil_instance_get_widget(instance); + widget->show(); + } else { + QPushButton* button = new QPushButton("Close"); + button->show(); + QObject::connect(button, SIGNAL(clicked()), app, SLOT(quit())); + } + app->connect(app, SIGNAL(lastWindowClosed()), app, SLOT(quit())); + + int ret = app->exec(); + sem_post(jalv->done); + return ret; +} + +} // extern "C" |