aboutsummaryrefslogtreecommitdiffstats
path: root/lv2/ui
diff options
context:
space:
mode:
Diffstat (limited to 'lv2/ui')
-rw-r--r--lv2/ui/lv2-ui.doap.ttl146
-rw-r--r--lv2/ui/manifest.ttl8
-rw-r--r--lv2/ui/ui.h445
-rw-r--r--lv2/ui/ui.ttl463
4 files changed, 1062 insertions, 0 deletions
diff --git a/lv2/ui/lv2-ui.doap.ttl b/lv2/ui/lv2-ui.doap.ttl
new file mode 100644
index 0000000..8b804b1
--- /dev/null
+++ b/lv2/ui/lv2-ui.doap.ttl
@@ -0,0 +1,146 @@
+@prefix dcs: <http://ontologi.es/doap-changeset#> .
+@prefix doap: <http://usefulinc.com/ns/doap#> .
+@prefix foaf: <http://xmlns.com/foaf/0.1/> .
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+
+<http://lv2plug.in/ns/extensions/ui>
+ a doap:Project ;
+ doap:license <http://opensource.org/licenses/isc> ;
+ doap:name "LV2 UI" ;
+ doap:shortdesc "LV2 plugin UIs of any type." ;
+ doap:created "2006-00-00" ;
+ doap:developer <http://lv2plug.in/ns/meta#larsl> ;
+ doap:maintainer <http://drobilla.net/drobilla#me> ;
+ doap:release [
+ doap:revision "2.20" ;
+ doap:created "2015-07-25" ;
+ doap:file-release <http://lv2plug.in/spec/lv2-1.14.0.tar.bz2> ;
+ dcs:blame <http://drobilla.net/drobilla#me> ;
+ dcs:changeset [
+ dcs:item [
+ rdfs:label "Improve documentation."
+ ] , [
+ rdfs:label "Add missing property labels."
+ ]
+ ]
+ ] , [
+ doap:revision "2.18" ;
+ doap:created "2014-08-08" ;
+ doap:file-release <http://lv2plug.in/spec/lv2-1.10.0.tar.bz2> ;
+ dcs:blame <http://drobilla.net/drobilla#me> ;
+ dcs:changeset [
+ dcs:item [
+ rdfs:label "Add show interface so UIs can gracefully degrade to separate windows if hosts can not use their widget directly."
+ ] , [
+ rdfs:label "Fix identifier typos in documentation."
+ ]
+ ]
+ ] , [
+ doap:revision "2.16" ;
+ doap:created "2014-01-04" ;
+ doap:file-release <http://lv2plug.in/spec/lv2-1.8.0.tar.bz2> ;
+ dcs:blame <http://drobilla.net/drobilla#me> ;
+ dcs:changeset [
+ dcs:item [
+ rdfs:label "Fix LV2_UI_INVALID_PORT_INDEX identifier in documentation."
+ ]
+ ]
+ ] , [
+ doap:revision "2.14" ;
+ doap:created "2013-03-18" ;
+ doap:file-release <http://lv2plug.in/spec/lv2-1.6.0.tar.bz2> ;
+ dcs:blame <http://drobilla.net/drobilla#me> ;
+ dcs:changeset [
+ dcs:item [
+ rdfs:label "Add idle interface so native UIs and foreign toolkits can drive their event loops."
+ ] , [
+ rdfs:label "Add ui:updateRate property."
+ ]
+ ]
+ ] , [
+ doap:revision "2.12" ;
+ doap:created "2012-12-01" ;
+ doap:file-release <http://lv2plug.in/spec/lv2-1.4.0.tar.bz2> ;
+ dcs:blame <http://drobilla.net/drobilla#me> ;
+ dcs:changeset [
+ dcs:item [
+ rdfs:label "Fix incorrect linker flag in ui:makeSONameResident documentation."
+ ]
+ ]
+ ] , [
+ doap:revision "2.10" ;
+ doap:created "2012-10-14" ;
+ doap:file-release <http://lv2plug.in/spec/lv2-1.2.0.tar.bz2> ;
+ dcs:blame <http://drobilla.net/drobilla#me> ;
+ dcs:changeset [
+ dcs:item [
+ rdfs:label "Add types for WindowsUI, CocoaUI, and Gtk3UI."
+ ] , [
+ rdfs:label "Use consistent label style."
+ ] , [
+ rdfs:label "Add missing LV2_SYMBOL_EXPORT declaration for lv2ui_descriptor prototype."
+ ]
+ ]
+ ] , [
+ doap:revision "2.8" ;
+ doap:created "2012-04-17" ;
+ doap:file-release <http://lv2plug.in/spec/lv2-1.0.0.tar.bz2> ;
+ dcs:blame <http://drobilla.net/drobilla#me> ;
+ dcs:changeset [
+ dcs:item [
+ rdfs:label "Add ui:parent and ui:resize."
+ ] , [
+ rdfs:label "Add support for referring to ports by symbol."
+ ] , [
+ rdfs:label "Add ui:portMap for accessing ports by symbol, allowing for UIs to be distributed separately from plugins."
+ ] , [
+ rdfs:label "Add port protocols and a dynamic notification subscription mechanism, for more flexible communication, and audio port metering without control port kludges."
+ ] , [
+ rdfs:label "Add touch feature to notify the host that the user has grabbed a control."
+ ] , [
+ rdfs:label "Merge with unified LV2 package."
+ ]
+ ]
+ ] , [
+ doap:revision "2.4" ;
+ doap:created "2011-11-21" ;
+ doap:file-release <http://lv2plug.in/spec/lv2-ui-2.4.tar.bz2> ;
+ dcs:blame <http://drobilla.net/drobilla#me> ;
+ dcs:changeset [
+ dcs:item [
+ rdfs:label "Deprecate ui:makeSONameResident."
+ ] , [
+ rdfs:label "Add Qt4 and X11 widget types."
+ ] , [
+ rdfs:label "Install header to URI-based system path."
+ ] , [
+ rdfs:label "Add pkg-config file."
+ ] , [
+ rdfs:label "Make ui.ttl a valid OWL 2 DL ontology."
+ ]
+ ]
+ ] , [
+ doap:revision "2.2" ;
+ doap:created "2011-05-26" ;
+ doap:file-release <http://lv2plug.in/spec/lv2-ui-2.2.tar.bz2> ;
+ dcs:blame <http://drobilla.net/drobilla#me> ;
+ dcs:changeset [
+ dcs:item [
+ rdfs:label "Add build system (for installation)."
+ ] , [
+ rdfs:label "Convert documentation to HTML and use lv2:documentation."
+ ] , [
+ rdfs:label "Use lv2:Specification to be discovered as an extension."
+ ]
+ ]
+ ] , [
+ doap:revision "2.0" ;
+ doap:created "2010-10-06" ;
+ doap:file-release <http://lv2plug.in/spec/lv2-ui-2.0.tar.gz> ;
+ dcs:blame <http://drobilla.net/drobilla#me> ;
+ dcs:changeset [
+ dcs:item [
+ rdfs:label "Initial release."
+ ]
+ ]
+ ] .
diff --git a/lv2/ui/manifest.ttl b/lv2/ui/manifest.ttl
new file mode 100644
index 0000000..384bf2e
--- /dev/null
+++ b/lv2/ui/manifest.ttl
@@ -0,0 +1,8 @@
+@prefix lv2: <http://lv2plug.in/ns/lv2core#> .
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+
+<http://lv2plug.in/ns/extensions/ui>
+ a lv2:Specification ;
+ lv2:minorVersion 2 ;
+ lv2:microVersion 20 ;
+ rdfs:seeAlso <ui.ttl> . \ No newline at end of file
diff --git a/lv2/ui/ui.h b/lv2/ui/ui.h
new file mode 100644
index 0000000..450a41e
--- /dev/null
+++ b/lv2/ui/ui.h
@@ -0,0 +1,445 @@
+/*
+ LV2 UI Extension
+ Copyright 2009-2016 David Robillard <d@drobilla.net>
+ Copyright 2006-2011 Lars Luthman <lars.luthman@gmail.com>
+
+ 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.
+*/
+
+/**
+ @defgroup ui User Interfaces
+
+ User interfaces of any type for plugins,
+ <http://lv2plug.in/ns/extensions/ui> for details.
+
+ @{
+*/
+
+#ifndef LV2_UI_H
+#define LV2_UI_H
+
+#include "lv2/core/lv2.h"
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#define LV2_UI_URI "http://lv2plug.in/ns/extensions/ui" ///< http://lv2plug.in/ns/extensions/ui
+#define LV2_UI_PREFIX LV2_UI_URI "#" ///< http://lv2plug.in/ns/extensions/ui#
+
+#define LV2_UI__CocoaUI LV2_UI_PREFIX "CocoaUI" ///< http://lv2plug.in/ns/extensions/ui#CocoaUI
+#define LV2_UI__Gtk3UI LV2_UI_PREFIX "Gtk3UI" ///< http://lv2plug.in/ns/extensions/ui#Gtk3UI
+#define LV2_UI__GtkUI LV2_UI_PREFIX "GtkUI" ///< http://lv2plug.in/ns/extensions/ui#GtkUI
+#define LV2_UI__PortNotification LV2_UI_PREFIX "PortNotification" ///< http://lv2plug.in/ns/extensions/ui#PortNotification
+#define LV2_UI__PortProtocol LV2_UI_PREFIX "PortProtocol" ///< http://lv2plug.in/ns/extensions/ui#PortProtocol
+#define LV2_UI__Qt4UI LV2_UI_PREFIX "Qt4UI" ///< http://lv2plug.in/ns/extensions/ui#Qt4UI
+#define LV2_UI__Qt5UI LV2_UI_PREFIX "Qt5UI" ///< http://lv2plug.in/ns/extensions/ui#Qt5UI
+#define LV2_UI__UI LV2_UI_PREFIX "UI" ///< http://lv2plug.in/ns/extensions/ui#UI
+#define LV2_UI__WindowsUI LV2_UI_PREFIX "WindowsUI" ///< http://lv2plug.in/ns/extensions/ui#WindowsUI
+#define LV2_UI__X11UI LV2_UI_PREFIX "X11UI" ///< http://lv2plug.in/ns/extensions/ui#X11UI
+#define LV2_UI__binary LV2_UI_PREFIX "binary" ///< http://lv2plug.in/ns/extensions/ui#binary
+#define LV2_UI__fixedSize LV2_UI_PREFIX "fixedSize" ///< http://lv2plug.in/ns/extensions/ui#fixedSize
+#define LV2_UI__idleInterface LV2_UI_PREFIX "idleInterface" ///< http://lv2plug.in/ns/extensions/ui#idleInterface
+#define LV2_UI__noUserResize LV2_UI_PREFIX "noUserResize" ///< http://lv2plug.in/ns/extensions/ui#noUserResize
+#define LV2_UI__notifyType LV2_UI_PREFIX "notifyType" ///< http://lv2plug.in/ns/extensions/ui#notifyType
+#define LV2_UI__parent LV2_UI_PREFIX "parent" ///< http://lv2plug.in/ns/extensions/ui#parent
+#define LV2_UI__plugin LV2_UI_PREFIX "plugin" ///< http://lv2plug.in/ns/extensions/ui#plugin
+#define LV2_UI__portIndex LV2_UI_PREFIX "portIndex" ///< http://lv2plug.in/ns/extensions/ui#portIndex
+#define LV2_UI__portMap LV2_UI_PREFIX "portMap" ///< http://lv2plug.in/ns/extensions/ui#portMap
+#define LV2_UI__portNotification LV2_UI_PREFIX "portNotification" ///< http://lv2plug.in/ns/extensions/ui#portNotification
+#define LV2_UI__portSubscribe LV2_UI_PREFIX "portSubscribe" ///< http://lv2plug.in/ns/extensions/ui#portSubscribe
+#define LV2_UI__protocol LV2_UI_PREFIX "protocol" ///< http://lv2plug.in/ns/extensions/ui#protocol
+#define LV2_UI__floatProtocol LV2_UI_PREFIX "floatProtocol" ///< http://lv2plug.in/ns/extensions/ui#floatProtocol
+#define LV2_UI__peakProtocol LV2_UI_PREFIX "peakProtocol" ///< http://lv2plug.in/ns/extensions/ui#peakProtocol
+#define LV2_UI__resize LV2_UI_PREFIX "resize" ///< http://lv2plug.in/ns/extensions/ui#resize
+#define LV2_UI__showInterface LV2_UI_PREFIX "showInterface" ///< http://lv2plug.in/ns/extensions/ui#showInterface
+#define LV2_UI__touch LV2_UI_PREFIX "touch" ///< http://lv2plug.in/ns/extensions/ui#touch
+#define LV2_UI__ui LV2_UI_PREFIX "ui" ///< http://lv2plug.in/ns/extensions/ui#ui
+#define LV2_UI__updateRate LV2_UI_PREFIX "updateRate" ///< http://lv2plug.in/ns/extensions/ui#updateRate
+#define LV2_UI__windowTitle LV2_UI_PREFIX "windowTitle" ///< http://lv2plug.in/ns/extensions/ui#windowTitle
+
+/**
+ The index returned by LV2UI_Port_Map::port_index() for unknown ports.
+*/
+#define LV2UI_INVALID_PORT_INDEX ((uint32_t)-1)
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ A pointer to some widget or other type of UI handle.
+
+ The actual type is defined by the type of the UI.
+*/
+typedef void* LV2UI_Widget;
+
+/**
+ A pointer to UI instance internals.
+
+ The host may compare this to NULL, but otherwise MUST NOT interpret it.
+*/
+typedef void* LV2UI_Handle;
+
+/**
+ A pointer to a controller provided by the host.
+
+ The UI may compare this to NULL, but otherwise MUST NOT interpret it.
+*/
+typedef void* LV2UI_Controller;
+
+/**
+ A pointer to opaque data for a feature.
+*/
+typedef void* LV2UI_Feature_Handle;
+
+/**
+ A host-provided function that sends data to a plugin's input ports.
+
+ @param controller The opaque controller pointer passed to
+ LV2UI_Descriptor::instantiate().
+
+ @param port_index Index of the port to update.
+
+ @param buffer Buffer containing `buffer_size` bytes of data.
+
+ @param buffer_size Size of `buffer` in bytes.
+
+ @param port_protocol Either 0 or the URID for a ui:PortProtocol. If 0, the
+ protocol is implicitly ui:floatProtocol, the port MUST be an lv2:ControlPort
+ input, `buffer` MUST point to a single float value, and `buffer_size` MUST
+ be sizeof(float). The UI SHOULD NOT use a protocol not supported by the
+ host, but the host MUST gracefully ignore any protocol it does not
+ understand.
+*/
+typedef void (*LV2UI_Write_Function)(LV2UI_Controller controller,
+ uint32_t port_index,
+ uint32_t buffer_size,
+ uint32_t port_protocol,
+ const void* buffer);
+
+/**
+ A plugin UI.
+
+ A pointer to an object of this type is returned by the lv2ui_descriptor()
+ function.
+*/
+typedef struct _LV2UI_Descriptor {
+ /**
+ The URI for this UI (not for the plugin it controls).
+ */
+ const char* URI;
+
+ /**
+ Create a new UI and return a handle to it. This function works
+ similarly to LV2_Descriptor::instantiate().
+
+ @param descriptor The descriptor for the UI to instantiate.
+
+ @param plugin_uri The URI of the plugin that this UI will control.
+
+ @param bundle_path The path to the bundle containing this UI, including
+ the trailing directory separator.
+
+ @param write_function A function that the UI can use to send data to the
+ plugin's input ports.
+
+ @param controller A handle for the UI instance to be passed as the
+ first parameter of UI methods.
+
+ @param widget (output) widget pointer. The UI points this at its main
+ widget, which has the type defined by the UI type in the data file.
+
+ @param features An array of LV2_Feature pointers. The host must pass
+ all feature URIs that it and the UI supports and any additional data, as
+ in LV2_Descriptor::instantiate(). Note that UI features and plugin
+ features are not necessarily the same.
+
+ */
+ LV2UI_Handle (*instantiate)(const struct _LV2UI_Descriptor* descriptor,
+ const char* plugin_uri,
+ const char* bundle_path,
+ LV2UI_Write_Function write_function,
+ LV2UI_Controller controller,
+ LV2UI_Widget* widget,
+ const LV2_Feature* const* features);
+
+
+ /**
+ Destroy the UI. The host must not try to access the widget after
+ calling this function.
+ */
+ void (*cleanup)(LV2UI_Handle ui);
+
+ /**
+ Tell the UI that something interesting has happened at a plugin port.
+
+ What is "interesting" and how it is written to `buffer` is defined by
+ `format`, which has the same meaning as in LV2UI_Write_Function().
+ Format 0 is a special case for lv2:ControlPort, where this function
+ should be called when the port value changes (but not necessarily for
+ every change), `buffer_size` must be sizeof(float), and `buffer`
+ points to a single IEEE-754 float.
+
+ By default, the host should only call this function for lv2:ControlPort
+ inputs. However, the UI can request updates for other ports statically
+ with ui:portNotification or dynamicaly with ui:portSubscribe.
+
+ The UI MUST NOT retain any reference to `buffer` after this function
+ returns, it is only valid for the duration of the call.
+
+ This member may be NULL if the UI is not interested in any port events.
+ */
+ void (*port_event)(LV2UI_Handle ui,
+ uint32_t port_index,
+ uint32_t buffer_size,
+ uint32_t format,
+ const void* buffer);
+
+ /**
+ Return a data structure associated with an extension URI, typically an
+ interface struct with additional function pointers
+
+ This member may be set to NULL if the UI is not interested in supporting
+ any extensions. This is similar to LV2_Descriptor::extension_data().
+
+ */
+ const void* (*extension_data)(const char* uri);
+} LV2UI_Descriptor;
+
+/**
+ Feature/interface for resizable UIs (LV2_UI__resize).
+
+ This structure is used in two ways: as a feature passed by the host via
+ LV2UI_Descriptor::instantiate(), or as an interface provided by a UI via
+ LV2UI_Descriptor::extension_data()).
+*/
+typedef struct _LV2UI_Resize {
+ /**
+ Pointer to opaque data which must be passed to ui_resize().
+ */
+ LV2UI_Feature_Handle handle;
+
+ /**
+ Request/advertise a size change.
+
+ When provided by the host, the UI may call this function to inform the
+ host about the size of the UI.
+
+ When provided by the UI, the host may call this function to notify the
+ UI that it should change its size accordingly. In this case, the host
+ must pass the LV2UI_Handle to provide access to the UI instance.
+
+ @return 0 on success.
+ */
+ int (*ui_resize)(LV2UI_Feature_Handle handle, int width, int height);
+} LV2UI_Resize;
+
+/**
+ Feature to map port symbols to UIs.
+
+ This can be used by the UI to get the index for a port with the given
+ symbol. This makes it possible to implement and distribute a UI separately
+ from the plugin (since symbol, unlike index, is a stable port identifier).
+*/
+typedef struct _LV2UI_Port_Map {
+ /**
+ Pointer to opaque data which must be passed to port_index().
+ */
+ LV2UI_Feature_Handle handle;
+
+ /**
+ Get the index for the port with the given `symbol`.
+
+ @return The index of the port, or LV2UI_INVALID_PORT_INDEX if no such
+ port is found.
+ */
+ uint32_t (*port_index)(LV2UI_Feature_Handle handle, const char* symbol);
+} LV2UI_Port_Map;
+
+/**
+ Feature to subscribe to port updates (LV2_UI__portSubscribe).
+*/
+typedef struct _LV2UI_Port_Subscribe {
+ /**
+ Pointer to opaque data which must be passed to subscribe() and
+ unsubscribe().
+ */
+ LV2UI_Feature_Handle handle;
+
+ /**
+ Subscribe to updates for a port.
+
+ This means that the host will call the UI's port_event() function when
+ the port value changes (as defined by protocol).
+
+ Calling this function with the same `port_index` and `port_protocol`
+ as an already active subscription has no effect.
+
+ @param handle The handle field of this struct.
+ @param port_index The index of the port.
+ @param port_protocol The URID of the ui:PortProtocol.
+ @param features Features for this subscription.
+ @return 0 on success.
+ */
+ uint32_t (*subscribe)(LV2UI_Feature_Handle handle,
+ uint32_t port_index,
+ uint32_t port_protocol,
+ const LV2_Feature* const* features);
+
+ /**
+ Unsubscribe from updates for a port.
+
+ This means that the host will cease calling calling port_event() when
+ the port value changes.
+
+ Calling this function with a `port_index` and `port_protocol` that
+ does not refer to an active port subscription has no effect.
+
+ @param handle The handle field of this struct.
+ @param port_index The index of the port.
+ @param port_protocol The URID of the ui:PortProtocol.
+ @param features Features for this subscription.
+ @return 0 on success.
+ */
+ uint32_t (*unsubscribe)(LV2UI_Feature_Handle handle,
+ uint32_t port_index,
+ uint32_t port_protocol,
+ const LV2_Feature* const* features);
+} LV2UI_Port_Subscribe;
+
+/**
+ A feature to notify the host that the user has grabbed a UI control.
+*/
+typedef struct _LV2UI_Touch {
+ /**
+ Pointer to opaque data which must be passed to ui_resize().
+ */
+ LV2UI_Feature_Handle handle;
+
+ /**
+ Notify the host that a control has been grabbed or released.
+
+ The host should cease automating the port or otherwise manipulating the
+ port value until the control has been ungrabbed.
+
+ @param handle The handle field of this struct.
+ @param port_index The index of the port associated with the control.
+ @param grabbed If true, the control has been grabbed, otherwise the
+ control has been released.
+ */
+ void (*touch)(LV2UI_Feature_Handle handle,
+ uint32_t port_index,
+ bool grabbed);
+} LV2UI_Touch;
+
+/**
+ UI Idle Interface (LV2_UI__idleInterface)
+
+ UIs can provide this interface to have an idle() callback called by the host
+ rapidly to update the UI.
+*/
+typedef struct _LV2UI_Idle_Interface {
+ /**
+ Run a single iteration of the UI's idle loop.
+
+ This will be called rapidly in the UI thread at a rate appropriate
+ for a toolkit main loop. There are no precise timing guarantees, but
+ the host should attempt to call idle() at a high enough rate for smooth
+ animation, at least 30Hz.
+
+ @return non-zero if the UI has been closed, in which case the host
+ should stop calling idle(), and can either completely destroy the UI, or
+ re-show it and resume calling idle().
+ */
+ int (*idle)(LV2UI_Handle ui);
+} LV2UI_Idle_Interface;
+
+/**
+ UI Show Interface (LV2_UI__showInterface)
+
+ UIs can provide this interface to show and hide a window, which allows them
+ to function in hosts unable to embed their widget. This allows any UI to
+ provide a fallback for embedding that works in any host.
+
+ If used:
+ - The host MUST use LV2UI_Idle_Interface to drive the UI.
+ - The UI MUST return non-zero from LV2UI_Idle_Interface::idle() when it has been closed.
+ - If idle() returns non-zero, the host MUST call hide() and stop calling
+ idle(). It MAY later call show() then resume calling idle().
+*/
+typedef struct _LV2UI_Show_Interface {
+ /**
+ Show a window for this UI.
+
+ The window title MAY have been passed by the host to
+ LV2UI_Descriptor::instantiate() as an LV2_Options_Option with key
+ LV2_UI__windowTitle.
+
+ @return 0 on success, or anything else to stop being called.
+ */
+ int (*show)(LV2UI_Handle ui);
+
+ /**
+ Hide the window for this UI.
+
+ @return 0 on success, or anything else to stop being called.
+ */
+ int (*hide)(LV2UI_Handle ui);
+} LV2UI_Show_Interface;
+
+/**
+ Peak data for a slice of time, the update format for ui:peakProtocol.
+*/
+typedef struct _LV2UI_Peak_Data {
+ /**
+ The start of the measurement period. This is just a running counter
+ that is only meaningful in comparison to previous values and must not be
+ interpreted as an absolute time.
+ */
+ uint32_t period_start;
+
+ /**
+ The size of the measurement period, in the same units as period_start.
+ */
+ uint32_t period_size;
+
+ /**
+ The peak value for the measurement period. This should be the maximal
+ value for abs(sample) over all the samples in the period.
+ */
+ float peak;
+} LV2UI_Peak_Data;
+
+/**
+ Prototype for UI accessor function.
+
+ This is the entry point to a UI library, which works in the same way as
+ lv2_descriptor() but for UIs rather than plugins.
+*/
+LV2_SYMBOL_EXPORT
+const LV2UI_Descriptor* lv2ui_descriptor(uint32_t index);
+
+/**
+ The type of the lv2ui_descriptor() function.
+*/
+typedef const LV2UI_Descriptor* (*LV2UI_DescriptorFunction)(uint32_t index);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* LV2_UI_H */
+
+/**
+ @}
+*/
diff --git a/lv2/ui/ui.ttl b/lv2/ui/ui.ttl
new file mode 100644
index 0000000..f0444b5
--- /dev/null
+++ b/lv2/ui/ui.ttl
@@ -0,0 +1,463 @@
+@prefix lv2: <http://lv2plug.in/ns/lv2core#> .
+@prefix owl: <http://www.w3.org/2002/07/owl#> .
+@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+@prefix ui: <http://lv2plug.in/ns/extensions/ui#> .
+@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
+
+<http://lv2plug.in/ns/extensions/ui>
+ a owl:Ontology ;
+ owl:imports <http://lv2plug.in/ns/lv2core> ;
+ rdfs:seeAlso <ui.h> ,
+ <lv2-ui.doap.ttl> ;
+ lv2:documentation """
+<p>This extension is used to create User Interfaces (UIs) for LV2 plugins.</p>
+
+<p>UIs are implemented as an LV2UI_Descriptor loaded via lv2ui_descriptor() in
+a shared library, and are distributed in bundles just like plugins. See the <a
+href="../../../doc/html/ui_8h.html">API reference</a> for details on the C
+API.</p>
+
+<p>UIs are associated with plugins in data:</p>
+
+<pre class="turtle-code">
+@prefix ui: &lt;http://lv2plug.in/ns/extensions/ui#&gt; .
+
+&lt;http://my.plugin&gt; ui:ui &lt;http://my.pluginui&gt; .
+&lt;http://my.pluginui&gt; a ui:GtkUI ;
+ ui:binary &lt;myui.so&gt; .
+</pre>
+
+<p>where &lt;http://my.plugin&gt; is the URI of the plugin,
+&lt;http://my.pluginui&gt; is the URI of the plugin UI and &lt;myui.so&gt; is
+the relative URI to the shared object file.</p>
+
+<p>While it is possible to have the plugin UI and the plugin in the same shared
+object file it is probably a good idea to keep them separate so that hosts that
+don't want UIs don't have to load the UI code. A UI MUST specify its class in
+the RDF data (ui:GtkUI in the above example). The class defines what type the
+UI is, e.g. what graphics toolkit it uses. Any type of UI class can be defined
+separately from this extension.</p>
+
+<p>It is possible to have multiple UIs for the same plugin, or to have the UI
+for a plugin in a different bundle from the actual plugin - this way people
+other than the plugin author can write plugin UIs independently without editing
+the original plugin bundle.</p>
+
+<p>Note that the process that loads the shared object file containing the UI
+code and the process that loads the shared object file containing the actual
+plugin implementation are not necessarily the same process (and not even
+necessarily on the same machine). This means that plugin and UI code MUST NOT
+use singletons and global variables and expect them to refer to the same
+objects in the UI and the actual plugin. The function callback interface
+defined in this header is the only method of communication between UIs and
+plugin instances (extensions may define more, though this is discouraged unless
+absolutely necessary since the significant benefits of network transparency and
+serialisability are lost).</p>
+
+<p>UI functionality may be extended via features, much like plugins:</p>
+
+<pre class="turtle-code">
+&lt;http://my.pluginui&gt; lv2:requiredFeature &lt;http://my.feature&gt; .
+&lt;http://my.pluginui&gt; lv2:optionalFeature &lt;http://my.feature&gt; .
+</pre>
+
+<p>The rules for a UI with a required or optional feature are identical to
+those of lv2:Plugin instances: if a UI declares a feature as required, the host
+is NOT allowed to load it unless it supports that feature; and if it does
+support a feature, it MUST pass an appropriate LV2_Feature struct to the UI's
+instantiate() method. This extension defines several standard features for
+common functionality.</p>
+
+<p>UIs written to this specification do not need to be thread-safe. All
+functions may only be called in the <q>UI thread</q>. There is only one UI
+thread (for toolkits, the one the UI main loop runs in). There is no
+requirement that a <q>UI</q> actually be a graphical widget.</p>
+
+<p>Note that UIs are completely separate from plugins. From the plugin's
+perspective, control from a UI is indistinguishable from any other control, as
+it all occcurs via ports.</p>
+""" .
+
+ui:UI
+ a rdfs:Class ,
+ owl:Class ;
+ rdfs:label "User Interface" ;
+ rdfs:comment "A UI for an LV2 plugin" .
+
+ui:GtkUI
+ a rdfs:Class ,
+ owl:Class ;
+ rdfs:subClassOf ui:UI ;
+ rdfs:label "GTK2 UI" ;
+ rdfs:comment """A UI where the LV2_Widget is a pointer to a Gtk+ 2.0 compatible GtkWidget, and the host guarantees that the Gtk+ library has been initialised and the Glib main loop is running before a UI of this type is instantiated.""" .
+
+ui:Gtk3UI
+ a rdfs:Class ,
+ owl:Class ;
+ rdfs:subClassOf ui:UI ;
+ rdfs:label "GTK3 UI" ;
+ rdfs:comment """A UI where the LV2_Widget is a pointer to a Gtk+ 3.0 compatible GtkWidget, and the host guarantees that the Gtk+ library has been initialised and the Glib main loop is running before a UI of this type is instantiated.""" .
+
+ui:Qt4UI
+ a rdfs:Class ,
+ owl:Class ;
+ rdfs:subClassOf ui:UI ;
+ rdfs:label "Qt4 UI" ;
+ rdfs:comment """A UI where the LV2_Widget is a pointer to a Qt4 compatible QWidget, and the host guarantees that the Qt4 library has been initialised and the Qt4 main loop is running before a UI of this type is instantiated.""" .
+
+ui:Qt5UI
+ a rdfs:Class ,
+ owl:Class ;
+ rdfs:subClassOf ui:UI ;
+ rdfs:label "Qt5 UI" ;
+ rdfs:comment """A UI where the LV2_Widget is a pointer to a Qt5 compatible QWidget, and the host guarantees that the Qt5 library has been initialised and the Qt5 main loop is running before a UI of this type is instantiated.""" .
+
+ui:X11UI
+ a rdfs:Class ,
+ owl:Class ;
+ rdfs:subClassOf ui:UI ;
+ rdfs:label "X11 UI" ;
+ rdfs:comment """A UI where the LV2_Widget is an X11 window ID. Note this is actually an integer, i.e. the LV2_Widget is not a pointer to an X11 window ID, but should be itself taken as an integer value. This is the native UI type on most POSIX systems.""" .
+
+ui:WindowsUI
+ a rdfs:Class ,
+ owl:Class ;
+ rdfs:subClassOf ui:UI ;
+ rdfs:label "Windows UI" ;
+ rdfs:comment """A UI where the LV2_Widget is a Windows HWND window ID. Note this is actually an unsigned 32-bit integer, i.e. the LV2_Widget is not a pointer to a HWND but should be interpreted as an HWND itself. This is the native UI type on Microsoft Windows.""" .
+
+ui:CocoaUI
+ a rdfs:Class ,
+ owl:Class ;
+ rdfs:subClassOf ui:UI ;
+ rdfs:label "Cocoa UI" ;
+ rdfs:comment """A UI where the LV2_Widget is a pointer to a NSView, the basic view type for the Cocoa API (formerly OpenStep). This is the native UI type on Mac OS X.""" .
+
+ui:ui
+ a rdf:Property ;
+ rdfs:domain lv2:Plugin ;
+ rdfs:range ui:UI ;
+ rdfs:label "user interface" ;
+ rdfs:comment """Relates a plugin to a UI that applies to it.""" .
+
+ui:binary
+ a rdf:Property ;
+ owl:sameAs lv2:binary ;
+ owl:deprecated "true"^^xsd:boolean ;
+ rdfs:label "binary" ;
+ rdfs:comment """The shared library a UI resides in. This property is redundant, new UIs SHOULD use lv2:binary, however hosts MUST still support ui:binary at this time.""" .
+
+ui:makeSONameResident
+ a lv2:Feature ;
+ owl:deprecated "true"^^xsd:boolean ;
+ lv2:documentation """
+<p>DEPRECATED</p>
+
+<p>This feature was intended to support UIs that link against toolkit
+libraries which may not be unloaded during the lifetime of the host.
+This is better achieved by using the appropriate flags when linking the
+UI, e.g. <code>gcc -Wl,-z,nodelete</code>.</p>
+""" .
+
+ui:noUserResize
+ a lv2:Feature ;
+ lv2:documentation """
+<p>If a UI requires this feature it indicates that it does not make sense
+to let the user resize the main widget, and the host should prevent that.
+This feature may not make sense for all UI types. The data pointer for the
+LV2_Feature for this feature should always be set to NULL.</p>
+""" .
+
+ui:fixedSize
+ a lv2:Feature ;
+ lv2:documentation """
+<p>If a UI requires this feature it indicates the same thing as
+ui:noUserResize, and additionally it means that the UI will not resize
+the main widget on its own - it will always remain the same size (e.g. a
+pixmap based GUI). This feature may not make sense for all UI types.
+The data pointer for the LV2_Feature for this feature should always be set
+to NULL.</p>
+""" .
+
+ui:parent
+ a lv2:Feature ;
+ lv2:documentation """
+<p>The parent for the UI.</p>
+
+<p>This feature can be used to pass a parent (e.g. a widget, container, canvas,
+etc.) the UI should be a child of. The format of data pointer of this feature
+is determined by the UI type, and is generally the same type as the LV2_Widget
+the UI would return (e.g. for a GtkUI the data would be a pointer to a
+GtkWidget which is a GtkContainer). This is particularly useful for
+cross-toolkit embedding, where the parent often must be known at construction
+time for embedding to work correctly. UIs should not require this feature
+unless it is absolutely necessary for them to work at all.</p>
+""" .
+
+ui:PortNotification
+ a rdfs:Class ,
+ owl:Class ;
+ rdfs:subClassOf [
+ a owl:Restriction ;
+ owl:onProperty ui:plugin ;
+ owl:cardinality 1 ;
+ rdfs:comment "A PortNotification MUST have exactly one ui:plugin." ;
+ ] ;
+ lv2:documentation """
+<p>A port notification. This describes which ports the host must send
+notifications to the UI about. The port can be specific by index, using the
+ui:portIndex property, or symbol, using the lv2:symbol property. Since port
+indices are not guaranteed to be stable between different revisions (or even
+instantiations) of a plugin, symbol is recommended, and index may only be used
+by UIs shipped in the same bundle as the plugin.</p>
+
+<p>A ui:PortNotification MUST have either a ui:portIndex or a lv2:symbol to
+indicate which port it refers to.</p>
+""" .
+
+ui:portNotification
+ a rdf:Property ,
+ owl:ObjectProperty ;
+ rdfs:domain ui:UI ;
+ rdfs:range ui:PortNotification ;
+ rdfs:label "port notification" ;
+ lv2:documentation """
+<p>Indicates that a UI should receive notification (via
+LV2UI_Descriptor::port_event()) when a particular port's value changes.</p>
+
+<p>For example:</p>
+<pre class="turtle-code">
+eg:ui
+ a ui:GtkUI ;
+ ui:portNotification [
+ ui:plugin eg:plugin ;
+ lv2:symbol "gain" ;
+ ui:protocol ui:floatProtocol
+ ] .
+</pre>
+""" .
+
+ui:plugin
+ a rdf:Property ,
+ owl:ObjectProperty ;
+ rdfs:domain ui:PortNotification ;
+ rdfs:range lv2:Plugin ;
+ rdfs:label "plugin" ;
+ rdfs:comment "The plugin a portNotification applies to." .
+
+ui:portIndex
+ a rdf:Property ,
+ owl:DatatypeProperty ;
+ rdfs:domain ui:PortNotification ;
+ rdfs:range xsd:decimal ;
+ rdfs:label "port index" ;
+ rdfs:comment "The index of the port a portNotification applies to." .
+
+ui:notifyType
+ a rdf:Property ;
+ rdfs:domain ui:PortNotification ;
+ rdfs:label "notify type" ;
+ lv2:documentation """
+<p>Indicates a particular type that the UI should be notified of. In the case
+of ports where several types of data can be present (e.g. event ports), this
+can be used to indicate that only a particular type of data should cause
+notification. This is useful where port traffic is very dense, but only a
+certain small number of events are actually of interest to the UI.</p>
+""" .
+
+ui:resize
+ a lv2:Feature ,
+ lv2:ExtensionData ;
+ lv2:documentation """
+<p>A feature that allows the UI to notify the host about its current size, or
+request a size change. This feature corresponds to the LV2UI_Resize struct,
+which should be passed with the URI LV2_UI__resize. This struct may also be
+provided by the UI as extension data using the same URI, in which case it is
+used by the host to request that the UI change its size.</p>
+""" .
+
+ui:portMap
+ a lv2:Feature ;
+ lv2:documentation """
+<p>A feature for accessing the index of a port by symbol. This makes it
+possible to implement and distribute UIs separately from the plugin binaries
+they control. This feature corresponds to the LV2UI_Port_Index struct, which
+should be passed with the URI LV2_UI__portIndex.</p>
+""" .
+
+ui:portSubscribe
+ a lv2:Feature ;
+ lv2:documentation """
+<p>A feature for dynamically subscribing to updates from a port. This makes it
+possible for a UI to explicitly request a particular style of update from a
+port at run-time, in a more flexible and powerful way than listing
+subscriptions statically allows. This feature corresponds to the
+LV2UI_Port_Subscribe struct, which should be passed with the URI
+LV2_UI__portSubscribe.</p>
+""" .
+
+ui:touch
+ a lv2:Feature ;
+ lv2:documentation """
+<p>A feature to notify the host that the user has grabbed a particular port
+control. This is useful for automation, so the host can allow the user to take
+control of a port, even if that port would otherwise be automated (much like
+grabbing a physical morotised fader). It can also be used for MIDI learn or in
+any other situation where the host needs to do something with a particular
+control and it would be convenient for the user to select it directly from the
+plugin UI. This feature corresponds to the LV2UI_Touch struct, which
+should be passed with the URI LV2_UI__touch.</p>
+""" .
+
+ui:idleInterface
+ a lv2:Feature ,
+ lv2:ExtensionData ;
+ lv2:documentation """
+<p>A feature that provides a callback for the host to call rapidly to drive the
+UI. To support this feature, the UI should list it as a lv2:optionalFeature or
+lv2:requiredFeature in its data, and also as lv2:extensionData. When the UI's
+extension_data() is called with this URI (LV2_UI__idleInterface), it should
+return a pointer to an LV2UI_Idle_Interface.</p>
+
+<p>To indicate support, the host should pass a feature to instantiate() with
+this URI, with NULL for data.</p>
+""" .
+
+ui:showInterface
+ a lv2:ExtensionData ;
+ lv2:documentation """
+<p>An interface for showing and hiding a window for a UI. This allows UIs to
+gracefully degrade to separate windows when the host is unable to embed the UI
+widget for whatever reason. When the UI's extension_data() is called with this
+URI (LV2_UI__showInterface), it should return a pointer to an
+LV2UI_Show_Interface.</p>
+""" .
+
+ui:windowTitle
+ a rdf:Property ;
+ rdfs:range xsd:string ;
+ rdfs:label "window title" ;
+ rdfs:comment "The title for the window shown by LV2UI_Show_Interface." .
+
+ui:updateRate
+ a rdf:Property ;
+ rdfs:range xsd:float ;
+ rdfs:label "update rate" ;
+ rdfs:comment "The target rate, in Hz, to send updates to the UI." .
+
+ui:protocol
+ a rdf:Property ;
+ rdfs:domain ui:PortNotification ;
+ rdfs:range ui:PortProtocol ;
+ rdfs:label "protocol" ;
+ rdfs:comment "The protocol to be used for this notification." .
+
+ui:PortProtocol
+ a rdfs:Class ;
+ rdfs:subClassOf lv2:Feature ;
+ rdfs:label "Port Protocol" ;
+ lv2:documentation """
+<p>A PortProtocol defines a method to communicate port data between a UI and
+plugin.</p>
+
+<p>Any PortProtocol MUST define:</p>
+<table>
+<tr><th>Port Type</th>
+ <td>Which plugin port types the buffer type is valid for.</td></tr>
+<tr><th>Feature Data</th>
+ <td>What data (if any) should be passed in the LV2_Feature.</td></tr>
+</table>
+
+<p>Any PortProtocol for an output port MUST define:</p>
+<table>
+<tr><th>Update Frequency</th>
+ <td>When the host should call port_event().</td></tr>
+<tr><th>Update Format</th>
+ <td>The format of the data in the buffer passed to port_event().</td></tr>
+<tr><th>Options</th>
+ <td>The format of the options passed to subscribe() and unsubscribe().</td>
+</tr></table>
+
+<p>Any PortProtocol for an input port MUST define:</p>
+<table>
+<tr><th>Write Format</th>
+ <td>The format of the data in the buffer passed to write_port().</td></tr>
+<tr><th>Write Effect</th>
+ <td>What happens when the UI calls write_port().</td></tr>
+</table>
+
+<p>For an example, see ui:floatProtocol or ui:peakProtocol.
+</p>
+
+<p>PortProtocol is a subclass of lv2:Feature, so UIs use lv2:optionalFeature and
+lv2:requiredFeature to specify which PortProtocols they want to use.
+</p>
+""" .
+
+ui:floatProtocol
+ a ui:PortProtocol ;
+ rdfs:label "floating point value" ;
+ lv2:documentation """
+
+<p>A protocol for transferring single floating point values. The rules for
+this protocol are:</p>
+<table>
+<tr><th>Port Type</th>
+ <td>lv2:ControlPort</td></tr>
+<tr><th>Feature Data</th>
+ <td>None.</td></tr>
+<tr><th>Update Frequency</th>
+ <td>The host SHOULD call port_event() as soon as possible when the port
+ value has changed, but there are no timing guarantees.</td></tr>
+<tr><th>Update Format</th>
+ <td>A single <code>float</code>.</td></tr>
+<tr><th>Options</th>
+ <td>None.</td></tr>
+<tr><th>Write Format</th>
+ <td>A single <code>float</code>.</td></tr>
+<tr><th>Write Effect</th>
+ <td>The host SHOULD set the port to the received value as soon as possible,
+ but there is no guarantee that run() actually sees this value.</td></tr>
+</table>
+""" .
+
+ui:peakProtocol
+ a ui:PortProtocol ;
+ rdfs:label "peak measurement for a period of audio" ;
+ lv2:documentation """
+<p>This port protocol defines a way for the host to send continuous peak
+measurements of the audio signal at a certain port to the UI. The
+intended use is visualisation, e.g. an animated meter widget that shows
+the level of the audio input or output.</p>
+
+<p>A contiguous sequence of audio samples for which a peak value has been
+computed is called a <em>measurement period</em>.</p>
+
+<p>The rules for this protocol are:</p>
+<table>
+<tr><th>Port Type</th>
+ <td>lv2:AudioPort</td></tr>
+<tr><th>Feature Data</th>
+ <td>None.</td></tr>
+<tr><th>Update Frequency</th>
+ <td>The host SHOULD call port_event() at regular intervals. The
+ measurement periods used for calls to port_event() for the same port SHOULD
+ be contiguous (i.e. the measurement period for one call should begin right
+ after the end of the measurement period for the previous call ends) unless
+ the UI has removed and re-added the port subscription between those calls.
+ However, UIs MUST NOT depend on either the regularity of the calls or the
+ contiguity of the measurement periods; hosts may change the call rate or
+ skip calls for performance or other reasons. Measurement periods for
+ different calls to port_event() for the same port MUST NOT
+ overlap.</td></tr>
+<tr><th>Update Format</th>
+ <td>A single LV2UI_Peak_Data object.</td></tr>
+<tr><th>Options</th>
+ <td>None.</td></tr>
+<tr><th>Write Format</th>
+ <td>None.</td></tr>
+<tr><th>Write Effect</th>
+ <td>None.</td></tr>
+</table>
+""" .